Running ‘000.sessionDetails.R’ [0s/1s]
  Running ‘ClusterRegistry.R’ [2s/12s]
  Running ‘Future-class.R’ [1s/5s]
  Running ‘FutureError.R’ [1s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/5s]
  Running ‘availableCores.R’ [0s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/1s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [5s/34s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [7s/14s]
  Running ‘dotdotdot.R’ [1s/6s]
  Running ‘early-signaling.R’ [2s/13s]
  Running ‘future,labels.R’ [1s/2s]
  Running ‘future.R’ [1s/2s]
  Running ‘futureAssign.R’ [2s/6s]
  Running ‘futureAssign_OP.R’ [2s/8s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/2s]
  Running ‘futureCall.R’ [3s/11s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [0s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [11s/33s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [3s/9s]
  Running ‘globals,manual.R’ [2s/3s]
  Running ‘globals,resolve.R’ [1s/5s]
  Running ‘globals,subassignment.R’ [3s/8s]
  Running ‘globals,toolarge.R’ [1s/4s]
  Running ‘globals,tricky.R’ [6s/14s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [0s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [1s/5s]
  Running ‘makeClusterPSOCK.R’ [1s/3s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [0s/1s]
  Running ‘multicore,multithreading.R’ [1s/1s]
  Running ‘multicore.R’ [1s/2s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [3s/15s]
  Running ‘nbrOfWorkers.R’ [3s/15s]
  Running ‘nested_futures,mc.cores.R’ [4s/28s]
  Running ‘nested_futures.R’ [1s/1s]
  Running ‘non-exportable,connections.R’ [1s/5s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [2s/5s]
  Running ‘relaying.R’ [1s/3s]
  Running ‘remote.R’ [1s/5s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/12s]
  Running ‘reserved-keyword-functions.R’ [1s/2s]
  Running ‘resolve.R’ [2s/5s]
  Running ‘resolved-non-blocking-test.R’ [2s/35s]
  Running ‘rng.R’ [9s/19s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/8s]
  Running ‘stdout.R’ [2s/5s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [1s/2s]
  Running ‘uuid.R’ [1s/2s]
  Running ‘whichIndex.R’ [1s/1s]
Running the tests in ‘tests/futures.R’ failed.
Complete output:
  > source("incl/start.R")
  [21:25:23.485] plan(): Setting new future strategy stack:
  [21:25:23.486] List of future strategies:
  [21:25:23.486] 1. sequential:
  [21:25:23.486]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.486]    - tweaked: FALSE
  [21:25:23.486]    - call: future::plan("sequential")
  [21:25:23.488] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > 
  > ## Backward compatibility
  > if (getRversion() < "3.2.0") {
  +   names <- function(x) {
  +     if (class(x)[1] == "environment") {
  +       ls(envir = x, all.names = TRUE)
  +     } else {
  +       base::names(x)
  +     }
  +   }
  + }
  > 
  > dims <- list(
  +   NULL,
  +   c(1, 6),
  +   c(2, 3),
  +   c(2, 3, 1),
  +   c(2, 1, 3, 1)
  + )
  > 
  > 
  > message("*** futures() / resolved() / values() ...")
  *** futures() / resolved() / values() ...
  > 
  > for (cores in 1:availCores) {
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  + 
  +   for (type in c("list", "environment", "listenv")) {
  +     message(sprintf("Type of object: %s", type))
  + 
  +     for (strategy in supportedStrategies(cores, excl = "multiprocess")) {
  +       message("Type of future: ", strategy)
  +       plan(strategy)
  + 
  +       for (dim in dims) {
  +         message("Dimensions: ", deparse(dim))
  + 
  +         if (type == "list") {
  +           x <- list()
  +         } else if (type == "listenv") {
  +           x <- listenv()
  +         } else if (type == "environment") {
  +           x <- new.env()
  +         }
  + 
  +         x$a <- 1
  +         x$b <- future(2)
  +         x$c <- future(NULL)
  +         if (type != "list") x$d %<-% { 4 }
  +         if (type != "environment") x[[6]] <- 6
  +         str(x)
  + 
  +         if (!is.null(dim)) {
  +           if (type != "environment") {
  +             names <- names(x)
  +             dim(x) <- dim
  +             dimnames(x) <- lapply(dim, FUN = function(n) letters[1:n])
  +             names(x) <- names
  +           }
  +         }
  + 
  +         f <- futures(x)
  +         str(f)
  +         if (type != "environment") {
  +           stopifnot(length(f) == length(x))
  +           stopifnot(identical(names(f), names(x)))
  +         }
  +         stopifnot(identical(dim(f), dim(x)))
  +         stopifnot(identical(dimnames(f), dimnames(x)))
  + 
  +         r <- resolved(x)
  +         str(r)
  +         if (type != "environment") {
  +           stopifnot(length(r) == length(x))
  +           stopifnot(identical(names(r), names(x)))
  +         }
  +         stopifnot(identical(dim(r), dim(x)))
  +         stopifnot(identical(dimnames(r), dimnames(x)))
  + 
  +         v <- values(x)
  +         str(v)
  +         if (type != "environment") {
  +           stopifnot(length(v) == length(x))
  +           stopifnot(identical(names(v), names(x)))
  +         }
  +         stopifnot(identical(dim(v), dim(x)))
  +         stopifnot(identical(dimnames(v), dimnames(x)))
  +       } # for (dim ...)
  +     } # for (strategy ...)
  + 
  +     message(sprintf("*** futures() - %s ... DONE", type))
  +   } # for (type ...)
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  Type of object: list
  Type of future: sequential
  [21:25:23.810] plan(): Setting new future strategy stack:
  [21:25:23.811] List of future strategies:
  [21:25:23.811] 1. sequential:
  [21:25:23.811]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.811]    - tweaked: FALSE
  [21:25:23.811]    - call: plan(strategy)
  [21:25:23.876] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [21:25:23.878] getGlobalsAndPackages() ...
  [21:25:23.878] Searching for globals...
  [21:25:23.898] 
  [21:25:23.898] Searching for globals ... DONE
  [21:25:23.899] - globals: [0] <none>
  [21:25:23.899] getGlobalsAndPackages() ... DONE
  [21:25:23.902] Packages needed by the future expression (n = 0): <none>
  [21:25:23.902] Packages needed by future strategies (n = 0): <none>
  [21:25:23.907] {
  [21:25:23.907]     {
  [21:25:23.907]         ...future.startTime <- base::Sys.time()
  [21:25:23.907]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:23.907]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:23.907]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:23.907]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:23.907]             future.resolve.recursive = NULL, width = 80L)
  [21:25:23.907]         {
  [21:25:23.907]             {
  [21:25:23.907]                 base::local({
  [21:25:23.907]                   has_future <- base::requireNamespace("future", 
  [21:25:23.907]                     quietly = TRUE)
  [21:25:23.907]                   version <- if (has_future) 
  [21:25:23.907]                     utils::packageVersion("future")
  [21:25:23.907]                   else NULL
  [21:25:23.907]                   if (!has_future || version < "1.8.0") {
  [21:25:23.907]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:23.907]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:23.907]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:23.907]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:23.907]                         "release", "version")], collapse = " "), 
  [21:25:23.907]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:23.907]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:23.907]                       info)
  [21:25:23.907]                     info <- base::paste(info, collapse = "; ")
  [21:25:23.907]                     if (!has_future) {
  [21:25:23.907]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:23.907]                         info)
  [21:25:23.907]                     }
  [21:25:23.907]                     else {
  [21:25:23.907]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:23.907]                         info, version)
  [21:25:23.907]                     }
  [21:25:23.907]                     base::stop(msg)
  [21:25:23.907]                   }
  [21:25:23.907]                 })
  [21:25:23.907]             }
  [21:25:23.907]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:23.907]         }
  [21:25:23.907]     }
  [21:25:23.907]     if (base::is.na(TRUE)) {
  [21:25:23.907]     }
  [21:25:23.907]     else {
  [21:25:23.907]         if (TRUE) {
  [21:25:23.907]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:23.907]                 open = "w")
  [21:25:23.907]         }
  [21:25:23.907]         else {
  [21:25:23.907]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:23.907]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:23.907]         }
  [21:25:23.907]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:23.907]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:23.907]             base::sink(type = "output", split = FALSE)
  [21:25:23.907]             base::close(...future.stdout)
  [21:25:23.907]         }, add = TRUE)
  [21:25:23.907]     }
  [21:25:23.907]     ...future.frame <- base::sys.nframe()
  [21:25:23.907]     ...future.conditions <- base::list()
  [21:25:23.907]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:23.907]     ...future.result <- base::tryCatch({
  [21:25:23.907]         base::withCallingHandlers({
  [21:25:23.907]             ...future.value <- base::withVisible(base::local(2))
  [21:25:23.907]             future::FutureResult(value = ...future.value$value, 
  [21:25:23.907]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:23.907]                   ...future.rng), started = ...future.startTime, 
  [21:25:23.907]                 version = "1.8")
  [21:25:23.907]         }, condition = base::local({
  [21:25:23.907]             c <- base::c
  [21:25:23.907]             inherits <- base::inherits
  [21:25:23.907]             invokeRestart <- base::invokeRestart
  [21:25:23.907]             length <- base::length
  [21:25:23.907]             list <- base::list
  [21:25:23.907]             seq.int <- base::seq.int
  [21:25:23.907]             signalCondition <- base::signalCondition
  [21:25:23.907]             sys.calls <- base::sys.calls
  [21:25:23.907]             Sys.time <- base::Sys.time
  [21:25:23.907]             `[[` <- base::`[[`
  [21:25:23.907]             `+` <- base::`+`
  [21:25:23.907]             `<<-` <- base::`<<-`
  [21:25:23.907]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:23.907]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:23.907]                   3L)]
  [21:25:23.907]             }
  [21:25:23.907]             function(cond) {
  [21:25:23.907]                 if (inherits(cond, "error")) {
  [21:25:23.907]                   sessionInformation <- function() {
  [21:25:23.907]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:23.907]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:23.907]                       search = base::search(), system = base::Sys.info())
  [21:25:23.907]                   }
  [21:25:23.907]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:23.907]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:23.907]                     cond$call), session = sessionInformation(), 
  [21:25:23.907]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:23.907]                   signalCondition(cond)
  [21:25:23.907]                 }
  [21:25:23.907]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:23.907]                 ))) {
  [21:25:23.907]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:23.907]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:23.907]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:23.907]                   if (!signal) {
  [21:25:23.907]                     muffleCondition <- function (cond) 
  [21:25:23.907]                     {
  [21:25:23.907]                       inherits <- base::inherits
  [21:25:23.907]                       invokeRestart <- base::invokeRestart
  [21:25:23.907]                       muffled <- FALSE
  [21:25:23.907]                       if (inherits(cond, "message")) {
  [21:25:23.907]                         invokeRestart("muffleMessage")
  [21:25:23.907]                         muffled <- TRUE
  [21:25:23.907]                       }
  [21:25:23.907]                       else if (inherits(cond, "warning")) {
  [21:25:23.907]                         invokeRestart("muffleWarning")
  [21:25:23.907]                         muffled <- TRUE
  [21:25:23.907]                       }
  [21:25:23.907]                       else if (inherits(cond, "condition")) {
  [21:25:23.907]                         computeRestarts <- base::computeRestarts
  [21:25:23.907]                         grepl <- base::grepl
  [21:25:23.907]                         is.null <- base::is.null
  [21:25:23.907]                         restarts <- computeRestarts(cond)
  [21:25:23.907]                         for (restart in restarts) {
  [21:25:23.907]                           name <- restart$name
  [21:25:23.907]                           if (is.null(name)) 
  [21:25:23.907]                             next
  [21:25:23.907]                           if (!grepl("^muffle", name)) 
  [21:25:23.907]                             next
  [21:25:23.907]                           invokeRestart(restart)
  [21:25:23.907]                           muffled <- TRUE
  [21:25:23.907]                           break
  [21:25:23.907]                         }
  [21:25:23.907]                       }
  [21:25:23.907]                       invisible(muffled)
  [21:25:23.907]                     }
  [21:25:23.907]                     muffleCondition(cond)
  [21:25:23.907]                   }
  [21:25:23.907]                 }
  [21:25:23.907]             }
  [21:25:23.907]         }))
  [21:25:23.907]     }, error = function(ex) {
  [21:25:23.907]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:23.907]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:23.907]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:23.907]     }, finally = {
  [21:25:23.907]         {
  [21:25:23.907]             NULL
  [21:25:23.907]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:23.907]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:23.907]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:23.907]                 label = NULL, ...) 
  [21:25:23.907]             {
  [21:25:23.907]                 if (substitute) 
  [21:25:23.907]                   expr <- substitute(expr)
  [21:25:23.907]                 local <- as.logical(local)
  [21:25:23.907]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:23.907]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:23.907]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:23.907]                   label = label, ...)
  [21:25:23.907]                 if (!future$lazy) 
  [21:25:23.907]                   future <- run(future)
  [21:25:23.907]                 invisible(future)
  [21:25:23.907]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:23.907]         }
  [21:25:23.907]         base::options(...future.oldOptions)
  [21:25:23.907]     })
  [21:25:23.907]     Sys.time
  [21:25:23.907]     if (base::is.na(TRUE)) {
  [21:25:23.907]     }
  [21:25:23.907]     else {
  [21:25:23.907]         base::sink(type = "output", split = FALSE)
  [21:25:23.907]         if (TRUE) {
  [21:25:23.907]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:23.907]         }
  [21:25:23.907]         else {
  [21:25:23.907]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:23.907]         }
  [21:25:23.907]         base::close(...future.stdout)
  [21:25:23.907]         ...future.stdout <- NULL
  [21:25:23.907]     }
  [21:25:23.907]     ...future.result$conditions <- ...future.conditions
  [21:25:23.907]     ...future.result
  [21:25:23.907] }
  [21:25:23.912] plan(): Setting new future strategy stack:
  [21:25:23.913] List of future strategies:
  [21:25:23.913] 1. sequential:
  [21:25:23.913]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.913]    - tweaked: FALSE
  [21:25:23.913]    - call: NULL
  [21:25:23.930] plan(): nbrOfWorkers() = 1
  [21:25:23.931] plan(): Setting new future strategy stack:
  [21:25:23.932] List of future strategies:
  [21:25:23.932] 1. sequential:
  [21:25:23.932]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.932]    - tweaked: FALSE
  [21:25:23.932]    - call: plan(strategy)
  [21:25:23.933] plan(): nbrOfWorkers() = 1
  [21:25:23.934] SequentialFuture started (and completed)
  [21:25:23.935] getGlobalsAndPackages() ...
  [21:25:23.935] Searching for globals...
  [21:25:23.936] 
  [21:25:23.936] Searching for globals ... DONE
  [21:25:23.936] - globals: [0] <none>
  [21:25:23.937] getGlobalsAndPackages() ... DONE
  [21:25:23.938] Packages needed by the future expression (n = 0): <none>
  [21:25:23.939] Packages needed by future strategies (n = 0): <none>
  [21:25:23.943] {
  [21:25:23.943]     {
  [21:25:23.943]         ...future.startTime <- base::Sys.time()
  [21:25:23.943]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:23.943]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:23.943]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:23.943]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:23.943]             future.resolve.recursive = NULL, width = 80L)
  [21:25:23.943]         {
  [21:25:23.943]             {
  [21:25:23.943]                 base::local({
  [21:25:23.943]                   has_future <- base::requireNamespace("future", 
  [21:25:23.943]                     quietly = TRUE)
  [21:25:23.943]                   version <- if (has_future) 
  [21:25:23.943]                     utils::packageVersion("future")
  [21:25:23.943]                   else NULL
  [21:25:23.943]                   if (!has_future || version < "1.8.0") {
  [21:25:23.943]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:23.943]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:23.943]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:23.943]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:23.943]                         "release", "version")], collapse = " "), 
  [21:25:23.943]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:23.943]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:23.943]                       info)
  [21:25:23.943]                     info <- base::paste(info, collapse = "; ")
  [21:25:23.943]                     if (!has_future) {
  [21:25:23.943]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:23.943]                         info)
  [21:25:23.943]                     }
  [21:25:23.943]                     else {
  [21:25:23.943]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:23.943]                         info, version)
  [21:25:23.943]                     }
  [21:25:23.943]                     base::stop(msg)
  [21:25:23.943]                   }
  [21:25:23.943]                 })
  [21:25:23.943]             }
  [21:25:23.943]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:23.943]         }
  [21:25:23.943]     }
  [21:25:23.943]     if (base::is.na(TRUE)) {
  [21:25:23.943]     }
  [21:25:23.943]     else {
  [21:25:23.943]         if (TRUE) {
  [21:25:23.943]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:23.943]                 open = "w")
  [21:25:23.943]         }
  [21:25:23.943]         else {
  [21:25:23.943]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:23.943]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:23.943]         }
  [21:25:23.943]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:23.943]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:23.943]             base::sink(type = "output", split = FALSE)
  [21:25:23.943]             base::close(...future.stdout)
  [21:25:23.943]         }, add = TRUE)
  [21:25:23.943]     }
  [21:25:23.943]     ...future.frame <- base::sys.nframe()
  [21:25:23.943]     ...future.conditions <- base::list()
  [21:25:23.943]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:23.943]     ...future.result <- base::tryCatch({
  [21:25:23.943]         base::withCallingHandlers({
  [21:25:23.943]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:23.943]             future::FutureResult(value = ...future.value$value, 
  [21:25:23.943]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:23.943]                   ...future.rng), started = ...future.startTime, 
  [21:25:23.943]                 version = "1.8")
  [21:25:23.943]         }, condition = base::local({
  [21:25:23.943]             c <- base::c
  [21:25:23.943]             inherits <- base::inherits
  [21:25:23.943]             invokeRestart <- base::invokeRestart
  [21:25:23.943]             length <- base::length
  [21:25:23.943]             list <- base::list
  [21:25:23.943]             seq.int <- base::seq.int
  [21:25:23.943]             signalCondition <- base::signalCondition
  [21:25:23.943]             sys.calls <- base::sys.calls
  [21:25:23.943]             Sys.time <- base::Sys.time
  [21:25:23.943]             `[[` <- base::`[[`
  [21:25:23.943]             `+` <- base::`+`
  [21:25:23.943]             `<<-` <- base::`<<-`
  [21:25:23.943]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:23.943]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:23.943]                   3L)]
  [21:25:23.943]             }
  [21:25:23.943]             function(cond) {
  [21:25:23.943]                 if (inherits(cond, "error")) {
  [21:25:23.943]                   sessionInformation <- function() {
  [21:25:23.943]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:23.943]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:23.943]                       search = base::search(), system = base::Sys.info())
  [21:25:23.943]                   }
  [21:25:23.943]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:23.943]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:23.943]                     cond$call), session = sessionInformation(), 
  [21:25:23.943]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:23.943]                   signalCondition(cond)
  [21:25:23.943]                 }
  [21:25:23.943]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:23.943]                 ))) {
  [21:25:23.943]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:23.943]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:23.943]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:23.943]                   if (!signal) {
  [21:25:23.943]                     muffleCondition <- function (cond) 
  [21:25:23.943]                     {
  [21:25:23.943]                       inherits <- base::inherits
  [21:25:23.943]                       invokeRestart <- base::invokeRestart
  [21:25:23.943]                       muffled <- FALSE
  [21:25:23.943]                       if (inherits(cond, "message")) {
  [21:25:23.943]                         invokeRestart("muffleMessage")
  [21:25:23.943]                         muffled <- TRUE
  [21:25:23.943]                       }
  [21:25:23.943]                       else if (inherits(cond, "warning")) {
  [21:25:23.943]                         invokeRestart("muffleWarning")
  [21:25:23.943]                         muffled <- TRUE
  [21:25:23.943]                       }
  [21:25:23.943]                       else if (inherits(cond, "condition")) {
  [21:25:23.943]                         computeRestarts <- base::computeRestarts
  [21:25:23.943]                         grepl <- base::grepl
  [21:25:23.943]                         is.null <- base::is.null
  [21:25:23.943]                         restarts <- computeRestarts(cond)
  [21:25:23.943]                         for (restart in restarts) {
  [21:25:23.943]                           name <- restart$name
  [21:25:23.943]                           if (is.null(name)) 
  [21:25:23.943]                             next
  [21:25:23.943]                           if (!grepl("^muffle", name)) 
  [21:25:23.943]                             next
  [21:25:23.943]                           invokeRestart(restart)
  [21:25:23.943]                           muffled <- TRUE
  [21:25:23.943]                           break
  [21:25:23.943]                         }
  [21:25:23.943]                       }
  [21:25:23.943]                       invisible(muffled)
  [21:25:23.943]                     }
  [21:25:23.943]                     muffleCondition(cond)
  [21:25:23.943]                   }
  [21:25:23.943]                 }
  [21:25:23.943]             }
  [21:25:23.943]         }))
  [21:25:23.943]     }, error = function(ex) {
  [21:25:23.943]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:23.943]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:23.943]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:23.943]     }, finally = {
  [21:25:23.943]         {
  [21:25:23.943]             NULL
  [21:25:23.943]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:23.943]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:23.943]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:23.943]                 label = NULL, ...) 
  [21:25:23.943]             {
  [21:25:23.943]                 if (substitute) 
  [21:25:23.943]                   expr <- substitute(expr)
  [21:25:23.943]                 local <- as.logical(local)
  [21:25:23.943]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:23.943]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:23.943]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:23.943]                   label = label, ...)
  [21:25:23.943]                 if (!future$lazy) 
  [21:25:23.943]                   future <- run(future)
  [21:25:23.943]                 invisible(future)
  [21:25:23.943]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:23.943]         }
  [21:25:23.943]         base::options(...future.oldOptions)
  [21:25:23.943]     })
  [21:25:23.943]     Sys.time
  [21:25:23.943]     if (base::is.na(TRUE)) {
  [21:25:23.943]     }
  [21:25:23.943]     else {
  [21:25:23.943]         base::sink(type = "output", split = FALSE)
  [21:25:23.943]         if (TRUE) {
  [21:25:23.943]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:23.943]         }
  [21:25:23.943]         else {
  [21:25:23.943]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:23.943]         }
  [21:25:23.943]         base::close(...future.stdout)
  [21:25:23.943]         ...future.stdout <- NULL
  [21:25:23.943]     }
  [21:25:23.943]     ...future.result$conditions <- ...future.conditions
  [21:25:23.943]     ...future.result
  [21:25:23.943] }
  [21:25:23.964] plan(): Setting new future strategy stack:
  [21:25:23.964] List of future strategies:
  [21:25:23.964] 1. sequential:
  [21:25:23.964]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.964]    - tweaked: FALSE
  [21:25:23.964]    - call: NULL
  [21:25:23.965] plan(): nbrOfWorkers() = 1
  [21:25:23.966] plan(): Setting new future strategy stack:
  [21:25:23.966] List of future strategies:
  [21:25:23.966] 1. sequential:
  [21:25:23.966]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:23.966]    - tweaked: FALSE
  [21:25:23.966]    - call: plan(strategy)
  [21:25:23.967] plan(): nbrOfWorkers() = 1
  [21:25:23.967] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef216dac50> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef227b6610> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef216dac50> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef227b6610> 
   $  : NULL
   $  : NULL
   $  : num 6
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:23.985] resolve() on list ...
  [21:25:23.985]  recursive: 0
  [21:25:23.986]  length: 6
  [21:25:23.991]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:23.991] signalConditionsASAP(numeric, pos=1) ...
  [21:25:23.992] - nx: 6
  [21:25:23.992] - relay: TRUE
  [21:25:23.992] - stdout: TRUE
  [21:25:23.992] - signal: TRUE
  [21:25:23.993] - resignal: FALSE
  [21:25:23.993] - force: TRUE
  [21:25:23.993] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.993] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.994]  - until=2
  [21:25:23.994]  - relaying element #2
  [21:25:23.994] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.995] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.995] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:23.995]  length: 5 (resolved future 1)
  [21:25:23.995] Future #2
  [21:25:23.996] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:23.997] - nx: 6
  [21:25:23.997] - relay: TRUE
  [21:25:23.997] - stdout: TRUE
  [21:25:23.997] - signal: TRUE
  [21:25:23.997] - resignal: FALSE
  [21:25:23.998] - force: TRUE
  [21:25:23.998] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.998] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.998]  - until=2
  [21:25:23.999]  - relaying element #2
  [21:25:23.999] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:23.999] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.000] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:24.000]  length: 4 (resolved future 2)
  [21:25:24.001] Future #3
  [21:25:24.001] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:24.001] - nx: 6
  [21:25:24.001] - relay: TRUE
  [21:25:24.002] - stdout: TRUE
  [21:25:24.002] - signal: TRUE
  [21:25:24.003] - resignal: FALSE
  [21:25:24.003] - force: TRUE
  [21:25:24.003] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.003] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.004]  - until=3
  [21:25:24.004]  - relaying element #3
  [21:25:24.004] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.005] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.005] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:24.005]  length: 3 (resolved future 3)
  [21:25:24.006] signalConditionsASAP(NULL, pos=4) ...
  [21:25:24.006] - nx: 6
  [21:25:24.006] - relay: TRUE
  [21:25:24.006] - stdout: TRUE
  [21:25:24.007] - signal: TRUE
  [21:25:24.007] - resignal: FALSE
  [21:25:24.007] - force: TRUE
  [21:25:24.007] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.007] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.008]  - until=5
  [21:25:24.008]  - relaying element #5
  [21:25:24.008] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.009] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.009] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:24.009]  length: 2 (resolved future 4)
  [21:25:24.009] signalConditionsASAP(NULL, pos=5) ...
  [21:25:24.010] - nx: 6
  [21:25:24.010] - relay: TRUE
  [21:25:24.010] - stdout: TRUE
  [21:25:24.010] - signal: TRUE
  [21:25:24.011] - resignal: FALSE
  [21:25:24.011] - force: TRUE
  [21:25:24.011] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.011] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.012]  - until=6
  [21:25:24.012]  - relaying element #6
  [21:25:24.012] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.012] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.013] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:24.013]  length: 1 (resolved future 5)
  [21:25:24.013] signalConditionsASAP(numeric, pos=6) ...
  [21:25:24.013] - nx: 6
  [21:25:24.014] - relay: TRUE
  [21:25:24.014] - stdout: TRUE
  [21:25:24.014] - signal: TRUE
  [21:25:24.014] - resignal: FALSE
  [21:25:24.015] - force: TRUE
  [21:25:24.015] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.015] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.015]  - until=6
  [21:25:24.016] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.016] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.016] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:24.016]  length: 0 (resolved future 6)
  [21:25:24.017] Relaying remaining futures
  [21:25:24.017] signalConditionsASAP(NULL, pos=0) ...
  [21:25:24.017] - nx: 6
  [21:25:24.017] - relay: TRUE
  [21:25:24.018] - stdout: TRUE
  [21:25:24.018] - signal: TRUE
  [21:25:24.018] - resignal: FALSE
  [21:25:24.018] - force: TRUE
  [21:25:24.019] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.019] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:24.019] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.020] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.020] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:24.020] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [21:25:24.026] getGlobalsAndPackages() ...
  [21:25:24.026] Searching for globals...
  [21:25:24.027] 
  [21:25:24.027] Searching for globals ... DONE
  [21:25:24.027] - globals: [0] <none>
  [21:25:24.028] getGlobalsAndPackages() ... DONE
  [21:25:24.029] Packages needed by the future expression (n = 0): <none>
  [21:25:24.030] Packages needed by future strategies (n = 0): <none>
  [21:25:24.033] {
  [21:25:24.033]     {
  [21:25:24.033]         ...future.startTime <- base::Sys.time()
  [21:25:24.033]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.033]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.033]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.033]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.033]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.033]         {
  [21:25:24.033]             {
  [21:25:24.033]                 base::local({
  [21:25:24.033]                   has_future <- base::requireNamespace("future", 
  [21:25:24.033]                     quietly = TRUE)
  [21:25:24.033]                   version <- if (has_future) 
  [21:25:24.033]                     utils::packageVersion("future")
  [21:25:24.033]                   else NULL
  [21:25:24.033]                   if (!has_future || version < "1.8.0") {
  [21:25:24.033]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.033]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.033]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.033]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.033]                         "release", "version")], collapse = " "), 
  [21:25:24.033]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.033]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.033]                       info)
  [21:25:24.033]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.033]                     if (!has_future) {
  [21:25:24.033]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.033]                         info)
  [21:25:24.033]                     }
  [21:25:24.033]                     else {
  [21:25:24.033]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.033]                         info, version)
  [21:25:24.033]                     }
  [21:25:24.033]                     base::stop(msg)
  [21:25:24.033]                   }
  [21:25:24.033]                 })
  [21:25:24.033]             }
  [21:25:24.033]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.033]         }
  [21:25:24.033]     }
  [21:25:24.033]     if (base::is.na(TRUE)) {
  [21:25:24.033]     }
  [21:25:24.033]     else {
  [21:25:24.033]         if (TRUE) {
  [21:25:24.033]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.033]                 open = "w")
  [21:25:24.033]         }
  [21:25:24.033]         else {
  [21:25:24.033]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.033]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.033]         }
  [21:25:24.033]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.033]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.033]             base::sink(type = "output", split = FALSE)
  [21:25:24.033]             base::close(...future.stdout)
  [21:25:24.033]         }, add = TRUE)
  [21:25:24.033]     }
  [21:25:24.033]     ...future.frame <- base::sys.nframe()
  [21:25:24.033]     ...future.conditions <- base::list()
  [21:25:24.033]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.033]     ...future.result <- base::tryCatch({
  [21:25:24.033]         base::withCallingHandlers({
  [21:25:24.033]             ...future.value <- base::withVisible(base::local(2))
  [21:25:24.033]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.033]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.033]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.033]                 version = "1.8")
  [21:25:24.033]         }, condition = base::local({
  [21:25:24.033]             c <- base::c
  [21:25:24.033]             inherits <- base::inherits
  [21:25:24.033]             invokeRestart <- base::invokeRestart
  [21:25:24.033]             length <- base::length
  [21:25:24.033]             list <- base::list
  [21:25:24.033]             seq.int <- base::seq.int
  [21:25:24.033]             signalCondition <- base::signalCondition
  [21:25:24.033]             sys.calls <- base::sys.calls
  [21:25:24.033]             Sys.time <- base::Sys.time
  [21:25:24.033]             `[[` <- base::`[[`
  [21:25:24.033]             `+` <- base::`+`
  [21:25:24.033]             `<<-` <- base::`<<-`
  [21:25:24.033]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.033]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.033]                   3L)]
  [21:25:24.033]             }
  [21:25:24.033]             function(cond) {
  [21:25:24.033]                 if (inherits(cond, "error")) {
  [21:25:24.033]                   sessionInformation <- function() {
  [21:25:24.033]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.033]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.033]                       search = base::search(), system = base::Sys.info())
  [21:25:24.033]                   }
  [21:25:24.033]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.033]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.033]                     cond$call), session = sessionInformation(), 
  [21:25:24.033]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.033]                   signalCondition(cond)
  [21:25:24.033]                 }
  [21:25:24.033]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.033]                 ))) {
  [21:25:24.033]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.033]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.033]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.033]                   if (!signal) {
  [21:25:24.033]                     muffleCondition <- function (cond) 
  [21:25:24.033]                     {
  [21:25:24.033]                       inherits <- base::inherits
  [21:25:24.033]                       invokeRestart <- base::invokeRestart
  [21:25:24.033]                       muffled <- FALSE
  [21:25:24.033]                       if (inherits(cond, "message")) {
  [21:25:24.033]                         invokeRestart("muffleMessage")
  [21:25:24.033]                         muffled <- TRUE
  [21:25:24.033]                       }
  [21:25:24.033]                       else if (inherits(cond, "warning")) {
  [21:25:24.033]                         invokeRestart("muffleWarning")
  [21:25:24.033]                         muffled <- TRUE
  [21:25:24.033]                       }
  [21:25:24.033]                       else if (inherits(cond, "condition")) {
  [21:25:24.033]                         computeRestarts <- base::computeRestarts
  [21:25:24.033]                         grepl <- base::grepl
  [21:25:24.033]                         is.null <- base::is.null
  [21:25:24.033]                         restarts <- computeRestarts(cond)
  [21:25:24.033]                         for (restart in restarts) {
  [21:25:24.033]                           name <- restart$name
  [21:25:24.033]                           if (is.null(name)) 
  [21:25:24.033]                             next
  [21:25:24.033]                           if (!grepl("^muffle", name)) 
  [21:25:24.033]                             next
  [21:25:24.033]                           invokeRestart(restart)
  [21:25:24.033]                           muffled <- TRUE
  [21:25:24.033]                           break
  [21:25:24.033]                         }
  [21:25:24.033]                       }
  [21:25:24.033]                       invisible(muffled)
  [21:25:24.033]                     }
  [21:25:24.033]                     muffleCondition(cond)
  [21:25:24.033]                   }
  [21:25:24.033]                 }
  [21:25:24.033]             }
  [21:25:24.033]         }))
  [21:25:24.033]     }, error = function(ex) {
  [21:25:24.033]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.033]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.033]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.033]     }, finally = {
  [21:25:24.033]         {
  [21:25:24.033]             NULL
  [21:25:24.033]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.033]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.033]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.033]                 label = NULL, ...) 
  [21:25:24.033]             {
  [21:25:24.033]                 if (substitute) 
  [21:25:24.033]                   expr <- substitute(expr)
  [21:25:24.033]                 local <- as.logical(local)
  [21:25:24.033]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.033]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.033]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.033]                   label = label, ...)
  [21:25:24.033]                 if (!future$lazy) 
  [21:25:24.033]                   future <- run(future)
  [21:25:24.033]                 invisible(future)
  [21:25:24.033]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.033]         }
  [21:25:24.033]         base::options(...future.oldOptions)
  [21:25:24.033]     })
  [21:25:24.033]     Sys.time
  [21:25:24.033]     if (base::is.na(TRUE)) {
  [21:25:24.033]     }
  [21:25:24.033]     else {
  [21:25:24.033]         base::sink(type = "output", split = FALSE)
  [21:25:24.033]         if (TRUE) {
  [21:25:24.033]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.033]         }
  [21:25:24.033]         else {
  [21:25:24.033]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.033]         }
  [21:25:24.033]         base::close(...future.stdout)
  [21:25:24.033]         ...future.stdout <- NULL
  [21:25:24.033]     }
  [21:25:24.033]     ...future.result$conditions <- ...future.conditions
  [21:25:24.033]     ...future.result
  [21:25:24.033] }
  [21:25:24.038] plan(): Setting new future strategy stack:
  [21:25:24.038] List of future strategies:
  [21:25:24.038] 1. sequential:
  [21:25:24.038]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.038]    - tweaked: FALSE
  [21:25:24.038]    - call: NULL
  [21:25:24.039] plan(): nbrOfWorkers() = 1
  [21:25:24.040] plan(): Setting new future strategy stack:
  [21:25:24.041] List of future strategies:
  [21:25:24.041] 1. sequential:
  [21:25:24.041]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.041]    - tweaked: FALSE
  [21:25:24.041]    - call: plan(strategy)
  [21:25:24.041] plan(): nbrOfWorkers() = 1
  [21:25:24.045] SequentialFuture started (and completed)
  [21:25:24.046] getGlobalsAndPackages() ...
  [21:25:24.046] Searching for globals...
  [21:25:24.047] 
  [21:25:24.047] Searching for globals ... DONE
  [21:25:24.047] - globals: [0] <none>
  [21:25:24.048] getGlobalsAndPackages() ... DONE
  [21:25:24.049] Packages needed by the future expression (n = 0): <none>
  [21:25:24.050] Packages needed by future strategies (n = 0): <none>
  [21:25:24.053] {
  [21:25:24.053]     {
  [21:25:24.053]         ...future.startTime <- base::Sys.time()
  [21:25:24.053]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.053]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.053]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.053]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.053]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.053]         {
  [21:25:24.053]             {
  [21:25:24.053]                 base::local({
  [21:25:24.053]                   has_future <- base::requireNamespace("future", 
  [21:25:24.053]                     quietly = TRUE)
  [21:25:24.053]                   version <- if (has_future) 
  [21:25:24.053]                     utils::packageVersion("future")
  [21:25:24.053]                   else NULL
  [21:25:24.053]                   if (!has_future || version < "1.8.0") {
  [21:25:24.053]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.053]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.053]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.053]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.053]                         "release", "version")], collapse = " "), 
  [21:25:24.053]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.053]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.053]                       info)
  [21:25:24.053]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.053]                     if (!has_future) {
  [21:25:24.053]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.053]                         info)
  [21:25:24.053]                     }
  [21:25:24.053]                     else {
  [21:25:24.053]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.053]                         info, version)
  [21:25:24.053]                     }
  [21:25:24.053]                     base::stop(msg)
  [21:25:24.053]                   }
  [21:25:24.053]                 })
  [21:25:24.053]             }
  [21:25:24.053]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.053]         }
  [21:25:24.053]     }
  [21:25:24.053]     if (base::is.na(TRUE)) {
  [21:25:24.053]     }
  [21:25:24.053]     else {
  [21:25:24.053]         if (TRUE) {
  [21:25:24.053]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.053]                 open = "w")
  [21:25:24.053]         }
  [21:25:24.053]         else {
  [21:25:24.053]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.053]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.053]         }
  [21:25:24.053]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.053]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.053]             base::sink(type = "output", split = FALSE)
  [21:25:24.053]             base::close(...future.stdout)
  [21:25:24.053]         }, add = TRUE)
  [21:25:24.053]     }
  [21:25:24.053]     ...future.frame <- base::sys.nframe()
  [21:25:24.053]     ...future.conditions <- base::list()
  [21:25:24.053]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.053]     ...future.result <- base::tryCatch({
  [21:25:24.053]         base::withCallingHandlers({
  [21:25:24.053]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:24.053]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.053]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.053]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.053]                 version = "1.8")
  [21:25:24.053]         }, condition = base::local({
  [21:25:24.053]             c <- base::c
  [21:25:24.053]             inherits <- base::inherits
  [21:25:24.053]             invokeRestart <- base::invokeRestart
  [21:25:24.053]             length <- base::length
  [21:25:24.053]             list <- base::list
  [21:25:24.053]             seq.int <- base::seq.int
  [21:25:24.053]             signalCondition <- base::signalCondition
  [21:25:24.053]             sys.calls <- base::sys.calls
  [21:25:24.053]             Sys.time <- base::Sys.time
  [21:25:24.053]             `[[` <- base::`[[`
  [21:25:24.053]             `+` <- base::`+`
  [21:25:24.053]             `<<-` <- base::`<<-`
  [21:25:24.053]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.053]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.053]                   3L)]
  [21:25:24.053]             }
  [21:25:24.053]             function(cond) {
  [21:25:24.053]                 if (inherits(cond, "error")) {
  [21:25:24.053]                   sessionInformation <- function() {
  [21:25:24.053]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.053]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.053]                       search = base::search(), system = base::Sys.info())
  [21:25:24.053]                   }
  [21:25:24.053]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.053]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.053]                     cond$call), session = sessionInformation(), 
  [21:25:24.053]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.053]                   signalCondition(cond)
  [21:25:24.053]                 }
  [21:25:24.053]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.053]                 ))) {
  [21:25:24.053]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.053]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.053]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.053]                   if (!signal) {
  [21:25:24.053]                     muffleCondition <- function (cond) 
  [21:25:24.053]                     {
  [21:25:24.053]                       inherits <- base::inherits
  [21:25:24.053]                       invokeRestart <- base::invokeRestart
  [21:25:24.053]                       muffled <- FALSE
  [21:25:24.053]                       if (inherits(cond, "message")) {
  [21:25:24.053]                         invokeRestart("muffleMessage")
  [21:25:24.053]                         muffled <- TRUE
  [21:25:24.053]                       }
  [21:25:24.053]                       else if (inherits(cond, "warning")) {
  [21:25:24.053]                         invokeRestart("muffleWarning")
  [21:25:24.053]                         muffled <- TRUE
  [21:25:24.053]                       }
  [21:25:24.053]                       else if (inherits(cond, "condition")) {
  [21:25:24.053]                         computeRestarts <- base::computeRestarts
  [21:25:24.053]                         grepl <- base::grepl
  [21:25:24.053]                         is.null <- base::is.null
  [21:25:24.053]                         restarts <- computeRestarts(cond)
  [21:25:24.053]                         for (restart in restarts) {
  [21:25:24.053]                           name <- restart$name
  [21:25:24.053]                           if (is.null(name)) 
  [21:25:24.053]                             next
  [21:25:24.053]                           if (!grepl("^muffle", name)) 
  [21:25:24.053]                             next
  [21:25:24.053]                           invokeRestart(restart)
  [21:25:24.053]                           muffled <- TRUE
  [21:25:24.053]                           break
  [21:25:24.053]                         }
  [21:25:24.053]                       }
  [21:25:24.053]                       invisible(muffled)
  [21:25:24.053]                     }
  [21:25:24.053]                     muffleCondition(cond)
  [21:25:24.053]                   }
  [21:25:24.053]                 }
  [21:25:24.053]             }
  [21:25:24.053]         }))
  [21:25:24.053]     }, error = function(ex) {
  [21:25:24.053]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.053]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.053]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.053]     }, finally = {
  [21:25:24.053]         {
  [21:25:24.053]             NULL
  [21:25:24.053]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.053]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.053]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.053]                 label = NULL, ...) 
  [21:25:24.053]             {
  [21:25:24.053]                 if (substitute) 
  [21:25:24.053]                   expr <- substitute(expr)
  [21:25:24.053]                 local <- as.logical(local)
  [21:25:24.053]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.053]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.053]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.053]                   label = label, ...)
  [21:25:24.053]                 if (!future$lazy) 
  [21:25:24.053]                   future <- run(future)
  [21:25:24.053]                 invisible(future)
  [21:25:24.053]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.053]         }
  [21:25:24.053]         base::options(...future.oldOptions)
  [21:25:24.053]     })
  [21:25:24.053]     Sys.time
  [21:25:24.053]     if (base::is.na(TRUE)) {
  [21:25:24.053]     }
  [21:25:24.053]     else {
  [21:25:24.053]         base::sink(type = "output", split = FALSE)
  [21:25:24.053]         if (TRUE) {
  [21:25:24.053]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.053]         }
  [21:25:24.053]         else {
  [21:25:24.053]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.053]         }
  [21:25:24.053]         base::close(...future.stdout)
  [21:25:24.053]         ...future.stdout <- NULL
  [21:25:24.053]     }
  [21:25:24.053]     ...future.result$conditions <- ...future.conditions
  [21:25:24.053]     ...future.result
  [21:25:24.053] }
  [21:25:24.058] plan(): Setting new future strategy stack:
  [21:25:24.058] List of future strategies:
  [21:25:24.058] 1. sequential:
  [21:25:24.058]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.058]    - tweaked: FALSE
  [21:25:24.058]    - call: NULL
  [21:25:24.059] plan(): nbrOfWorkers() = 1
  [21:25:24.060] plan(): Setting new future strategy stack:
  [21:25:24.061] List of future strategies:
  [21:25:24.061] 1. sequential:
  [21:25:24.061]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.061]    - tweaked: FALSE
  [21:25:24.061]    - call: plan(strategy)
  [21:25:24.062] plan(): nbrOfWorkers() = 1
  [21:25:24.063] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef2262f6b8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22968268> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef2262f6b8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22968268> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 1 6
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
   logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:24.085] resolve() on list ...
  [21:25:24.085]  recursive: 0
  [21:25:24.086]  length: 6
  [21:25:24.086]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:24.086] signalConditionsASAP(numeric, pos=1) ...
  [21:25:24.086] - nx: 6
  [21:25:24.087] - relay: TRUE
  [21:25:24.087] - stdout: TRUE
  [21:25:24.087] - signal: TRUE
  [21:25:24.087] - resignal: FALSE
  [21:25:24.088] - force: TRUE
  [21:25:24.088] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.088] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.088]  - until=2
  [21:25:24.089]  - relaying element #2
  [21:25:24.089] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.089] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.090] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:24.090]  length: 5 (resolved future 1)
  [21:25:24.090] Future #2
  [21:25:24.091] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:24.091] - nx: 6
  [21:25:24.091] - relay: TRUE
  [21:25:24.091] - stdout: TRUE
  [21:25:24.092] - signal: TRUE
  [21:25:24.092] - resignal: FALSE
  [21:25:24.092] - force: TRUE
  [21:25:24.092] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.092] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.093]  - until=2
  [21:25:24.093]  - relaying element #2
  [21:25:24.093] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.094] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.094] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:24.094]  length: 4 (resolved future 2)
  [21:25:24.095] Future #3
  [21:25:24.095] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:24.095] - nx: 6
  [21:25:24.096] - relay: TRUE
  [21:25:24.096] - stdout: TRUE
  [21:25:24.096] - signal: TRUE
  [21:25:24.096] - resignal: FALSE
  [21:25:24.096] - force: TRUE
  [21:25:24.097] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.097] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.097]  - until=3
  [21:25:24.097]  - relaying element #3
  [21:25:24.098] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.098] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.099] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:24.099]  length: 3 (resolved future 3)
  [21:25:24.099] signalConditionsASAP(NULL, pos=4) ...
  [21:25:24.099] - nx: 6
  [21:25:24.100] - relay: TRUE
  [21:25:24.100] - stdout: TRUE
  [21:25:24.100] - signal: TRUE
  [21:25:24.100] - resignal: FALSE
  [21:25:24.101] - force: TRUE
  [21:25:24.101] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.101] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.101]  - until=5
  [21:25:24.102]  - relaying element #5
  [21:25:24.102] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.102] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.102] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:24.103]  length: 2 (resolved future 4)
  [21:25:24.103] signalConditionsASAP(NULL, pos=5) ...
  [21:25:24.103] - nx: 6
  [21:25:24.103] - relay: TRUE
  [21:25:24.104] - stdout: TRUE
  [21:25:24.104] - signal: TRUE
  [21:25:24.104] - resignal: FALSE
  [21:25:24.104] - force: TRUE
  [21:25:24.105] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.105] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.105]  - until=6
  [21:25:24.105]  - relaying element #6
  [21:25:24.106] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.106] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.107] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:24.107]  length: 1 (resolved future 5)
  [21:25:24.107] signalConditionsASAP(numeric, pos=6) ...
  [21:25:24.107] - nx: 6
  [21:25:24.108] - relay: TRUE
  [21:25:24.108] - stdout: TRUE
  [21:25:24.108] - signal: TRUE
  [21:25:24.108] - resignal: FALSE
  [21:25:24.109] - force: TRUE
  [21:25:24.109] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.109] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.109]  - until=6
  [21:25:24.110] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.110] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.110] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:24.110]  length: 0 (resolved future 6)
  [21:25:24.111] Relaying remaining futures
  [21:25:24.111] signalConditionsASAP(NULL, pos=0) ...
  [21:25:24.111] - nx: 6
  [21:25:24.111] - relay: TRUE
  [21:25:24.112] - stdout: TRUE
  [21:25:24.112] - signal: TRUE
  [21:25:24.112] - resignal: FALSE
  [21:25:24.112] - force: TRUE
  [21:25:24.112] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.113] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:24.113] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.113] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.114] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:24.114] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 1 6
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
  Dimensions: c(2, 3)
  [21:25:24.123] getGlobalsAndPackages() ...
  [21:25:24.124] Searching for globals...
  [21:25:24.124] 
  [21:25:24.125] Searching for globals ... DONE
  [21:25:24.125] - globals: [0] <none>
  [21:25:24.125] getGlobalsAndPackages() ... DONE
  [21:25:24.127] Packages needed by the future expression (n = 0): <none>
  [21:25:24.127] Packages needed by future strategies (n = 0): <none>
  [21:25:24.131] {
  [21:25:24.131]     {
  [21:25:24.131]         ...future.startTime <- base::Sys.time()
  [21:25:24.131]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.131]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.131]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.131]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.131]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.131]         {
  [21:25:24.131]             {
  [21:25:24.131]                 base::local({
  [21:25:24.131]                   has_future <- base::requireNamespace("future", 
  [21:25:24.131]                     quietly = TRUE)
  [21:25:24.131]                   version <- if (has_future) 
  [21:25:24.131]                     utils::packageVersion("future")
  [21:25:24.131]                   else NULL
  [21:25:24.131]                   if (!has_future || version < "1.8.0") {
  [21:25:24.131]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.131]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.131]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.131]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.131]                         "release", "version")], collapse = " "), 
  [21:25:24.131]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.131]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.131]                       info)
  [21:25:24.131]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.131]                     if (!has_future) {
  [21:25:24.131]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.131]                         info)
  [21:25:24.131]                     }
  [21:25:24.131]                     else {
  [21:25:24.131]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.131]                         info, version)
  [21:25:24.131]                     }
  [21:25:24.131]                     base::stop(msg)
  [21:25:24.131]                   }
  [21:25:24.131]                 })
  [21:25:24.131]             }
  [21:25:24.131]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.131]         }
  [21:25:24.131]     }
  [21:25:24.131]     if (base::is.na(TRUE)) {
  [21:25:24.131]     }
  [21:25:24.131]     else {
  [21:25:24.131]         if (TRUE) {
  [21:25:24.131]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.131]                 open = "w")
  [21:25:24.131]         }
  [21:25:24.131]         else {
  [21:25:24.131]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.131]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.131]         }
  [21:25:24.131]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.131]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.131]             base::sink(type = "output", split = FALSE)
  [21:25:24.131]             base::close(...future.stdout)
  [21:25:24.131]         }, add = TRUE)
  [21:25:24.131]     }
  [21:25:24.131]     ...future.frame <- base::sys.nframe()
  [21:25:24.131]     ...future.conditions <- base::list()
  [21:25:24.131]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.131]     ...future.result <- base::tryCatch({
  [21:25:24.131]         base::withCallingHandlers({
  [21:25:24.131]             ...future.value <- base::withVisible(base::local(2))
  [21:25:24.131]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.131]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.131]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.131]                 version = "1.8")
  [21:25:24.131]         }, condition = base::local({
  [21:25:24.131]             c <- base::c
  [21:25:24.131]             inherits <- base::inherits
  [21:25:24.131]             invokeRestart <- base::invokeRestart
  [21:25:24.131]             length <- base::length
  [21:25:24.131]             list <- base::list
  [21:25:24.131]             seq.int <- base::seq.int
  [21:25:24.131]             signalCondition <- base::signalCondition
  [21:25:24.131]             sys.calls <- base::sys.calls
  [21:25:24.131]             Sys.time <- base::Sys.time
  [21:25:24.131]             `[[` <- base::`[[`
  [21:25:24.131]             `+` <- base::`+`
  [21:25:24.131]             `<<-` <- base::`<<-`
  [21:25:24.131]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.131]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.131]                   3L)]
  [21:25:24.131]             }
  [21:25:24.131]             function(cond) {
  [21:25:24.131]                 if (inherits(cond, "error")) {
  [21:25:24.131]                   sessionInformation <- function() {
  [21:25:24.131]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.131]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.131]                       search = base::search(), system = base::Sys.info())
  [21:25:24.131]                   }
  [21:25:24.131]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.131]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.131]                     cond$call), session = sessionInformation(), 
  [21:25:24.131]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.131]                   signalCondition(cond)
  [21:25:24.131]                 }
  [21:25:24.131]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.131]                 ))) {
  [21:25:24.131]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.131]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.131]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.131]                   if (!signal) {
  [21:25:24.131]                     muffleCondition <- function (cond) 
  [21:25:24.131]                     {
  [21:25:24.131]                       inherits <- base::inherits
  [21:25:24.131]                       invokeRestart <- base::invokeRestart
  [21:25:24.131]                       muffled <- FALSE
  [21:25:24.131]                       if (inherits(cond, "message")) {
  [21:25:24.131]                         invokeRestart("muffleMessage")
  [21:25:24.131]                         muffled <- TRUE
  [21:25:24.131]                       }
  [21:25:24.131]                       else if (inherits(cond, "warning")) {
  [21:25:24.131]                         invokeRestart("muffleWarning")
  [21:25:24.131]                         muffled <- TRUE
  [21:25:24.131]                       }
  [21:25:24.131]                       else if (inherits(cond, "condition")) {
  [21:25:24.131]                         computeRestarts <- base::computeRestarts
  [21:25:24.131]                         grepl <- base::grepl
  [21:25:24.131]                         is.null <- base::is.null
  [21:25:24.131]                         restarts <- computeRestarts(cond)
  [21:25:24.131]                         for (restart in restarts) {
  [21:25:24.131]                           name <- restart$name
  [21:25:24.131]                           if (is.null(name)) 
  [21:25:24.131]                             next
  [21:25:24.131]                           if (!grepl("^muffle", name)) 
  [21:25:24.131]                             next
  [21:25:24.131]                           invokeRestart(restart)
  [21:25:24.131]                           muffled <- TRUE
  [21:25:24.131]                           break
  [21:25:24.131]                         }
  [21:25:24.131]                       }
  [21:25:24.131]                       invisible(muffled)
  [21:25:24.131]                     }
  [21:25:24.131]                     muffleCondition(cond)
  [21:25:24.131]                   }
  [21:25:24.131]                 }
  [21:25:24.131]             }
  [21:25:24.131]         }))
  [21:25:24.131]     }, error = function(ex) {
  [21:25:24.131]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.131]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.131]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.131]     }, finally = {
  [21:25:24.131]         {
  [21:25:24.131]             NULL
  [21:25:24.131]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.131]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.131]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.131]                 label = NULL, ...) 
  [21:25:24.131]             {
  [21:25:24.131]                 if (substitute) 
  [21:25:24.131]                   expr <- substitute(expr)
  [21:25:24.131]                 local <- as.logical(local)
  [21:25:24.131]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.131]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.131]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.131]                   label = label, ...)
  [21:25:24.131]                 if (!future$lazy) 
  [21:25:24.131]                   future <- run(future)
  [21:25:24.131]                 invisible(future)
  [21:25:24.131]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.131]         }
  [21:25:24.131]         base::options(...future.oldOptions)
  [21:25:24.131]     })
  [21:25:24.131]     Sys.time
  [21:25:24.131]     if (base::is.na(TRUE)) {
  [21:25:24.131]     }
  [21:25:24.131]     else {
  [21:25:24.131]         base::sink(type = "output", split = FALSE)
  [21:25:24.131]         if (TRUE) {
  [21:25:24.131]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.131]         }
  [21:25:24.131]         else {
  [21:25:24.131]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.131]         }
  [21:25:24.131]         base::close(...future.stdout)
  [21:25:24.131]         ...future.stdout <- NULL
  [21:25:24.131]     }
  [21:25:24.131]     ...future.result$conditions <- ...future.conditions
  [21:25:24.131]     ...future.result
  [21:25:24.131] }
  [21:25:24.136] plan(): Setting new future strategy stack:
  [21:25:24.136] List of future strategies:
  [21:25:24.136] 1. sequential:
  [21:25:24.136]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.136]    - tweaked: FALSE
  [21:25:24.136]    - call: NULL
  [21:25:24.137] plan(): nbrOfWorkers() = 1
  [21:25:24.138] plan(): Setting new future strategy stack:
  [21:25:24.138] List of future strategies:
  [21:25:24.138] 1. sequential:
  [21:25:24.138]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.138]    - tweaked: FALSE
  [21:25:24.138]    - call: plan(strategy)
  [21:25:24.139] plan(): nbrOfWorkers() = 1
  [21:25:24.140] SequentialFuture started (and completed)
  [21:25:24.140] getGlobalsAndPackages() ...
  [21:25:24.141] Searching for globals...
  [21:25:24.154] 
  [21:25:24.155] Searching for globals ... DONE
  [21:25:24.155] - globals: [0] <none>
  [21:25:24.155] getGlobalsAndPackages() ... DONE
  [21:25:24.157] Packages needed by the future expression (n = 0): <none>
  [21:25:24.157] Packages needed by future strategies (n = 0): <none>
  [21:25:24.161] {
  [21:25:24.161]     {
  [21:25:24.161]         ...future.startTime <- base::Sys.time()
  [21:25:24.161]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.161]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.161]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.161]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.161]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.161]         {
  [21:25:24.161]             {
  [21:25:24.161]                 base::local({
  [21:25:24.161]                   has_future <- base::requireNamespace("future", 
  [21:25:24.161]                     quietly = TRUE)
  [21:25:24.161]                   version <- if (has_future) 
  [21:25:24.161]                     utils::packageVersion("future")
  [21:25:24.161]                   else NULL
  [21:25:24.161]                   if (!has_future || version < "1.8.0") {
  [21:25:24.161]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.161]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.161]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.161]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.161]                         "release", "version")], collapse = " "), 
  [21:25:24.161]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.161]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.161]                       info)
  [21:25:24.161]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.161]                     if (!has_future) {
  [21:25:24.161]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.161]                         info)
  [21:25:24.161]                     }
  [21:25:24.161]                     else {
  [21:25:24.161]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.161]                         info, version)
  [21:25:24.161]                     }
  [21:25:24.161]                     base::stop(msg)
  [21:25:24.161]                   }
  [21:25:24.161]                 })
  [21:25:24.161]             }
  [21:25:24.161]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.161]         }
  [21:25:24.161]     }
  [21:25:24.161]     if (base::is.na(TRUE)) {
  [21:25:24.161]     }
  [21:25:24.161]     else {
  [21:25:24.161]         if (TRUE) {
  [21:25:24.161]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.161]                 open = "w")
  [21:25:24.161]         }
  [21:25:24.161]         else {
  [21:25:24.161]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.161]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.161]         }
  [21:25:24.161]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.161]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.161]             base::sink(type = "output", split = FALSE)
  [21:25:24.161]             base::close(...future.stdout)
  [21:25:24.161]         }, add = TRUE)
  [21:25:24.161]     }
  [21:25:24.161]     ...future.frame <- base::sys.nframe()
  [21:25:24.161]     ...future.conditions <- base::list()
  [21:25:24.161]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.161]     ...future.result <- base::tryCatch({
  [21:25:24.161]         base::withCallingHandlers({
  [21:25:24.161]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:24.161]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.161]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.161]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.161]                 version = "1.8")
  [21:25:24.161]         }, condition = base::local({
  [21:25:24.161]             c <- base::c
  [21:25:24.161]             inherits <- base::inherits
  [21:25:24.161]             invokeRestart <- base::invokeRestart
  [21:25:24.161]             length <- base::length
  [21:25:24.161]             list <- base::list
  [21:25:24.161]             seq.int <- base::seq.int
  [21:25:24.161]             signalCondition <- base::signalCondition
  [21:25:24.161]             sys.calls <- base::sys.calls
  [21:25:24.161]             Sys.time <- base::Sys.time
  [21:25:24.161]             `[[` <- base::`[[`
  [21:25:24.161]             `+` <- base::`+`
  [21:25:24.161]             `<<-` <- base::`<<-`
  [21:25:24.161]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.161]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.161]                   3L)]
  [21:25:24.161]             }
  [21:25:24.161]             function(cond) {
  [21:25:24.161]                 if (inherits(cond, "error")) {
  [21:25:24.161]                   sessionInformation <- function() {
  [21:25:24.161]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.161]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.161]                       search = base::search(), system = base::Sys.info())
  [21:25:24.161]                   }
  [21:25:24.161]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.161]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.161]                     cond$call), session = sessionInformation(), 
  [21:25:24.161]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.161]                   signalCondition(cond)
  [21:25:24.161]                 }
  [21:25:24.161]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.161]                 ))) {
  [21:25:24.161]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.161]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.161]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.161]                   if (!signal) {
  [21:25:24.161]                     muffleCondition <- function (cond) 
  [21:25:24.161]                     {
  [21:25:24.161]                       inherits <- base::inherits
  [21:25:24.161]                       invokeRestart <- base::invokeRestart
  [21:25:24.161]                       muffled <- FALSE
  [21:25:24.161]                       if (inherits(cond, "message")) {
  [21:25:24.161]                         invokeRestart("muffleMessage")
  [21:25:24.161]                         muffled <- TRUE
  [21:25:24.161]                       }
  [21:25:24.161]                       else if (inherits(cond, "warning")) {
  [21:25:24.161]                         invokeRestart("muffleWarning")
  [21:25:24.161]                         muffled <- TRUE
  [21:25:24.161]                       }
  [21:25:24.161]                       else if (inherits(cond, "condition")) {
  [21:25:24.161]                         computeRestarts <- base::computeRestarts
  [21:25:24.161]                         grepl <- base::grepl
  [21:25:24.161]                         is.null <- base::is.null
  [21:25:24.161]                         restarts <- computeRestarts(cond)
  [21:25:24.161]                         for (restart in restarts) {
  [21:25:24.161]                           name <- restart$name
  [21:25:24.161]                           if (is.null(name)) 
  [21:25:24.161]                             next
  [21:25:24.161]                           if (!grepl("^muffle", name)) 
  [21:25:24.161]                             next
  [21:25:24.161]                           invokeRestart(restart)
  [21:25:24.161]                           muffled <- TRUE
  [21:25:24.161]                           break
  [21:25:24.161]                         }
  [21:25:24.161]                       }
  [21:25:24.161]                       invisible(muffled)
  [21:25:24.161]                     }
  [21:25:24.161]                     muffleCondition(cond)
  [21:25:24.161]                   }
  [21:25:24.161]                 }
  [21:25:24.161]             }
  [21:25:24.161]         }))
  [21:25:24.161]     }, error = function(ex) {
  [21:25:24.161]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.161]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.161]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.161]     }, finally = {
  [21:25:24.161]         {
  [21:25:24.161]             NULL
  [21:25:24.161]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.161]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.161]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.161]                 label = NULL, ...) 
  [21:25:24.161]             {
  [21:25:24.161]                 if (substitute) 
  [21:25:24.161]                   expr <- substitute(expr)
  [21:25:24.161]                 local <- as.logical(local)
  [21:25:24.161]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.161]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.161]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.161]                   label = label, ...)
  [21:25:24.161]                 if (!future$lazy) 
  [21:25:24.161]                   future <- run(future)
  [21:25:24.161]                 invisible(future)
  [21:25:24.161]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.161]         }
  [21:25:24.161]         base::options(...future.oldOptions)
  [21:25:24.161]     })
  [21:25:24.161]     Sys.time
  [21:25:24.161]     if (base::is.na(TRUE)) {
  [21:25:24.161]     }
  [21:25:24.161]     else {
  [21:25:24.161]         base::sink(type = "output", split = FALSE)
  [21:25:24.161]         if (TRUE) {
  [21:25:24.161]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.161]         }
  [21:25:24.161]         else {
  [21:25:24.161]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.161]         }
  [21:25:24.161]         base::close(...future.stdout)
  [21:25:24.161]         ...future.stdout <- NULL
  [21:25:24.161]     }
  [21:25:24.161]     ...future.result$conditions <- ...future.conditions
  [21:25:24.161]     ...future.result
  [21:25:24.161] }
  [21:25:24.165] plan(): Setting new future strategy stack:
  [21:25:24.182] List of future strategies:
  [21:25:24.182] 1. sequential:
  [21:25:24.182]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.182]    - tweaked: FALSE
  [21:25:24.182]    - call: NULL
  [21:25:24.183] plan(): nbrOfWorkers() = 1
  [21:25:24.184] plan(): Setting new future strategy stack:
  [21:25:24.184] List of future strategies:
  [21:25:24.184] 1. sequential:
  [21:25:24.184]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.184]    - tweaked: FALSE
  [21:25:24.184]    - call: plan(strategy)
  [21:25:24.185] plan(): nbrOfWorkers() = 1
  [21:25:24.186] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22ada9c8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef218d5610> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22ada9c8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef218d5610> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 2 3
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
   logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:24.220] resolve() on list ...
  [21:25:24.220]  recursive: 0
  [21:25:24.220]  length: 6
  [21:25:24.220]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:24.221] signalConditionsASAP(numeric, pos=1) ...
  [21:25:24.221] - nx: 6
  [21:25:24.221] - relay: TRUE
  [21:25:24.222] - stdout: TRUE
  [21:25:24.222] - signal: TRUE
  [21:25:24.222] - resignal: FALSE
  [21:25:24.222] - force: TRUE
  [21:25:24.223] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.223] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.223]  - until=2
  [21:25:24.223]  - relaying element #2
  [21:25:24.224] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.224] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.224] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:24.224]  length: 5 (resolved future 1)
  [21:25:24.225] Future #2
  [21:25:24.225] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:24.225] - nx: 6
  [21:25:24.226] - relay: TRUE
  [21:25:24.226] - stdout: TRUE
  [21:25:24.226] - signal: TRUE
  [21:25:24.226] - resignal: FALSE
  [21:25:24.227] - force: TRUE
  [21:25:24.227] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.227] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.228]  - until=2
  [21:25:24.228]  - relaying element #2
  [21:25:24.228] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.229] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.229] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:24.229]  length: 4 (resolved future 2)
  [21:25:24.230] Future #3
  [21:25:24.238] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:24.238] - nx: 6
  [21:25:24.238] - relay: TRUE
  [21:25:24.238] - stdout: TRUE
  [21:25:24.239] - signal: TRUE
  [21:25:24.239] - resignal: FALSE
  [21:25:24.239] - force: TRUE
  [21:25:24.239] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.240] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.240]  - until=3
  [21:25:24.240]  - relaying element #3
  [21:25:24.241] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.241] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.241] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:24.241]  length: 3 (resolved future 3)
  [21:25:24.242] signalConditionsASAP(NULL, pos=4) ...
  [21:25:24.242] - nx: 6
  [21:25:24.242] - relay: TRUE
  [21:25:24.242] - stdout: TRUE
  [21:25:24.243] - signal: TRUE
  [21:25:24.243] - resignal: FALSE
  [21:25:24.243] - force: TRUE
  [21:25:24.243] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.244] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.244]  - until=5
  [21:25:24.244]  - relaying element #5
  [21:25:24.244] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.245] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.245] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:24.245]  length: 2 (resolved future 4)
  [21:25:24.245] signalConditionsASAP(NULL, pos=5) ...
  [21:25:24.246] - nx: 6
  [21:25:24.246] - relay: TRUE
  [21:25:24.246] - stdout: TRUE
  [21:25:24.246] - signal: TRUE
  [21:25:24.247] - resignal: FALSE
  [21:25:24.247] - force: TRUE
  [21:25:24.247] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.247] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.248]  - until=6
  [21:25:24.248]  - relaying element #6
  [21:25:24.248] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.248] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.249] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:24.249]  length: 1 (resolved future 5)
  [21:25:24.249] signalConditionsASAP(numeric, pos=6) ...
  [21:25:24.249] - nx: 6
  [21:25:24.250] - relay: TRUE
  [21:25:24.250] - stdout: TRUE
  [21:25:24.250] - signal: TRUE
  [21:25:24.250] - resignal: FALSE
  [21:25:24.251] - force: TRUE
  [21:25:24.251] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.251] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.251]  - until=6
  [21:25:24.252] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.252] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.252] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:24.252]  length: 0 (resolved future 6)
  [21:25:24.253] Relaying remaining futures
  [21:25:24.253] signalConditionsASAP(NULL, pos=0) ...
  [21:25:24.253] - nx: 6
  [21:25:24.253] - relay: TRUE
  [21:25:24.255] - stdout: TRUE
  [21:25:24.255] - signal: TRUE
  [21:25:24.255] - resignal: FALSE
  [21:25:24.256] - force: TRUE
  [21:25:24.256] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.256] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:24.257] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.257] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.257] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:24.257] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 2 3
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
  Dimensions: c(2, 3, 1)
  [21:25:24.270] getGlobalsAndPackages() ...
  [21:25:24.270] Searching for globals...
  [21:25:24.271] 
  [21:25:24.271] Searching for globals ... DONE
  [21:25:24.271] - globals: [0] <none>
  [21:25:24.272] getGlobalsAndPackages() ... DONE
  [21:25:24.273] Packages needed by the future expression (n = 0): <none>
  [21:25:24.274] Packages needed by future strategies (n = 0): <none>
  [21:25:24.278] {
  [21:25:24.278]     {
  [21:25:24.278]         ...future.startTime <- base::Sys.time()
  [21:25:24.278]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.278]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.278]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.278]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.278]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.278]         {
  [21:25:24.278]             {
  [21:25:24.278]                 base::local({
  [21:25:24.278]                   has_future <- base::requireNamespace("future", 
  [21:25:24.278]                     quietly = TRUE)
  [21:25:24.278]                   version <- if (has_future) 
  [21:25:24.278]                     utils::packageVersion("future")
  [21:25:24.278]                   else NULL
  [21:25:24.278]                   if (!has_future || version < "1.8.0") {
  [21:25:24.278]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.278]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.278]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.278]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.278]                         "release", "version")], collapse = " "), 
  [21:25:24.278]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.278]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.278]                       info)
  [21:25:24.278]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.278]                     if (!has_future) {
  [21:25:24.278]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.278]                         info)
  [21:25:24.278]                     }
  [21:25:24.278]                     else {
  [21:25:24.278]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.278]                         info, version)
  [21:25:24.278]                     }
  [21:25:24.278]                     base::stop(msg)
  [21:25:24.278]                   }
  [21:25:24.278]                 })
  [21:25:24.278]             }
  [21:25:24.278]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.278]         }
  [21:25:24.278]     }
  [21:25:24.278]     if (base::is.na(TRUE)) {
  [21:25:24.278]     }
  [21:25:24.278]     else {
  [21:25:24.278]         if (TRUE) {
  [21:25:24.278]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.278]                 open = "w")
  [21:25:24.278]         }
  [21:25:24.278]         else {
  [21:25:24.278]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.278]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.278]         }
  [21:25:24.278]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.278]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.278]             base::sink(type = "output", split = FALSE)
  [21:25:24.278]             base::close(...future.stdout)
  [21:25:24.278]         }, add = TRUE)
  [21:25:24.278]     }
  [21:25:24.278]     ...future.frame <- base::sys.nframe()
  [21:25:24.278]     ...future.conditions <- base::list()
  [21:25:24.278]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.278]     ...future.result <- base::tryCatch({
  [21:25:24.278]         base::withCallingHandlers({
  [21:25:24.278]             ...future.value <- base::withVisible(base::local(2))
  [21:25:24.278]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.278]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.278]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.278]                 version = "1.8")
  [21:25:24.278]         }, condition = base::local({
  [21:25:24.278]             c <- base::c
  [21:25:24.278]             inherits <- base::inherits
  [21:25:24.278]             invokeRestart <- base::invokeRestart
  [21:25:24.278]             length <- base::length
  [21:25:24.278]             list <- base::list
  [21:25:24.278]             seq.int <- base::seq.int
  [21:25:24.278]             signalCondition <- base::signalCondition
  [21:25:24.278]             sys.calls <- base::sys.calls
  [21:25:24.278]             Sys.time <- base::Sys.time
  [21:25:24.278]             `[[` <- base::`[[`
  [21:25:24.278]             `+` <- base::`+`
  [21:25:24.278]             `<<-` <- base::`<<-`
  [21:25:24.278]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.278]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.278]                   3L)]
  [21:25:24.278]             }
  [21:25:24.278]             function(cond) {
  [21:25:24.278]                 if (inherits(cond, "error")) {
  [21:25:24.278]                   sessionInformation <- function() {
  [21:25:24.278]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.278]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.278]                       search = base::search(), system = base::Sys.info())
  [21:25:24.278]                   }
  [21:25:24.278]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.278]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.278]                     cond$call), session = sessionInformation(), 
  [21:25:24.278]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.278]                   signalCondition(cond)
  [21:25:24.278]                 }
  [21:25:24.278]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.278]                 ))) {
  [21:25:24.278]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.278]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.278]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.278]                   if (!signal) {
  [21:25:24.278]                     muffleCondition <- function (cond) 
  [21:25:24.278]                     {
  [21:25:24.278]                       inherits <- base::inherits
  [21:25:24.278]                       invokeRestart <- base::invokeRestart
  [21:25:24.278]                       muffled <- FALSE
  [21:25:24.278]                       if (inherits(cond, "message")) {
  [21:25:24.278]                         invokeRestart("muffleMessage")
  [21:25:24.278]                         muffled <- TRUE
  [21:25:24.278]                       }
  [21:25:24.278]                       else if (inherits(cond, "warning")) {
  [21:25:24.278]                         invokeRestart("muffleWarning")
  [21:25:24.278]                         muffled <- TRUE
  [21:25:24.278]                       }
  [21:25:24.278]                       else if (inherits(cond, "condition")) {
  [21:25:24.278]                         computeRestarts <- base::computeRestarts
  [21:25:24.278]                         grepl <- base::grepl
  [21:25:24.278]                         is.null <- base::is.null
  [21:25:24.278]                         restarts <- computeRestarts(cond)
  [21:25:24.278]                         for (restart in restarts) {
  [21:25:24.278]                           name <- restart$name
  [21:25:24.278]                           if (is.null(name)) 
  [21:25:24.278]                             next
  [21:25:24.278]                           if (!grepl("^muffle", name)) 
  [21:25:24.278]                             next
  [21:25:24.278]                           invokeRestart(restart)
  [21:25:24.278]                           muffled <- TRUE
  [21:25:24.278]                           break
  [21:25:24.278]                         }
  [21:25:24.278]                       }
  [21:25:24.278]                       invisible(muffled)
  [21:25:24.278]                     }
  [21:25:24.278]                     muffleCondition(cond)
  [21:25:24.278]                   }
  [21:25:24.278]                 }
  [21:25:24.278]             }
  [21:25:24.278]         }))
  [21:25:24.278]     }, error = function(ex) {
  [21:25:24.278]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.278]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.278]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.278]     }, finally = {
  [21:25:24.278]         {
  [21:25:24.278]             NULL
  [21:25:24.278]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.278]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.278]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.278]                 label = NULL, ...) 
  [21:25:24.278]             {
  [21:25:24.278]                 if (substitute) 
  [21:25:24.278]                   expr <- substitute(expr)
  [21:25:24.278]                 local <- as.logical(local)
  [21:25:24.278]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.278]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.278]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.278]                   label = label, ...)
  [21:25:24.278]                 if (!future$lazy) 
  [21:25:24.278]                   future <- run(future)
  [21:25:24.278]                 invisible(future)
  [21:25:24.278]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.278]         }
  [21:25:24.278]         base::options(...future.oldOptions)
  [21:25:24.278]     })
  [21:25:24.278]     Sys.time
  [21:25:24.278]     if (base::is.na(TRUE)) {
  [21:25:24.278]     }
  [21:25:24.278]     else {
  [21:25:24.278]         base::sink(type = "output", split = FALSE)
  [21:25:24.278]         if (TRUE) {
  [21:25:24.278]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.278]         }
  [21:25:24.278]         else {
  [21:25:24.278]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.278]         }
  [21:25:24.278]         base::close(...future.stdout)
  [21:25:24.278]         ...future.stdout <- NULL
  [21:25:24.278]     }
  [21:25:24.278]     ...future.result$conditions <- ...future.conditions
  [21:25:24.278]     ...future.result
  [21:25:24.278] }
  [21:25:24.285] plan(): Setting new future strategy stack:
  [21:25:24.285] List of future strategies:
  [21:25:24.285] 1. sequential:
  [21:25:24.285]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.285]    - tweaked: FALSE
  [21:25:24.285]    - call: NULL
  [21:25:24.286] plan(): nbrOfWorkers() = 1
  [21:25:24.287] plan(): Setting new future strategy stack:
  [21:25:24.287] List of future strategies:
  [21:25:24.287] 1. sequential:
  [21:25:24.287]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.287]    - tweaked: FALSE
  [21:25:24.287]    - call: plan(strategy)
  [21:25:24.288] plan(): nbrOfWorkers() = 1
  [21:25:24.289] SequentialFuture started (and completed)
  [21:25:24.289] getGlobalsAndPackages() ...
  [21:25:24.290] Searching for globals...
  [21:25:24.291] 
  [21:25:24.291] Searching for globals ... DONE
  [21:25:24.291] - globals: [0] <none>
  [21:25:24.291] getGlobalsAndPackages() ... DONE
  [21:25:24.293] Packages needed by the future expression (n = 0): <none>
  [21:25:24.293] Packages needed by future strategies (n = 0): <none>
  [21:25:24.298] {
  [21:25:24.298]     {
  [21:25:24.298]         ...future.startTime <- base::Sys.time()
  [21:25:24.298]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.298]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.298]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.298]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.298]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.298]         {
  [21:25:24.298]             {
  [21:25:24.298]                 base::local({
  [21:25:24.298]                   has_future <- base::requireNamespace("future", 
  [21:25:24.298]                     quietly = TRUE)
  [21:25:24.298]                   version <- if (has_future) 
  [21:25:24.298]                     utils::packageVersion("future")
  [21:25:24.298]                   else NULL
  [21:25:24.298]                   if (!has_future || version < "1.8.0") {
  [21:25:24.298]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.298]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.298]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.298]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.298]                         "release", "version")], collapse = " "), 
  [21:25:24.298]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.298]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.298]                       info)
  [21:25:24.298]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.298]                     if (!has_future) {
  [21:25:24.298]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.298]                         info)
  [21:25:24.298]                     }
  [21:25:24.298]                     else {
  [21:25:24.298]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.298]                         info, version)
  [21:25:24.298]                     }
  [21:25:24.298]                     base::stop(msg)
  [21:25:24.298]                   }
  [21:25:24.298]                 })
  [21:25:24.298]             }
  [21:25:24.298]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.298]         }
  [21:25:24.298]     }
  [21:25:24.298]     if (base::is.na(TRUE)) {
  [21:25:24.298]     }
  [21:25:24.298]     else {
  [21:25:24.298]         if (TRUE) {
  [21:25:24.298]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.298]                 open = "w")
  [21:25:24.298]         }
  [21:25:24.298]         else {
  [21:25:24.298]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.298]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.298]         }
  [21:25:24.298]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.298]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.298]             base::sink(type = "output", split = FALSE)
  [21:25:24.298]             base::close(...future.stdout)
  [21:25:24.298]         }, add = TRUE)
  [21:25:24.298]     }
  [21:25:24.298]     ...future.frame <- base::sys.nframe()
  [21:25:24.298]     ...future.conditions <- base::list()
  [21:25:24.298]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.298]     ...future.result <- base::tryCatch({
  [21:25:24.298]         base::withCallingHandlers({
  [21:25:24.298]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:24.298]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.298]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.298]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.298]                 version = "1.8")
  [21:25:24.298]         }, condition = base::local({
  [21:25:24.298]             c <- base::c
  [21:25:24.298]             inherits <- base::inherits
  [21:25:24.298]             invokeRestart <- base::invokeRestart
  [21:25:24.298]             length <- base::length
  [21:25:24.298]             list <- base::list
  [21:25:24.298]             seq.int <- base::seq.int
  [21:25:24.298]             signalCondition <- base::signalCondition
  [21:25:24.298]             sys.calls <- base::sys.calls
  [21:25:24.298]             Sys.time <- base::Sys.time
  [21:25:24.298]             `[[` <- base::`[[`
  [21:25:24.298]             `+` <- base::`+`
  [21:25:24.298]             `<<-` <- base::`<<-`
  [21:25:24.298]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.298]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.298]                   3L)]
  [21:25:24.298]             }
  [21:25:24.298]             function(cond) {
  [21:25:24.298]                 if (inherits(cond, "error")) {
  [21:25:24.298]                   sessionInformation <- function() {
  [21:25:24.298]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.298]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.298]                       search = base::search(), system = base::Sys.info())
  [21:25:24.298]                   }
  [21:25:24.298]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.298]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.298]                     cond$call), session = sessionInformation(), 
  [21:25:24.298]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.298]                   signalCondition(cond)
  [21:25:24.298]                 }
  [21:25:24.298]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.298]                 ))) {
  [21:25:24.298]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.298]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.298]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.298]                   if (!signal) {
  [21:25:24.298]                     muffleCondition <- function (cond) 
  [21:25:24.298]                     {
  [21:25:24.298]                       inherits <- base::inherits
  [21:25:24.298]                       invokeRestart <- base::invokeRestart
  [21:25:24.298]                       muffled <- FALSE
  [21:25:24.298]                       if (inherits(cond, "message")) {
  [21:25:24.298]                         invokeRestart("muffleMessage")
  [21:25:24.298]                         muffled <- TRUE
  [21:25:24.298]                       }
  [21:25:24.298]                       else if (inherits(cond, "warning")) {
  [21:25:24.298]                         invokeRestart("muffleWarning")
  [21:25:24.298]                         muffled <- TRUE
  [21:25:24.298]                       }
  [21:25:24.298]                       else if (inherits(cond, "condition")) {
  [21:25:24.298]                         computeRestarts <- base::computeRestarts
  [21:25:24.298]                         grepl <- base::grepl
  [21:25:24.298]                         is.null <- base::is.null
  [21:25:24.298]                         restarts <- computeRestarts(cond)
  [21:25:24.298]                         for (restart in restarts) {
  [21:25:24.298]                           name <- restart$name
  [21:25:24.298]                           if (is.null(name)) 
  [21:25:24.298]                             next
  [21:25:24.298]                           if (!grepl("^muffle", name)) 
  [21:25:24.298]                             next
  [21:25:24.298]                           invokeRestart(restart)
  [21:25:24.298]                           muffled <- TRUE
  [21:25:24.298]                           break
  [21:25:24.298]                         }
  [21:25:24.298]                       }
  [21:25:24.298]                       invisible(muffled)
  [21:25:24.298]                     }
  [21:25:24.298]                     muffleCondition(cond)
  [21:25:24.298]                   }
  [21:25:24.298]                 }
  [21:25:24.298]             }
  [21:25:24.298]         }))
  [21:25:24.298]     }, error = function(ex) {
  [21:25:24.298]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.298]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.298]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.298]     }, finally = {
  [21:25:24.298]         {
  [21:25:24.298]             NULL
  [21:25:24.298]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.298]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.298]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.298]                 label = NULL, ...) 
  [21:25:24.298]             {
  [21:25:24.298]                 if (substitute) 
  [21:25:24.298]                   expr <- substitute(expr)
  [21:25:24.298]                 local <- as.logical(local)
  [21:25:24.298]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.298]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.298]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.298]                   label = label, ...)
  [21:25:24.298]                 if (!future$lazy) 
  [21:25:24.298]                   future <- run(future)
  [21:25:24.298]                 invisible(future)
  [21:25:24.298]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.298]         }
  [21:25:24.298]         base::options(...future.oldOptions)
  [21:25:24.298]     })
  [21:25:24.298]     Sys.time
  [21:25:24.298]     if (base::is.na(TRUE)) {
  [21:25:24.298]     }
  [21:25:24.298]     else {
  [21:25:24.298]         base::sink(type = "output", split = FALSE)
  [21:25:24.298]         if (TRUE) {
  [21:25:24.298]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.298]         }
  [21:25:24.298]         else {
  [21:25:24.298]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.298]         }
  [21:25:24.298]         base::close(...future.stdout)
  [21:25:24.298]         ...future.stdout <- NULL
  [21:25:24.298]     }
  [21:25:24.298]     ...future.result$conditions <- ...future.conditions
  [21:25:24.298]     ...future.result
  [21:25:24.298] }
  [21:25:24.303] plan(): Setting new future strategy stack:
  [21:25:24.304] List of future strategies:
  [21:25:24.304] 1. sequential:
  [21:25:24.304]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.304]    - tweaked: FALSE
  [21:25:24.304]    - call: NULL
  [21:25:24.305] plan(): nbrOfWorkers() = 1
  [21:25:24.306] plan(): Setting new future strategy stack:
  [21:25:24.306] List of future strategies:
  [21:25:24.306] 1. sequential:
  [21:25:24.306]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.306]    - tweaked: FALSE
  [21:25:24.306]    - call: plan(strategy)
  [21:25:24.307] plan(): nbrOfWorkers() = 1
  [21:25:24.308] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef213cbb80> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef21161000> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef213cbb80> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef21161000> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:3] 2 3 1
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:24.326] resolve() on list ...
  [21:25:24.342]  recursive: 0
  [21:25:24.342]  length: 6
  [21:25:24.342]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:24.343] signalConditionsASAP(numeric, pos=1) ...
  [21:25:24.343] - nx: 6
  [21:25:24.343] - relay: TRUE
  [21:25:24.344] - stdout: TRUE
  [21:25:24.344] - signal: TRUE
  [21:25:24.344] - resignal: FALSE
  [21:25:24.344] - force: TRUE
  [21:25:24.344] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.345] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.345]  - until=2
  [21:25:24.345]  - relaying element #2
  [21:25:24.345] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.346] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.346] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:24.346]  length: 5 (resolved future 1)
  [21:25:24.347] Future #2
  [21:25:24.347] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:24.347] - nx: 6
  [21:25:24.347] - relay: TRUE
  [21:25:24.348] - stdout: TRUE
  [21:25:24.348] - signal: TRUE
  [21:25:24.348] - resignal: FALSE
  [21:25:24.348] - force: TRUE
  [21:25:24.349] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.349] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.349]  - until=2
  [21:25:24.349]  - relaying element #2
  [21:25:24.350] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.350] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.350] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:24.351]  length: 4 (resolved future 2)
  [21:25:24.351] Future #3
  [21:25:24.351] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:24.352] - nx: 6
  [21:25:24.352] - relay: TRUE
  [21:25:24.352] - stdout: TRUE
  [21:25:24.368] - signal: TRUE
  [21:25:24.369] - resignal: FALSE
  [21:25:24.369] - force: TRUE
  [21:25:24.369] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.369] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.370]  - until=3
  [21:25:24.370]  - relaying element #3
  [21:25:24.370] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.371] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.371] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:24.371]  length: 3 (resolved future 3)
  [21:25:24.371] signalConditionsASAP(NULL, pos=4) ...
  [21:25:24.372] - nx: 6
  [21:25:24.372] - relay: TRUE
  [21:25:24.372] - stdout: TRUE
  [21:25:24.372] - signal: TRUE
  [21:25:24.373] - resignal: FALSE
  [21:25:24.373] - force: TRUE
  [21:25:24.373] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.373] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.374]  - until=5
  [21:25:24.374]  - relaying element #5
  [21:25:24.374] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.375] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.375] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:24.375]  length: 2 (resolved future 4)
  [21:25:24.375] signalConditionsASAP(NULL, pos=5) ...
  [21:25:24.376] - nx: 6
  [21:25:24.376] - relay: TRUE
  [21:25:24.376] - stdout: TRUE
  [21:25:24.376] - signal: TRUE
  [21:25:24.377] - resignal: FALSE
  [21:25:24.377] - force: TRUE
  [21:25:24.377] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.377] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.378]  - until=6
  [21:25:24.378]  - relaying element #6
  [21:25:24.378] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.378] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.379] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:24.379]  length: 1 (resolved future 5)
  [21:25:24.379] signalConditionsASAP(numeric, pos=6) ...
  [21:25:24.380] - nx: 6
  [21:25:24.380] - relay: TRUE
  [21:25:24.380] - stdout: TRUE
  [21:25:24.380] - signal: TRUE
  [21:25:24.381] - resignal: FALSE
  [21:25:24.381] - force: TRUE
  [21:25:24.381] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.381] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.398]  - until=6
  [21:25:24.398] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.398] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.399] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:24.399]  length: 0 (resolved future 6)
  [21:25:24.399] Relaying remaining futures
  [21:25:24.400] signalConditionsASAP(NULL, pos=0) ...
  [21:25:24.400] - nx: 6
  [21:25:24.400] - relay: TRUE
  [21:25:24.400] - stdout: TRUE
  [21:25:24.401] - signal: TRUE
  [21:25:24.401] - resignal: FALSE
  [21:25:24.401] - force: TRUE
  [21:25:24.401] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.401] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:24.402] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.402] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.402] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:24.403] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:3] 2 3 1
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  Dimensions: c(2, 1, 3, 1)
  [21:25:24.429] getGlobalsAndPackages() ...
  [21:25:24.429] Searching for globals...
  [21:25:24.430] 
  [21:25:24.430] Searching for globals ... DONE
  [21:25:24.431] - globals: [0] <none>
  [21:25:24.431] getGlobalsAndPackages() ... DONE
  [21:25:24.433] Packages needed by the future expression (n = 0): <none>
  [21:25:24.433] Packages needed by future strategies (n = 0): <none>
  [21:25:24.437] {
  [21:25:24.437]     {
  [21:25:24.437]         ...future.startTime <- base::Sys.time()
  [21:25:24.437]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.437]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.437]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.437]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.437]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.437]         {
  [21:25:24.437]             {
  [21:25:24.437]                 base::local({
  [21:25:24.437]                   has_future <- base::requireNamespace("future", 
  [21:25:24.437]                     quietly = TRUE)
  [21:25:24.437]                   version <- if (has_future) 
  [21:25:24.437]                     utils::packageVersion("future")
  [21:25:24.437]                   else NULL
  [21:25:24.437]                   if (!has_future || version < "1.8.0") {
  [21:25:24.437]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.437]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.437]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.437]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.437]                         "release", "version")], collapse = " "), 
  [21:25:24.437]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.437]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.437]                       info)
  [21:25:24.437]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.437]                     if (!has_future) {
  [21:25:24.437]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.437]                         info)
  [21:25:24.437]                     }
  [21:25:24.437]                     else {
  [21:25:24.437]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.437]                         info, version)
  [21:25:24.437]                     }
  [21:25:24.437]                     base::stop(msg)
  [21:25:24.437]                   }
  [21:25:24.437]                 })
  [21:25:24.437]             }
  [21:25:24.437]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.437]         }
  [21:25:24.437]     }
  [21:25:24.437]     if (base::is.na(TRUE)) {
  [21:25:24.437]     }
  [21:25:24.437]     else {
  [21:25:24.437]         if (TRUE) {
  [21:25:24.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.437]                 open = "w")
  [21:25:24.437]         }
  [21:25:24.437]         else {
  [21:25:24.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.437]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.437]         }
  [21:25:24.437]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.437]             base::sink(type = "output", split = FALSE)
  [21:25:24.437]             base::close(...future.stdout)
  [21:25:24.437]         }, add = TRUE)
  [21:25:24.437]     }
  [21:25:24.437]     ...future.frame <- base::sys.nframe()
  [21:25:24.437]     ...future.conditions <- base::list()
  [21:25:24.437]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.437]     ...future.result <- base::tryCatch({
  [21:25:24.437]         base::withCallingHandlers({
  [21:25:24.437]             ...future.value <- base::withVisible(base::local(2))
  [21:25:24.437]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.437]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.437]                 version = "1.8")
  [21:25:24.437]         }, condition = base::local({
  [21:25:24.437]             c <- base::c
  [21:25:24.437]             inherits <- base::inherits
  [21:25:24.437]             invokeRestart <- base::invokeRestart
  [21:25:24.437]             length <- base::length
  [21:25:24.437]             list <- base::list
  [21:25:24.437]             seq.int <- base::seq.int
  [21:25:24.437]             signalCondition <- base::signalCondition
  [21:25:24.437]             sys.calls <- base::sys.calls
  [21:25:24.437]             Sys.time <- base::Sys.time
  [21:25:24.437]             `[[` <- base::`[[`
  [21:25:24.437]             `+` <- base::`+`
  [21:25:24.437]             `<<-` <- base::`<<-`
  [21:25:24.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.437]                   3L)]
  [21:25:24.437]             }
  [21:25:24.437]             function(cond) {
  [21:25:24.437]                 if (inherits(cond, "error")) {
  [21:25:24.437]                   sessionInformation <- function() {
  [21:25:24.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.437]                       search = base::search(), system = base::Sys.info())
  [21:25:24.437]                   }
  [21:25:24.437]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.437]                     cond$call), session = sessionInformation(), 
  [21:25:24.437]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.437]                   signalCondition(cond)
  [21:25:24.437]                 }
  [21:25:24.437]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.437]                 ))) {
  [21:25:24.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.437]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.437]                   if (!signal) {
  [21:25:24.437]                     muffleCondition <- function (cond) 
  [21:25:24.437]                     {
  [21:25:24.437]                       inherits <- base::inherits
  [21:25:24.437]                       invokeRestart <- base::invokeRestart
  [21:25:24.437]                       muffled <- FALSE
  [21:25:24.437]                       if (inherits(cond, "message")) {
  [21:25:24.437]                         invokeRestart("muffleMessage")
  [21:25:24.437]                         muffled <- TRUE
  [21:25:24.437]                       }
  [21:25:24.437]                       else if (inherits(cond, "warning")) {
  [21:25:24.437]                         invokeRestart("muffleWarning")
  [21:25:24.437]                         muffled <- TRUE
  [21:25:24.437]                       }
  [21:25:24.437]                       else if (inherits(cond, "condition")) {
  [21:25:24.437]                         computeRestarts <- base::computeRestarts
  [21:25:24.437]                         grepl <- base::grepl
  [21:25:24.437]                         is.null <- base::is.null
  [21:25:24.437]                         restarts <- computeRestarts(cond)
  [21:25:24.437]                         for (restart in restarts) {
  [21:25:24.437]                           name <- restart$name
  [21:25:24.437]                           if (is.null(name)) 
  [21:25:24.437]                             next
  [21:25:24.437]                           if (!grepl("^muffle", name)) 
  [21:25:24.437]                             next
  [21:25:24.437]                           invokeRestart(restart)
  [21:25:24.437]                           muffled <- TRUE
  [21:25:24.437]                           break
  [21:25:24.437]                         }
  [21:25:24.437]                       }
  [21:25:24.437]                       invisible(muffled)
  [21:25:24.437]                     }
  [21:25:24.437]                     muffleCondition(cond)
  [21:25:24.437]                   }
  [21:25:24.437]                 }
  [21:25:24.437]             }
  [21:25:24.437]         }))
  [21:25:24.437]     }, error = function(ex) {
  [21:25:24.437]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.437]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.437]     }, finally = {
  [21:25:24.437]         {
  [21:25:24.437]             NULL
  [21:25:24.437]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.437]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.437]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.437]                 label = NULL, ...) 
  [21:25:24.437]             {
  [21:25:24.437]                 if (substitute) 
  [21:25:24.437]                   expr <- substitute(expr)
  [21:25:24.437]                 local <- as.logical(local)
  [21:25:24.437]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.437]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.437]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.437]                   label = label, ...)
  [21:25:24.437]                 if (!future$lazy) 
  [21:25:24.437]                   future <- run(future)
  [21:25:24.437]                 invisible(future)
  [21:25:24.437]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.437]         }
  [21:25:24.437]         base::options(...future.oldOptions)
  [21:25:24.437]     })
  [21:25:24.437]     Sys.time
  [21:25:24.437]     if (base::is.na(TRUE)) {
  [21:25:24.437]     }
  [21:25:24.437]     else {
  [21:25:24.437]         base::sink(type = "output", split = FALSE)
  [21:25:24.437]         if (TRUE) {
  [21:25:24.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.437]         }
  [21:25:24.437]         else {
  [21:25:24.437]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.437]         }
  [21:25:24.437]         base::close(...future.stdout)
  [21:25:24.437]         ...future.stdout <- NULL
  [21:25:24.437]     }
  [21:25:24.437]     ...future.result$conditions <- ...future.conditions
  [21:25:24.437]     ...future.result
  [21:25:24.437] }
  [21:25:24.458] plan(): Setting new future strategy stack:
  [21:25:24.458] List of future strategies:
  [21:25:24.458] 1. sequential:
  [21:25:24.458]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.458]    - tweaked: FALSE
  [21:25:24.458]    - call: NULL
  [21:25:24.459] plan(): nbrOfWorkers() = 1
  [21:25:24.460] plan(): Setting new future strategy stack:
  [21:25:24.461] List of future strategies:
  [21:25:24.461] 1. sequential:
  [21:25:24.461]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.461]    - tweaked: FALSE
  [21:25:24.461]    - call: plan(strategy)
  [21:25:24.461] plan(): nbrOfWorkers() = 1
  [21:25:24.462] SequentialFuture started (and completed)
  [21:25:24.462] getGlobalsAndPackages() ...
  [21:25:24.463] Searching for globals...
  [21:25:24.463] 
  [21:25:24.464] Searching for globals ... DONE
  [21:25:24.464] - globals: [0] <none>
  [21:25:24.464] getGlobalsAndPackages() ... DONE
  [21:25:24.466] Packages needed by the future expression (n = 0): <none>
  [21:25:24.466] Packages needed by future strategies (n = 0): <none>
  [21:25:24.470] {
  [21:25:24.470]     {
  [21:25:24.470]         ...future.startTime <- base::Sys.time()
  [21:25:24.470]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:24.470]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:24.470]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:24.470]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:24.470]             future.resolve.recursive = NULL, width = 80L)
  [21:25:24.470]         {
  [21:25:24.470]             {
  [21:25:24.470]                 base::local({
  [21:25:24.470]                   has_future <- base::requireNamespace("future", 
  [21:25:24.470]                     quietly = TRUE)
  [21:25:24.470]                   version <- if (has_future) 
  [21:25:24.470]                     utils::packageVersion("future")
  [21:25:24.470]                   else NULL
  [21:25:24.470]                   if (!has_future || version < "1.8.0") {
  [21:25:24.470]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:24.470]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:24.470]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:24.470]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:24.470]                         "release", "version")], collapse = " "), 
  [21:25:24.470]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:24.470]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:24.470]                       info)
  [21:25:24.470]                     info <- base::paste(info, collapse = "; ")
  [21:25:24.470]                     if (!has_future) {
  [21:25:24.470]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:24.470]                         info)
  [21:25:24.470]                     }
  [21:25:24.470]                     else {
  [21:25:24.470]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:24.470]                         info, version)
  [21:25:24.470]                     }
  [21:25:24.470]                     base::stop(msg)
  [21:25:24.470]                   }
  [21:25:24.470]                 })
  [21:25:24.470]             }
  [21:25:24.470]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:24.470]         }
  [21:25:24.470]     }
  [21:25:24.470]     if (base::is.na(TRUE)) {
  [21:25:24.470]     }
  [21:25:24.470]     else {
  [21:25:24.470]         if (TRUE) {
  [21:25:24.470]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:24.470]                 open = "w")
  [21:25:24.470]         }
  [21:25:24.470]         else {
  [21:25:24.470]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:24.470]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:24.470]         }
  [21:25:24.470]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:24.470]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:24.470]             base::sink(type = "output", split = FALSE)
  [21:25:24.470]             base::close(...future.stdout)
  [21:25:24.470]         }, add = TRUE)
  [21:25:24.470]     }
  [21:25:24.470]     ...future.frame <- base::sys.nframe()
  [21:25:24.470]     ...future.conditions <- base::list()
  [21:25:24.470]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:24.470]     ...future.result <- base::tryCatch({
  [21:25:24.470]         base::withCallingHandlers({
  [21:25:24.470]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:24.470]             future::FutureResult(value = ...future.value$value, 
  [21:25:24.470]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.470]                   ...future.rng), started = ...future.startTime, 
  [21:25:24.470]                 version = "1.8")
  [21:25:24.470]         }, condition = base::local({
  [21:25:24.470]             c <- base::c
  [21:25:24.470]             inherits <- base::inherits
  [21:25:24.470]             invokeRestart <- base::invokeRestart
  [21:25:24.470]             length <- base::length
  [21:25:24.470]             list <- base::list
  [21:25:24.470]             seq.int <- base::seq.int
  [21:25:24.470]             signalCondition <- base::signalCondition
  [21:25:24.470]             sys.calls <- base::sys.calls
  [21:25:24.470]             Sys.time <- base::Sys.time
  [21:25:24.470]             `[[` <- base::`[[`
  [21:25:24.470]             `+` <- base::`+`
  [21:25:24.470]             `<<-` <- base::`<<-`
  [21:25:24.470]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:24.470]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:24.470]                   3L)]
  [21:25:24.470]             }
  [21:25:24.470]             function(cond) {
  [21:25:24.470]                 if (inherits(cond, "error")) {
  [21:25:24.470]                   sessionInformation <- function() {
  [21:25:24.470]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:24.470]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:24.470]                       search = base::search(), system = base::Sys.info())
  [21:25:24.470]                   }
  [21:25:24.470]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.470]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:24.470]                     cond$call), session = sessionInformation(), 
  [21:25:24.470]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:24.470]                   signalCondition(cond)
  [21:25:24.470]                 }
  [21:25:24.470]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:24.470]                 ))) {
  [21:25:24.470]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:24.470]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:24.470]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:24.470]                   if (!signal) {
  [21:25:24.470]                     muffleCondition <- function (cond) 
  [21:25:24.470]                     {
  [21:25:24.470]                       inherits <- base::inherits
  [21:25:24.470]                       invokeRestart <- base::invokeRestart
  [21:25:24.470]                       muffled <- FALSE
  [21:25:24.470]                       if (inherits(cond, "message")) {
  [21:25:24.470]                         invokeRestart("muffleMessage")
  [21:25:24.470]                         muffled <- TRUE
  [21:25:24.470]                       }
  [21:25:24.470]                       else if (inherits(cond, "warning")) {
  [21:25:24.470]                         invokeRestart("muffleWarning")
  [21:25:24.470]                         muffled <- TRUE
  [21:25:24.470]                       }
  [21:25:24.470]                       else if (inherits(cond, "condition")) {
  [21:25:24.470]                         computeRestarts <- base::computeRestarts
  [21:25:24.470]                         grepl <- base::grepl
  [21:25:24.470]                         is.null <- base::is.null
  [21:25:24.470]                         restarts <- computeRestarts(cond)
  [21:25:24.470]                         for (restart in restarts) {
  [21:25:24.470]                           name <- restart$name
  [21:25:24.470]                           if (is.null(name)) 
  [21:25:24.470]                             next
  [21:25:24.470]                           if (!grepl("^muffle", name)) 
  [21:25:24.470]                             next
  [21:25:24.470]                           invokeRestart(restart)
  [21:25:24.470]                           muffled <- TRUE
  [21:25:24.470]                           break
  [21:25:24.470]                         }
  [21:25:24.470]                       }
  [21:25:24.470]                       invisible(muffled)
  [21:25:24.470]                     }
  [21:25:24.470]                     muffleCondition(cond)
  [21:25:24.470]                   }
  [21:25:24.470]                 }
  [21:25:24.470]             }
  [21:25:24.470]         }))
  [21:25:24.470]     }, error = function(ex) {
  [21:25:24.470]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:24.470]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:24.470]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:24.470]     }, finally = {
  [21:25:24.470]         {
  [21:25:24.470]             NULL
  [21:25:24.470]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:24.470]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:24.470]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:24.470]                 label = NULL, ...) 
  [21:25:24.470]             {
  [21:25:24.470]                 if (substitute) 
  [21:25:24.470]                   expr <- substitute(expr)
  [21:25:24.470]                 local <- as.logical(local)
  [21:25:24.470]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:24.470]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:24.470]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:24.470]                   label = label, ...)
  [21:25:24.470]                 if (!future$lazy) 
  [21:25:24.470]                   future <- run(future)
  [21:25:24.470]                 invisible(future)
  [21:25:24.470]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:24.470]         }
  [21:25:24.470]         base::options(...future.oldOptions)
  [21:25:24.470]     })
  [21:25:24.470]     Sys.time
  [21:25:24.470]     if (base::is.na(TRUE)) {
  [21:25:24.470]     }
  [21:25:24.470]     else {
  [21:25:24.470]         base::sink(type = "output", split = FALSE)
  [21:25:24.470]         if (TRUE) {
  [21:25:24.470]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:24.470]         }
  [21:25:24.470]         else {
  [21:25:24.470]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:24.470]         }
  [21:25:24.470]         base::close(...future.stdout)
  [21:25:24.470]         ...future.stdout <- NULL
  [21:25:24.470]     }
  [21:25:24.470]     ...future.result$conditions <- ...future.conditions
  [21:25:24.470]     ...future.result
  [21:25:24.470] }
  [21:25:24.491] plan(): Setting new future strategy stack:
  [21:25:24.491] List of future strategies:
  [21:25:24.491] 1. sequential:
  [21:25:24.491]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.491]    - tweaked: FALSE
  [21:25:24.491]    - call: NULL
  [21:25:24.492] plan(): nbrOfWorkers() = 1
  [21:25:24.493] plan(): Setting new future strategy stack:
  [21:25:24.494] List of future strategies:
  [21:25:24.494] 1. sequential:
  [21:25:24.494]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.494]    - tweaked: FALSE
  [21:25:24.494]    - call: plan(strategy)
  [21:25:24.494] plan(): nbrOfWorkers() = 1
  [21:25:24.495] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22567d88> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef228c68d8> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef22567d88> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ef228c68d8> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:4] 2 1 3 1
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:24.536] resolve() on list ...
  [21:25:24.536]  recursive: 0
  [21:25:24.536]  length: 6
  [21:25:24.536]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:24.537] signalConditionsASAP(numeric, pos=1) ...
  [21:25:24.537] - nx: 6
  [21:25:24.537] - relay: TRUE
  [21:25:24.537] - stdout: TRUE
  [21:25:24.545] - signal: TRUE
  [21:25:24.546] - resignal: FALSE
  [21:25:24.546] - force: TRUE
  [21:25:24.546] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.547] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.547]  - until=2
  [21:25:24.547]  - relaying element #2
  [21:25:24.547] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.548] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.548] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:24.548]  length: 5 (resolved future 1)
  [21:25:24.549] Future #2
  [21:25:24.549] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:24.549] - nx: 6
  [21:25:24.550] - relay: TRUE
  [21:25:24.550] - stdout: TRUE
  [21:25:24.550] - signal: TRUE
  [21:25:24.550] - resignal: FALSE
  [21:25:24.551] - force: TRUE
  [21:25:24.551] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.551] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.551]  - until=2
  [21:25:24.552]  - relaying element #2
  [21:25:24.552] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.552] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.553] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:24.553]  length: 4 (resolved future 2)
  [21:25:24.553] Future #3
  [21:25:24.554] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:24.554] - nx: 6
  [21:25:24.554] - relay: TRUE
  [21:25:24.554] - stdout: TRUE
  [21:25:24.555] - signal: TRUE
  [21:25:24.555] - resignal: FALSE
  [21:25:24.555] - force: TRUE
  [21:25:24.555] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.557] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:24.557]  - until=3
  [21:25:24.557]  - relaying element #3
  [21:25:24.558] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.558] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.559] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:24.559]  length: 3 (resolved future 3)
  [21:25:24.559] signalConditionsASAP(NULL, pos=4) ...
  [21:25:24.560] - nx: 6
  [21:25:24.560] - relay: TRUE
  [21:25:24.560] - stdout: TRUE
  [21:25:24.560] - signal: TRUE
  [21:25:24.561] - resignal: FALSE
  [21:25:24.561] - force: TRUE
  [21:25:24.561] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.561] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.562]  - until=5
  [21:25:24.562]  - relaying element #5
  [21:25:24.562] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.562] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.563] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:24.563]  length: 2 (resolved future 4)
  [21:25:24.563] signalConditionsASAP(NULL, pos=5) ...
  [21:25:24.563] - nx: 6
  [21:25:24.564] - relay: TRUE
  [21:25:24.564] - stdout: TRUE
  [21:25:24.564] - signal: TRUE
  [21:25:24.564] - resignal: FALSE
  [21:25:24.565] - force: TRUE
  [21:25:24.565] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:24.565] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.565]  - until=6
  [21:25:24.566]  - relaying element #6
  [21:25:24.566] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.566] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.567] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:24.567]  length: 1 (resolved future 5)
  [21:25:24.567] signalConditionsASAP(numeric, pos=6) ...
  [21:25:24.567] - nx: 6
  [21:25:24.568] - relay: TRUE
  [21:25:24.568] - stdout: TRUE
  [21:25:24.568] - signal: TRUE
  [21:25:24.568] - resignal: FALSE
  [21:25:24.569] - force: TRUE
  [21:25:24.569] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:24.569] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.572]  - until=6
  [21:25:24.573] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.573] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.574] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:24.574]  length: 0 (resolved future 6)
  [21:25:24.574] Relaying remaining futures
  [21:25:24.575] signalConditionsASAP(NULL, pos=0) ...
  [21:25:24.575] - nx: 6
  [21:25:24.575] - relay: TRUE
  [21:25:24.575] - stdout: TRUE
  [21:25:24.576] - signal: TRUE
  [21:25:24.576] - resignal: FALSE
  [21:25:24.576] - force: TRUE
  [21:25:24.576] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.577] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:24.577] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:24.577] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:24.578] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:24.578] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:4] 2 1 3 1
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  Type of future: cluster
  [21:25:24.593] plan(): Setting new future strategy stack:
  [21:25:24.593] List of future strategies:
  [21:25:24.593] 1. cluster:
  [21:25:24.593]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.593]    - tweaked: FALSE
  [21:25:24.593]    - call: plan(strategy)
  [21:25:24.595] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [21:25:24.595] cluster:
  [21:25:24.595] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:25:24.595] - tweaked: FALSE
  [21:25:24.595] - call: plan(strategy)
  [21:25:24.596] getGlobalsAndPackages() ...
  [21:25:24.597] Not searching for globals
  [21:25:24.597] - globals: [0] <none>
  [21:25:24.598] getGlobalsAndPackages() ... DONE
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 27288
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c5ad007f2.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c5ad007f2.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futures.R:gimli2:hornik:32556' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c5ad007f2.pid")), silent = TRUE)' -e 'workRSOCK <- tryCatch(parallel:::.slaveRSOCK, error=function(e) parallel:::.workRSOCK); workRSOCK()' MASTER=localhost PORT=27288 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 1 ... done
  [21:25:26.051] Packages needed by the future expression (n = 0): <none>
  [21:25:26.051] Packages needed by future strategies (n = 0): <none>
  [21:25:26.056] {
  [21:25:26.056]     {
  [21:25:26.056]         ...future.startTime <- base::Sys.time()
  [21:25:26.056]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.056]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.056]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.056]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.056]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.056]         {
  [21:25:26.056]             {
  [21:25:26.056]                 base::local({
  [21:25:26.056]                   has_future <- base::requireNamespace("future", 
  [21:25:26.056]                     quietly = TRUE)
  [21:25:26.056]                   version <- if (has_future) 
  [21:25:26.056]                     utils::packageVersion("future")
  [21:25:26.056]                   else NULL
  [21:25:26.056]                   if (!has_future || version < "1.8.0") {
  [21:25:26.056]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.056]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.056]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.056]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.056]                         "release", "version")], collapse = " "), 
  [21:25:26.056]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.056]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.056]                       info)
  [21:25:26.056]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.056]                     if (!has_future) {
  [21:25:26.056]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.056]                         info)
  [21:25:26.056]                     }
  [21:25:26.056]                     else {
  [21:25:26.056]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.056]                         info, version)
  [21:25:26.056]                     }
  [21:25:26.056]                     base::stop(msg)
  [21:25:26.056]                   }
  [21:25:26.056]                 })
  [21:25:26.056]             }
  [21:25:26.056]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.056]         }
  [21:25:26.056]     }
  [21:25:26.056]     if (base::is.na(TRUE)) {
  [21:25:26.056]     }
  [21:25:26.056]     else {
  [21:25:26.056]         if (TRUE) {
  [21:25:26.056]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.056]                 open = "w")
  [21:25:26.056]         }
  [21:25:26.056]         else {
  [21:25:26.056]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.056]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.056]         }
  [21:25:26.056]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.056]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.056]             base::sink(type = "output", split = FALSE)
  [21:25:26.056]             base::close(...future.stdout)
  [21:25:26.056]         }, add = TRUE)
  [21:25:26.056]     }
  [21:25:26.056]     ...future.frame <- base::sys.nframe()
  [21:25:26.056]     ...future.conditions <- base::list()
  [21:25:26.056]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.056]     ...future.result <- base::tryCatch({
  [21:25:26.056]         base::withCallingHandlers({
  [21:25:26.056]             ...future.value <- base::withVisible(base::local({
  [21:25:26.056]                 ...future.sendCondition <- local({
  [21:25:26.056]                   sendCondition <- NULL
  [21:25:26.056]                   function(frame = 1L) {
  [21:25:26.056]                     if (is.function(sendCondition)) 
  [21:25:26.056]                       return(sendCondition)
  [21:25:26.056]                     ns <- getNamespace("parallel")
  [21:25:26.056]                     if (exists("sendData", mode = "function", 
  [21:25:26.056]                       envir = ns)) {
  [21:25:26.056]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.056]                         envir = ns)
  [21:25:26.056]                       envir <- sys.frame(frame)
  [21:25:26.056]                       master <- NULL
  [21:25:26.056]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.056]                         !identical(envir, emptyenv())) {
  [21:25:26.056]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.056]                           inherits = FALSE)) {
  [21:25:26.056]                           master <- get("master", mode = "list", 
  [21:25:26.056]                             envir = envir, inherits = FALSE)
  [21:25:26.056]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.056]                             sendCondition <<- function(cond) {
  [21:25:26.056]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.056]                                 success = TRUE)
  [21:25:26.056]                               parallel_sendData(master, data)
  [21:25:26.056]                             }
  [21:25:26.056]                             return(sendCondition)
  [21:25:26.056]                           }
  [21:25:26.056]                         }
  [21:25:26.056]                         frame <- frame + 1L
  [21:25:26.056]                         envir <- sys.frame(frame)
  [21:25:26.056]                       }
  [21:25:26.056]                     }
  [21:25:26.056]                     sendCondition <<- function(cond) NULL
  [21:25:26.056]                   }
  [21:25:26.056]                 })
  [21:25:26.056]                 withCallingHandlers({
  [21:25:26.056]                   NA
  [21:25:26.056]                 }, immediateCondition = function(cond) {
  [21:25:26.056]                   sendCondition <- ...future.sendCondition()
  [21:25:26.056]                   sendCondition(cond)
  [21:25:26.056]                   muffleCondition <- function (cond) 
  [21:25:26.056]                   {
  [21:25:26.056]                     inherits <- base::inherits
  [21:25:26.056]                     invokeRestart <- base::invokeRestart
  [21:25:26.056]                     muffled <- FALSE
  [21:25:26.056]                     if (inherits(cond, "message")) {
  [21:25:26.056]                       invokeRestart("muffleMessage")
  [21:25:26.056]                       muffled <- TRUE
  [21:25:26.056]                     }
  [21:25:26.056]                     else if (inherits(cond, "warning")) {
  [21:25:26.056]                       invokeRestart("muffleWarning")
  [21:25:26.056]                       muffled <- TRUE
  [21:25:26.056]                     }
  [21:25:26.056]                     else if (inherits(cond, "condition")) {
  [21:25:26.056]                       computeRestarts <- base::computeRestarts
  [21:25:26.056]                       grepl <- base::grepl
  [21:25:26.056]                       is.null <- base::is.null
  [21:25:26.056]                       restarts <- computeRestarts(cond)
  [21:25:26.056]                       for (restart in restarts) {
  [21:25:26.056]                         name <- restart$name
  [21:25:26.056]                         if (is.null(name)) 
  [21:25:26.056]                           next
  [21:25:26.056]                         if (!grepl("^muffle", name)) 
  [21:25:26.056]                           next
  [21:25:26.056]                         invokeRestart(restart)
  [21:25:26.056]                         muffled <- TRUE
  [21:25:26.056]                         break
  [21:25:26.056]                       }
  [21:25:26.056]                     }
  [21:25:26.056]                     invisible(muffled)
  [21:25:26.056]                   }
  [21:25:26.056]                   muffleCondition(cond)
  [21:25:26.056]                 })
  [21:25:26.056]             }))
  [21:25:26.056]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.056]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.056]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.056]                 version = "1.8")
  [21:25:26.056]         }, condition = base::local({
  [21:25:26.056]             c <- base::c
  [21:25:26.056]             inherits <- base::inherits
  [21:25:26.056]             invokeRestart <- base::invokeRestart
  [21:25:26.056]             length <- base::length
  [21:25:26.056]             list <- base::list
  [21:25:26.056]             seq.int <- base::seq.int
  [21:25:26.056]             signalCondition <- base::signalCondition
  [21:25:26.056]             sys.calls <- base::sys.calls
  [21:25:26.056]             Sys.time <- base::Sys.time
  [21:25:26.056]             `[[` <- base::`[[`
  [21:25:26.056]             `+` <- base::`+`
  [21:25:26.056]             `<<-` <- base::`<<-`
  [21:25:26.056]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.056]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.056]                   3L)]
  [21:25:26.056]             }
  [21:25:26.056]             function(cond) {
  [21:25:26.056]                 if (inherits(cond, "error")) {
  [21:25:26.056]                   sessionInformation <- function() {
  [21:25:26.056]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.056]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.056]                       search = base::search(), system = base::Sys.info())
  [21:25:26.056]                   }
  [21:25:26.056]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.056]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.056]                     cond$call), session = sessionInformation(), 
  [21:25:26.056]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.056]                   signalCondition(cond)
  [21:25:26.056]                 }
  [21:25:26.056]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.056]                 ))) {
  [21:25:26.056]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.056]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.056]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.056]                   if (!signal) {
  [21:25:26.056]                     muffleCondition <- function (cond) 
  [21:25:26.056]                     {
  [21:25:26.056]                       inherits <- base::inherits
  [21:25:26.056]                       invokeRestart <- base::invokeRestart
  [21:25:26.056]                       muffled <- FALSE
  [21:25:26.056]                       if (inherits(cond, "message")) {
  [21:25:26.056]                         invokeRestart("muffleMessage")
  [21:25:26.056]                         muffled <- TRUE
  [21:25:26.056]                       }
  [21:25:26.056]                       else if (inherits(cond, "warning")) {
  [21:25:26.056]                         invokeRestart("muffleWarning")
  [21:25:26.056]                         muffled <- TRUE
  [21:25:26.056]                       }
  [21:25:26.056]                       else if (inherits(cond, "condition")) {
  [21:25:26.056]                         computeRestarts <- base::computeRestarts
  [21:25:26.056]                         grepl <- base::grepl
  [21:25:26.056]                         is.null <- base::is.null
  [21:25:26.056]                         restarts <- computeRestarts(cond)
  [21:25:26.056]                         for (restart in restarts) {
  [21:25:26.056]                           name <- restart$name
  [21:25:26.056]                           if (is.null(name)) 
  [21:25:26.056]                             next
  [21:25:26.056]                           if (!grepl("^muffle", name)) 
  [21:25:26.056]                             next
  [21:25:26.056]                           invokeRestart(restart)
  [21:25:26.056]                           muffled <- TRUE
  [21:25:26.056]                           break
  [21:25:26.056]                         }
  [21:25:26.056]                       }
  [21:25:26.056]                       invisible(muffled)
  [21:25:26.056]                     }
  [21:25:26.056]                     muffleCondition(cond)
  [21:25:26.056]                   }
  [21:25:26.056]                 }
  [21:25:26.056]             }
  [21:25:26.056]         }))
  [21:25:26.056]     }, error = function(ex) {
  [21:25:26.056]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.056]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.056]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.056]     }, finally = {
  [21:25:26.056]         {
  [21:25:26.056]             NULL
  [21:25:26.056]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.056]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.056]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.056]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.056]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.056]                 ...) 
  [21:25:26.056]             {
  [21:25:26.056]                 if (substitute) 
  [21:25:26.056]                   expr <- substitute(expr)
  [21:25:26.056]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.056]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.056]                   globals = globals, persistent = persistent, 
  [21:25:26.056]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.056]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.056]                   label = label, ...)
  [21:25:26.056]                 if (!future$lazy) 
  [21:25:26.056]                   future <- run(future)
  [21:25:26.056]                 invisible(future)
  [21:25:26.056]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.056]         }
  [21:25:26.056]         base::options(...future.oldOptions)
  [21:25:26.056]     })
  [21:25:26.056]     Sys.time
  [21:25:26.056]     if (base::is.na(TRUE)) {
  [21:25:26.056]     }
  [21:25:26.056]     else {
  [21:25:26.056]         base::sink(type = "output", split = FALSE)
  [21:25:26.056]         if (TRUE) {
  [21:25:26.056]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.056]         }
  [21:25:26.056]         else {
  [21:25:26.056]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.056]         }
  [21:25:26.056]         base::close(...future.stdout)
  [21:25:26.056]         ...future.stdout <- NULL
  [21:25:26.056]     }
  [21:25:26.056]     ...future.result$conditions <- ...future.conditions
  [21:25:26.056]     ...future.result
  [21:25:26.056] }
  [21:25:26.075] ClusterFuture started
  [21:25:26.075] result() for ClusterFuture ...
  [21:25:26.076] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.077] - Validating connection of ClusterFuture
  [21:25:26.281] - received message: FutureResult
  [21:25:26.282] - Received FutureResult
  [21:25:26.287] - Erased future from FutureRegistry
  [21:25:26.288] result() for ClusterFuture ...
  [21:25:26.288] - result already collected: FutureResult
  [21:25:26.288] result() for ClusterFuture ... done
  [21:25:26.289] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:26.289] result() for ClusterFuture ... done
  [21:25:26.289] result() for ClusterFuture ...
  [21:25:26.290] - result already collected: FutureResult
  [21:25:26.290] result() for ClusterFuture ... done
  [21:25:26.290] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [21:25:26.292] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [21:25:26.292] getGlobalsAndPackages() ...
  [21:25:26.292] Searching for globals...
  [21:25:26.293] 
  [21:25:26.293] Searching for globals ... DONE
  [21:25:26.306] - globals: [0] <none>
  [21:25:26.306] getGlobalsAndPackages() ... DONE
  [21:25:26.310] Packages needed by the future expression (n = 0): <none>
  [21:25:26.310] Packages needed by future strategies (n = 0): <none>
  [21:25:26.314] {
  [21:25:26.314]     {
  [21:25:26.314]         ...future.startTime <- base::Sys.time()
  [21:25:26.314]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.314]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.314]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.314]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.314]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.314]         {
  [21:25:26.314]             {
  [21:25:26.314]                 base::local({
  [21:25:26.314]                   has_future <- base::requireNamespace("future", 
  [21:25:26.314]                     quietly = TRUE)
  [21:25:26.314]                   version <- if (has_future) 
  [21:25:26.314]                     utils::packageVersion("future")
  [21:25:26.314]                   else NULL
  [21:25:26.314]                   if (!has_future || version < "1.8.0") {
  [21:25:26.314]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.314]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.314]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.314]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.314]                         "release", "version")], collapse = " "), 
  [21:25:26.314]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.314]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.314]                       info)
  [21:25:26.314]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.314]                     if (!has_future) {
  [21:25:26.314]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.314]                         info)
  [21:25:26.314]                     }
  [21:25:26.314]                     else {
  [21:25:26.314]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.314]                         info, version)
  [21:25:26.314]                     }
  [21:25:26.314]                     base::stop(msg)
  [21:25:26.314]                   }
  [21:25:26.314]                 })
  [21:25:26.314]             }
  [21:25:26.314]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.314]         }
  [21:25:26.314]     }
  [21:25:26.314]     if (base::is.na(TRUE)) {
  [21:25:26.314]     }
  [21:25:26.314]     else {
  [21:25:26.314]         if (TRUE) {
  [21:25:26.314]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.314]                 open = "w")
  [21:25:26.314]         }
  [21:25:26.314]         else {
  [21:25:26.314]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.314]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.314]         }
  [21:25:26.314]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.314]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.314]             base::sink(type = "output", split = FALSE)
  [21:25:26.314]             base::close(...future.stdout)
  [21:25:26.314]         }, add = TRUE)
  [21:25:26.314]     }
  [21:25:26.314]     ...future.frame <- base::sys.nframe()
  [21:25:26.314]     ...future.conditions <- base::list()
  [21:25:26.314]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.314]     ...future.result <- base::tryCatch({
  [21:25:26.314]         base::withCallingHandlers({
  [21:25:26.314]             ...future.value <- base::withVisible(base::local({
  [21:25:26.314]                 ...future.sendCondition <- local({
  [21:25:26.314]                   sendCondition <- NULL
  [21:25:26.314]                   function(frame = 1L) {
  [21:25:26.314]                     if (is.function(sendCondition)) 
  [21:25:26.314]                       return(sendCondition)
  [21:25:26.314]                     ns <- getNamespace("parallel")
  [21:25:26.314]                     if (exists("sendData", mode = "function", 
  [21:25:26.314]                       envir = ns)) {
  [21:25:26.314]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.314]                         envir = ns)
  [21:25:26.314]                       envir <- sys.frame(frame)
  [21:25:26.314]                       master <- NULL
  [21:25:26.314]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.314]                         !identical(envir, emptyenv())) {
  [21:25:26.314]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.314]                           inherits = FALSE)) {
  [21:25:26.314]                           master <- get("master", mode = "list", 
  [21:25:26.314]                             envir = envir, inherits = FALSE)
  [21:25:26.314]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.314]                             sendCondition <<- function(cond) {
  [21:25:26.314]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.314]                                 success = TRUE)
  [21:25:26.314]                               parallel_sendData(master, data)
  [21:25:26.314]                             }
  [21:25:26.314]                             return(sendCondition)
  [21:25:26.314]                           }
  [21:25:26.314]                         }
  [21:25:26.314]                         frame <- frame + 1L
  [21:25:26.314]                         envir <- sys.frame(frame)
  [21:25:26.314]                       }
  [21:25:26.314]                     }
  [21:25:26.314]                     sendCondition <<- function(cond) NULL
  [21:25:26.314]                   }
  [21:25:26.314]                 })
  [21:25:26.314]                 withCallingHandlers({
  [21:25:26.314]                   2
  [21:25:26.314]                 }, immediateCondition = function(cond) {
  [21:25:26.314]                   sendCondition <- ...future.sendCondition()
  [21:25:26.314]                   sendCondition(cond)
  [21:25:26.314]                   muffleCondition <- function (cond) 
  [21:25:26.314]                   {
  [21:25:26.314]                     inherits <- base::inherits
  [21:25:26.314]                     invokeRestart <- base::invokeRestart
  [21:25:26.314]                     muffled <- FALSE
  [21:25:26.314]                     if (inherits(cond, "message")) {
  [21:25:26.314]                       invokeRestart("muffleMessage")
  [21:25:26.314]                       muffled <- TRUE
  [21:25:26.314]                     }
  [21:25:26.314]                     else if (inherits(cond, "warning")) {
  [21:25:26.314]                       invokeRestart("muffleWarning")
  [21:25:26.314]                       muffled <- TRUE
  [21:25:26.314]                     }
  [21:25:26.314]                     else if (inherits(cond, "condition")) {
  [21:25:26.314]                       computeRestarts <- base::computeRestarts
  [21:25:26.314]                       grepl <- base::grepl
  [21:25:26.314]                       is.null <- base::is.null
  [21:25:26.314]                       restarts <- computeRestarts(cond)
  [21:25:26.314]                       for (restart in restarts) {
  [21:25:26.314]                         name <- restart$name
  [21:25:26.314]                         if (is.null(name)) 
  [21:25:26.314]                           next
  [21:25:26.314]                         if (!grepl("^muffle", name)) 
  [21:25:26.314]                           next
  [21:25:26.314]                         invokeRestart(restart)
  [21:25:26.314]                         muffled <- TRUE
  [21:25:26.314]                         break
  [21:25:26.314]                       }
  [21:25:26.314]                     }
  [21:25:26.314]                     invisible(muffled)
  [21:25:26.314]                   }
  [21:25:26.314]                   muffleCondition(cond)
  [21:25:26.314]                 })
  [21:25:26.314]             }))
  [21:25:26.314]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.314]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.314]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.314]                 version = "1.8")
  [21:25:26.314]         }, condition = base::local({
  [21:25:26.314]             c <- base::c
  [21:25:26.314]             inherits <- base::inherits
  [21:25:26.314]             invokeRestart <- base::invokeRestart
  [21:25:26.314]             length <- base::length
  [21:25:26.314]             list <- base::list
  [21:25:26.314]             seq.int <- base::seq.int
  [21:25:26.314]             signalCondition <- base::signalCondition
  [21:25:26.314]             sys.calls <- base::sys.calls
  [21:25:26.314]             Sys.time <- base::Sys.time
  [21:25:26.314]             `[[` <- base::`[[`
  [21:25:26.314]             `+` <- base::`+`
  [21:25:26.314]             `<<-` <- base::`<<-`
  [21:25:26.314]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.314]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.314]                   3L)]
  [21:25:26.314]             }
  [21:25:26.314]             function(cond) {
  [21:25:26.314]                 if (inherits(cond, "error")) {
  [21:25:26.314]                   sessionInformation <- function() {
  [21:25:26.314]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.314]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.314]                       search = base::search(), system = base::Sys.info())
  [21:25:26.314]                   }
  [21:25:26.314]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.314]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.314]                     cond$call), session = sessionInformation(), 
  [21:25:26.314]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.314]                   signalCondition(cond)
  [21:25:26.314]                 }
  [21:25:26.314]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.314]                 ))) {
  [21:25:26.314]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.314]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.314]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.314]                   if (!signal) {
  [21:25:26.314]                     muffleCondition <- function (cond) 
  [21:25:26.314]                     {
  [21:25:26.314]                       inherits <- base::inherits
  [21:25:26.314]                       invokeRestart <- base::invokeRestart
  [21:25:26.314]                       muffled <- FALSE
  [21:25:26.314]                       if (inherits(cond, "message")) {
  [21:25:26.314]                         invokeRestart("muffleMessage")
  [21:25:26.314]                         muffled <- TRUE
  [21:25:26.314]                       }
  [21:25:26.314]                       else if (inherits(cond, "warning")) {
  [21:25:26.314]                         invokeRestart("muffleWarning")
  [21:25:26.314]                         muffled <- TRUE
  [21:25:26.314]                       }
  [21:25:26.314]                       else if (inherits(cond, "condition")) {
  [21:25:26.314]                         computeRestarts <- base::computeRestarts
  [21:25:26.314]                         grepl <- base::grepl
  [21:25:26.314]                         is.null <- base::is.null
  [21:25:26.314]                         restarts <- computeRestarts(cond)
  [21:25:26.314]                         for (restart in restarts) {
  [21:25:26.314]                           name <- restart$name
  [21:25:26.314]                           if (is.null(name)) 
  [21:25:26.314]                             next
  [21:25:26.314]                           if (!grepl("^muffle", name)) 
  [21:25:26.314]                             next
  [21:25:26.314]                           invokeRestart(restart)
  [21:25:26.314]                           muffled <- TRUE
  [21:25:26.314]                           break
  [21:25:26.314]                         }
  [21:25:26.314]                       }
  [21:25:26.314]                       invisible(muffled)
  [21:25:26.314]                     }
  [21:25:26.314]                     muffleCondition(cond)
  [21:25:26.314]                   }
  [21:25:26.314]                 }
  [21:25:26.314]             }
  [21:25:26.314]         }))
  [21:25:26.314]     }, error = function(ex) {
  [21:25:26.314]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.314]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.314]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.314]     }, finally = {
  [21:25:26.314]         {
  [21:25:26.314]             NULL
  [21:25:26.314]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.314]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.314]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.314]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.314]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.314]                 ...) 
  [21:25:26.314]             {
  [21:25:26.314]                 if (substitute) 
  [21:25:26.314]                   expr <- substitute(expr)
  [21:25:26.314]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.314]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.314]                   globals = globals, persistent = persistent, 
  [21:25:26.314]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.314]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.314]                   label = label, ...)
  [21:25:26.314]                 if (!future$lazy) 
  [21:25:26.314]                   future <- run(future)
  [21:25:26.314]                 invisible(future)
  [21:25:26.314]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.314]         }
  [21:25:26.314]         base::options(...future.oldOptions)
  [21:25:26.314]     })
  [21:25:26.314]     Sys.time
  [21:25:26.314]     if (base::is.na(TRUE)) {
  [21:25:26.314]     }
  [21:25:26.314]     else {
  [21:25:26.314]         base::sink(type = "output", split = FALSE)
  [21:25:26.314]         if (TRUE) {
  [21:25:26.314]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.314]         }
  [21:25:26.314]         else {
  [21:25:26.314]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.314]         }
  [21:25:26.314]         base::close(...future.stdout)
  [21:25:26.314]         ...future.stdout <- NULL
  [21:25:26.314]     }
  [21:25:26.314]     ...future.result$conditions <- ...future.conditions
  [21:25:26.314]     ...future.result
  [21:25:26.314] }
  [21:25:26.333] ClusterFuture started
  [21:25:26.333] getGlobalsAndPackages() ...
  [21:25:26.334] Searching for globals...
  [21:25:26.334] 
  [21:25:26.335] Searching for globals ... DONE
  [21:25:26.335] - globals: [0] <none>
  [21:25:26.335] getGlobalsAndPackages() ... DONE
  [21:25:26.339] Packages needed by the future expression (n = 0): <none>
  [21:25:26.339] Packages needed by future strategies (n = 0): <none>
  [21:25:26.343] {
  [21:25:26.343]     {
  [21:25:26.343]         ...future.startTime <- base::Sys.time()
  [21:25:26.343]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.343]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.343]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.343]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.343]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.343]         {
  [21:25:26.343]             {
  [21:25:26.343]                 base::local({
  [21:25:26.343]                   has_future <- base::requireNamespace("future", 
  [21:25:26.343]                     quietly = TRUE)
  [21:25:26.343]                   version <- if (has_future) 
  [21:25:26.343]                     utils::packageVersion("future")
  [21:25:26.343]                   else NULL
  [21:25:26.343]                   if (!has_future || version < "1.8.0") {
  [21:25:26.343]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.343]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.343]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.343]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.343]                         "release", "version")], collapse = " "), 
  [21:25:26.343]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.343]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.343]                       info)
  [21:25:26.343]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.343]                     if (!has_future) {
  [21:25:26.343]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.343]                         info)
  [21:25:26.343]                     }
  [21:25:26.343]                     else {
  [21:25:26.343]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.343]                         info, version)
  [21:25:26.343]                     }
  [21:25:26.343]                     base::stop(msg)
  [21:25:26.343]                   }
  [21:25:26.343]                 })
  [21:25:26.343]             }
  [21:25:26.343]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.343]         }
  [21:25:26.343]     }
  [21:25:26.343]     if (base::is.na(TRUE)) {
  [21:25:26.343]     }
  [21:25:26.343]     else {
  [21:25:26.343]         if (TRUE) {
  [21:25:26.343]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.343]                 open = "w")
  [21:25:26.343]         }
  [21:25:26.343]         else {
  [21:25:26.343]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.343]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.343]         }
  [21:25:26.343]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.343]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.343]             base::sink(type = "output", split = FALSE)
  [21:25:26.343]             base::close(...future.stdout)
  [21:25:26.343]         }, add = TRUE)
  [21:25:26.343]     }
  [21:25:26.343]     ...future.frame <- base::sys.nframe()
  [21:25:26.343]     ...future.conditions <- base::list()
  [21:25:26.343]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.343]     ...future.result <- base::tryCatch({
  [21:25:26.343]         base::withCallingHandlers({
  [21:25:26.343]             ...future.value <- base::withVisible(base::local({
  [21:25:26.343]                 ...future.sendCondition <- local({
  [21:25:26.343]                   sendCondition <- NULL
  [21:25:26.343]                   function(frame = 1L) {
  [21:25:26.343]                     if (is.function(sendCondition)) 
  [21:25:26.343]                       return(sendCondition)
  [21:25:26.343]                     ns <- getNamespace("parallel")
  [21:25:26.343]                     if (exists("sendData", mode = "function", 
  [21:25:26.343]                       envir = ns)) {
  [21:25:26.343]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.343]                         envir = ns)
  [21:25:26.343]                       envir <- sys.frame(frame)
  [21:25:26.343]                       master <- NULL
  [21:25:26.343]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.343]                         !identical(envir, emptyenv())) {
  [21:25:26.343]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.343]                           inherits = FALSE)) {
  [21:25:26.343]                           master <- get("master", mode = "list", 
  [21:25:26.343]                             envir = envir, inherits = FALSE)
  [21:25:26.343]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.343]                             sendCondition <<- function(cond) {
  [21:25:26.343]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.343]                                 success = TRUE)
  [21:25:26.343]                               parallel_sendData(master, data)
  [21:25:26.343]                             }
  [21:25:26.343]                             return(sendCondition)
  [21:25:26.343]                           }
  [21:25:26.343]                         }
  [21:25:26.343]                         frame <- frame + 1L
  [21:25:26.343]                         envir <- sys.frame(frame)
  [21:25:26.343]                       }
  [21:25:26.343]                     }
  [21:25:26.343]                     sendCondition <<- function(cond) NULL
  [21:25:26.343]                   }
  [21:25:26.343]                 })
  [21:25:26.343]                 withCallingHandlers({
  [21:25:26.343]                   NULL
  [21:25:26.343]                 }, immediateCondition = function(cond) {
  [21:25:26.343]                   sendCondition <- ...future.sendCondition()
  [21:25:26.343]                   sendCondition(cond)
  [21:25:26.343]                   muffleCondition <- function (cond) 
  [21:25:26.343]                   {
  [21:25:26.343]                     inherits <- base::inherits
  [21:25:26.343]                     invokeRestart <- base::invokeRestart
  [21:25:26.343]                     muffled <- FALSE
  [21:25:26.343]                     if (inherits(cond, "message")) {
  [21:25:26.343]                       invokeRestart("muffleMessage")
  [21:25:26.343]                       muffled <- TRUE
  [21:25:26.343]                     }
  [21:25:26.343]                     else if (inherits(cond, "warning")) {
  [21:25:26.343]                       invokeRestart("muffleWarning")
  [21:25:26.343]                       muffled <- TRUE
  [21:25:26.343]                     }
  [21:25:26.343]                     else if (inherits(cond, "condition")) {
  [21:25:26.343]                       computeRestarts <- base::computeRestarts
  [21:25:26.343]                       grepl <- base::grepl
  [21:25:26.343]                       is.null <- base::is.null
  [21:25:26.343]                       restarts <- computeRestarts(cond)
  [21:25:26.343]                       for (restart in restarts) {
  [21:25:26.343]                         name <- restart$name
  [21:25:26.343]                         if (is.null(name)) 
  [21:25:26.343]                           next
  [21:25:26.343]                         if (!grepl("^muffle", name)) 
  [21:25:26.343]                           next
  [21:25:26.343]                         invokeRestart(restart)
  [21:25:26.343]                         muffled <- TRUE
  [21:25:26.343]                         break
  [21:25:26.343]                       }
  [21:25:26.343]                     }
  [21:25:26.343]                     invisible(muffled)
  [21:25:26.343]                   }
  [21:25:26.343]                   muffleCondition(cond)
  [21:25:26.343]                 })
  [21:25:26.343]             }))
  [21:25:26.343]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.343]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.343]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.343]                 version = "1.8")
  [21:25:26.343]         }, condition = base::local({
  [21:25:26.343]             c <- base::c
  [21:25:26.343]             inherits <- base::inherits
  [21:25:26.343]             invokeRestart <- base::invokeRestart
  [21:25:26.343]             length <- base::length
  [21:25:26.343]             list <- base::list
  [21:25:26.343]             seq.int <- base::seq.int
  [21:25:26.343]             signalCondition <- base::signalCondition
  [21:25:26.343]             sys.calls <- base::sys.calls
  [21:25:26.343]             Sys.time <- base::Sys.time
  [21:25:26.343]             `[[` <- base::`[[`
  [21:25:26.343]             `+` <- base::`+`
  [21:25:26.343]             `<<-` <- base::`<<-`
  [21:25:26.343]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.343]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.343]                   3L)]
  [21:25:26.343]             }
  [21:25:26.343]             function(cond) {
  [21:25:26.343]                 if (inherits(cond, "error")) {
  [21:25:26.343]                   sessionInformation <- function() {
  [21:25:26.343]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.343]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.343]                       search = base::search(), system = base::Sys.info())
  [21:25:26.343]                   }
  [21:25:26.343]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.343]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.343]                     cond$call), session = sessionInformation(), 
  [21:25:26.343]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.343]                   signalCondition(cond)
  [21:25:26.343]                 }
  [21:25:26.343]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.343]                 ))) {
  [21:25:26.343]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.343]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.343]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.343]                   if (!signal) {
  [21:25:26.343]                     muffleCondition <- function (cond) 
  [21:25:26.343]                     {
  [21:25:26.343]                       inherits <- base::inherits
  [21:25:26.343]                       invokeRestart <- base::invokeRestart
  [21:25:26.343]                       muffled <- FALSE
  [21:25:26.343]                       if (inherits(cond, "message")) {
  [21:25:26.343]                         invokeRestart("muffleMessage")
  [21:25:26.343]                         muffled <- TRUE
  [21:25:26.343]                       }
  [21:25:26.343]                       else if (inherits(cond, "warning")) {
  [21:25:26.343]                         invokeRestart("muffleWarning")
  [21:25:26.343]                         muffled <- TRUE
  [21:25:26.343]                       }
  [21:25:26.343]                       else if (inherits(cond, "condition")) {
  [21:25:26.343]                         computeRestarts <- base::computeRestarts
  [21:25:26.343]                         grepl <- base::grepl
  [21:25:26.343]                         is.null <- base::is.null
  [21:25:26.343]                         restarts <- computeRestarts(cond)
  [21:25:26.343]                         for (restart in restarts) {
  [21:25:26.343]                           name <- restart$name
  [21:25:26.343]                           if (is.null(name)) 
  [21:25:26.343]                             next
  [21:25:26.343]                           if (!grepl("^muffle", name)) 
  [21:25:26.343]                             next
  [21:25:26.343]                           invokeRestart(restart)
  [21:25:26.343]                           muffled <- TRUE
  [21:25:26.343]                           break
  [21:25:26.343]                         }
  [21:25:26.343]                       }
  [21:25:26.343]                       invisible(muffled)
  [21:25:26.343]                     }
  [21:25:26.343]                     muffleCondition(cond)
  [21:25:26.343]                   }
  [21:25:26.343]                 }
  [21:25:26.343]             }
  [21:25:26.343]         }))
  [21:25:26.343]     }, error = function(ex) {
  [21:25:26.343]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.343]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.343]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.343]     }, finally = {
  [21:25:26.343]         {
  [21:25:26.343]             NULL
  [21:25:26.343]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.343]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.343]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.343]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.343]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.343]                 ...) 
  [21:25:26.343]             {
  [21:25:26.343]                 if (substitute) 
  [21:25:26.343]                   expr <- substitute(expr)
  [21:25:26.343]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.343]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.343]                   globals = globals, persistent = persistent, 
  [21:25:26.343]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.343]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.343]                   label = label, ...)
  [21:25:26.343]                 if (!future$lazy) 
  [21:25:26.343]                   future <- run(future)
  [21:25:26.343]                 invisible(future)
  [21:25:26.343]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.343]         }
  [21:25:26.343]         base::options(...future.oldOptions)
  [21:25:26.343]     })
  [21:25:26.343]     Sys.time
  [21:25:26.343]     if (base::is.na(TRUE)) {
  [21:25:26.343]     }
  [21:25:26.343]     else {
  [21:25:26.343]         base::sink(type = "output", split = FALSE)
  [21:25:26.343]         if (TRUE) {
  [21:25:26.343]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.343]         }
  [21:25:26.343]         else {
  [21:25:26.343]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.343]         }
  [21:25:26.343]         base::close(...future.stdout)
  [21:25:26.343]         ...future.stdout <- NULL
  [21:25:26.343]     }
  [21:25:26.343]     ...future.result$conditions <- ...future.conditions
  [21:25:26.343]     ...future.result
  [21:25:26.343] }
  [21:25:26.348] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:26.378] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.378] - Validating connection of ClusterFuture
  [21:25:26.378] - received message: FutureResult
  [21:25:26.379] - Received FutureResult
  [21:25:26.379] - Erased future from FutureRegistry
  [21:25:26.379] result() for ClusterFuture ...
  [21:25:26.380] - result already collected: FutureResult
  [21:25:26.380] result() for ClusterFuture ... done
  [21:25:26.380] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:26.381] result() for ClusterFuture ...
  [21:25:26.381] - result already collected: FutureResult
  [21:25:26.381] result() for ClusterFuture ... done
  [21:25:26.381] result() for ClusterFuture ...
  [21:25:26.382] - result already collected: FutureResult
  [21:25:26.382] result() for ClusterFuture ... done
  [21:25:26.385] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22314f98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22785560> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22314f98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22785560> 
   $  : NULL
   $  : NULL
   $  : num 6
  [21:25:26.434] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.434] - Validating connection of ClusterFuture
  [21:25:26.435] - received message: FutureResult
  [21:25:26.435] - Received FutureResult
  [21:25:26.435] - Erased future from FutureRegistry
  [21:25:26.435] result() for ClusterFuture ...
  [21:25:26.436] - result already collected: FutureResult
  [21:25:26.436] result() for ClusterFuture ... done
  [21:25:26.436] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:26.438] resolve() on list ...
  [21:25:26.438]  recursive: 0
  [21:25:26.439]  length: 6
  [21:25:26.439]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:26.439] signalConditionsASAP(numeric, pos=1) ...
  [21:25:26.440] - nx: 6
  [21:25:26.440] - relay: TRUE
  [21:25:26.440] - stdout: TRUE
  [21:25:26.440] - signal: TRUE
  [21:25:26.440] - resignal: FALSE
  [21:25:26.441] - force: TRUE
  [21:25:26.441] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.441] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.442]  - until=2
  [21:25:26.442]  - relaying element #2
  [21:25:26.442] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.442] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.443] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:26.443]  length: 5 (resolved future 1)
  [21:25:26.443] Future #2
  [21:25:26.444] result() for ClusterFuture ...
  [21:25:26.444] - result already collected: FutureResult
  [21:25:26.444] result() for ClusterFuture ... done
  [21:25:26.444] result() for ClusterFuture ...
  [21:25:26.445] - result already collected: FutureResult
  [21:25:26.445] result() for ClusterFuture ... done
  [21:25:26.445] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:26.446] - nx: 6
  [21:25:26.446] - relay: TRUE
  [21:25:26.446] - stdout: TRUE
  [21:25:26.446] - signal: TRUE
  [21:25:26.447] - resignal: FALSE
  [21:25:26.447] - force: TRUE
  [21:25:26.447] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.447] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.448]  - until=2
  [21:25:26.448]  - relaying element #2
  [21:25:26.448] result() for ClusterFuture ...
  [21:25:26.448] - result already collected: FutureResult
  [21:25:26.449] result() for ClusterFuture ... done
  [21:25:26.449] result() for ClusterFuture ...
  [21:25:26.449] - result already collected: FutureResult
  [21:25:26.450] result() for ClusterFuture ... done
  [21:25:26.450] result() for ClusterFuture ...
  [21:25:26.450] - result already collected: FutureResult
  [21:25:26.451] result() for ClusterFuture ... done
  [21:25:26.451] result() for ClusterFuture ...
  [21:25:26.451] - result already collected: FutureResult
  [21:25:26.451] result() for ClusterFuture ... done
  [21:25:26.452] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.452] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.452] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:26.453]  length: 4 (resolved future 2)
  [21:25:26.453] Future #3
  [21:25:26.453] result() for ClusterFuture ...
  [21:25:26.453] - result already collected: FutureResult
  [21:25:26.470] result() for ClusterFuture ... done
  [21:25:26.470] result() for ClusterFuture ...
  [21:25:26.470] - result already collected: FutureResult
  [21:25:26.471] result() for ClusterFuture ... done
  [21:25:26.471] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:26.471] - nx: 6
  [21:25:26.472] - relay: TRUE
  [21:25:26.472] - stdout: TRUE
  [21:25:26.472] - signal: TRUE
  [21:25:26.472] - resignal: FALSE
  [21:25:26.473] - force: TRUE
  [21:25:26.473] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.473] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.473]  - until=3
  [21:25:26.474]  - relaying element #3
  [21:25:26.474] result() for ClusterFuture ...
  [21:25:26.474] - result already collected: FutureResult
  [21:25:26.475] result() for ClusterFuture ... done
  [21:25:26.475] result() for ClusterFuture ...
  [21:25:26.475] - result already collected: FutureResult
  [21:25:26.475] result() for ClusterFuture ... done
  [21:25:26.476] result() for ClusterFuture ...
  [21:25:26.476] - result already collected: FutureResult
  [21:25:26.476] result() for ClusterFuture ... done
  [21:25:26.477] result() for ClusterFuture ...
  [21:25:26.477] - result already collected: FutureResult
  [21:25:26.477] result() for ClusterFuture ... done
  [21:25:26.477] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.478] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.478] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:26.479]  length: 3 (resolved future 3)
  [21:25:26.479] signalConditionsASAP(NULL, pos=4) ...
  [21:25:26.479] - nx: 6
  [21:25:26.479] - relay: TRUE
  [21:25:26.480] - stdout: TRUE
  [21:25:26.480] - signal: TRUE
  [21:25:26.480] - resignal: FALSE
  [21:25:26.480] - force: TRUE
  [21:25:26.481] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.481] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.481]  - until=5
  [21:25:26.481]  - relaying element #5
  [21:25:26.482] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.482] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.482] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:26.482]  length: 2 (resolved future 4)
  [21:25:26.483] signalConditionsASAP(NULL, pos=5) ...
  [21:25:26.483] - nx: 6
  [21:25:26.483] - relay: TRUE
  [21:25:26.484] - stdout: TRUE
  [21:25:26.484] - signal: TRUE
  [21:25:26.484] - resignal: FALSE
  [21:25:26.484] - force: TRUE
  [21:25:26.484] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.485] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.485]  - until=6
  [21:25:26.485]  - relaying element #6
  [21:25:26.486] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.486] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.486] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:26.486]  length: 1 (resolved future 5)
  [21:25:26.487] signalConditionsASAP(numeric, pos=6) ...
  [21:25:26.487] - nx: 6
  [21:25:26.487] - relay: TRUE
  [21:25:26.487] - stdout: TRUE
  [21:25:26.488] - signal: TRUE
  [21:25:26.488] - resignal: FALSE
  [21:25:26.488] - force: TRUE
  [21:25:26.488] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.489] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.489]  - until=6
  [21:25:26.489] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.490] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.490] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:26.490]  length: 0 (resolved future 6)
  [21:25:26.490] Relaying remaining futures
  [21:25:26.491] signalConditionsASAP(NULL, pos=0) ...
  [21:25:26.491] - nx: 6
  [21:25:26.491] - relay: TRUE
  [21:25:26.491] - stdout: TRUE
  [21:25:26.492] - signal: TRUE
  [21:25:26.492] - resignal: FALSE
  [21:25:26.492] - force: TRUE
  [21:25:26.492] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.493] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:26.493] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.493] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.518] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:26.518] resolve() on list ... DONE
  [21:25:26.518] result() for ClusterFuture ...
  [21:25:26.519] - result already collected: FutureResult
  [21:25:26.519] result() for ClusterFuture ... done
  [21:25:26.519] result() for ClusterFuture ...
  [21:25:26.519] - result already collected: FutureResult
  [21:25:26.520] result() for ClusterFuture ... done
  [21:25:26.520] result() for ClusterFuture ...
  [21:25:26.520] - result already collected: FutureResult
  [21:25:26.521] result() for ClusterFuture ... done
  [21:25:26.521] result() for ClusterFuture ...
  [21:25:26.521] - result already collected: FutureResult
  [21:25:26.521] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [21:25:26.527] getGlobalsAndPackages() ...
  [21:25:26.527] Searching for globals...
  [21:25:26.528] 
  [21:25:26.528] Searching for globals ... DONE
  [21:25:26.528] - globals: [0] <none>
  [21:25:26.529] getGlobalsAndPackages() ... DONE
  [21:25:26.552] Packages needed by the future expression (n = 0): <none>
  [21:25:26.552] Packages needed by future strategies (n = 0): <none>
  [21:25:26.556] {
  [21:25:26.556]     {
  [21:25:26.556]         ...future.startTime <- base::Sys.time()
  [21:25:26.556]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.556]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.556]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.556]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.556]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.556]         {
  [21:25:26.556]             {
  [21:25:26.556]                 base::local({
  [21:25:26.556]                   has_future <- base::requireNamespace("future", 
  [21:25:26.556]                     quietly = TRUE)
  [21:25:26.556]                   version <- if (has_future) 
  [21:25:26.556]                     utils::packageVersion("future")
  [21:25:26.556]                   else NULL
  [21:25:26.556]                   if (!has_future || version < "1.8.0") {
  [21:25:26.556]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.556]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.556]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.556]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.556]                         "release", "version")], collapse = " "), 
  [21:25:26.556]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.556]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.556]                       info)
  [21:25:26.556]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.556]                     if (!has_future) {
  [21:25:26.556]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.556]                         info)
  [21:25:26.556]                     }
  [21:25:26.556]                     else {
  [21:25:26.556]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.556]                         info, version)
  [21:25:26.556]                     }
  [21:25:26.556]                     base::stop(msg)
  [21:25:26.556]                   }
  [21:25:26.556]                 })
  [21:25:26.556]             }
  [21:25:26.556]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.556]         }
  [21:25:26.556]     }
  [21:25:26.556]     if (base::is.na(TRUE)) {
  [21:25:26.556]     }
  [21:25:26.556]     else {
  [21:25:26.556]         if (TRUE) {
  [21:25:26.556]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.556]                 open = "w")
  [21:25:26.556]         }
  [21:25:26.556]         else {
  [21:25:26.556]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.556]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.556]         }
  [21:25:26.556]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.556]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.556]             base::sink(type = "output", split = FALSE)
  [21:25:26.556]             base::close(...future.stdout)
  [21:25:26.556]         }, add = TRUE)
  [21:25:26.556]     }
  [21:25:26.556]     ...future.frame <- base::sys.nframe()
  [21:25:26.556]     ...future.conditions <- base::list()
  [21:25:26.556]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.556]     ...future.result <- base::tryCatch({
  [21:25:26.556]         base::withCallingHandlers({
  [21:25:26.556]             ...future.value <- base::withVisible(base::local({
  [21:25:26.556]                 ...future.sendCondition <- local({
  [21:25:26.556]                   sendCondition <- NULL
  [21:25:26.556]                   function(frame = 1L) {
  [21:25:26.556]                     if (is.function(sendCondition)) 
  [21:25:26.556]                       return(sendCondition)
  [21:25:26.556]                     ns <- getNamespace("parallel")
  [21:25:26.556]                     if (exists("sendData", mode = "function", 
  [21:25:26.556]                       envir = ns)) {
  [21:25:26.556]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.556]                         envir = ns)
  [21:25:26.556]                       envir <- sys.frame(frame)
  [21:25:26.556]                       master <- NULL
  [21:25:26.556]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.556]                         !identical(envir, emptyenv())) {
  [21:25:26.556]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.556]                           inherits = FALSE)) {
  [21:25:26.556]                           master <- get("master", mode = "list", 
  [21:25:26.556]                             envir = envir, inherits = FALSE)
  [21:25:26.556]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.556]                             sendCondition <<- function(cond) {
  [21:25:26.556]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.556]                                 success = TRUE)
  [21:25:26.556]                               parallel_sendData(master, data)
  [21:25:26.556]                             }
  [21:25:26.556]                             return(sendCondition)
  [21:25:26.556]                           }
  [21:25:26.556]                         }
  [21:25:26.556]                         frame <- frame + 1L
  [21:25:26.556]                         envir <- sys.frame(frame)
  [21:25:26.556]                       }
  [21:25:26.556]                     }
  [21:25:26.556]                     sendCondition <<- function(cond) NULL
  [21:25:26.556]                   }
  [21:25:26.556]                 })
  [21:25:26.556]                 withCallingHandlers({
  [21:25:26.556]                   2
  [21:25:26.556]                 }, immediateCondition = function(cond) {
  [21:25:26.556]                   sendCondition <- ...future.sendCondition()
  [21:25:26.556]                   sendCondition(cond)
  [21:25:26.556]                   muffleCondition <- function (cond) 
  [21:25:26.556]                   {
  [21:25:26.556]                     inherits <- base::inherits
  [21:25:26.556]                     invokeRestart <- base::invokeRestart
  [21:25:26.556]                     muffled <- FALSE
  [21:25:26.556]                     if (inherits(cond, "message")) {
  [21:25:26.556]                       invokeRestart("muffleMessage")
  [21:25:26.556]                       muffled <- TRUE
  [21:25:26.556]                     }
  [21:25:26.556]                     else if (inherits(cond, "warning")) {
  [21:25:26.556]                       invokeRestart("muffleWarning")
  [21:25:26.556]                       muffled <- TRUE
  [21:25:26.556]                     }
  [21:25:26.556]                     else if (inherits(cond, "condition")) {
  [21:25:26.556]                       computeRestarts <- base::computeRestarts
  [21:25:26.556]                       grepl <- base::grepl
  [21:25:26.556]                       is.null <- base::is.null
  [21:25:26.556]                       restarts <- computeRestarts(cond)
  [21:25:26.556]                       for (restart in restarts) {
  [21:25:26.556]                         name <- restart$name
  [21:25:26.556]                         if (is.null(name)) 
  [21:25:26.556]                           next
  [21:25:26.556]                         if (!grepl("^muffle", name)) 
  [21:25:26.556]                           next
  [21:25:26.556]                         invokeRestart(restart)
  [21:25:26.556]                         muffled <- TRUE
  [21:25:26.556]                         break
  [21:25:26.556]                       }
  [21:25:26.556]                     }
  [21:25:26.556]                     invisible(muffled)
  [21:25:26.556]                   }
  [21:25:26.556]                   muffleCondition(cond)
  [21:25:26.556]                 })
  [21:25:26.556]             }))
  [21:25:26.556]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.556]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.556]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.556]                 version = "1.8")
  [21:25:26.556]         }, condition = base::local({
  [21:25:26.556]             c <- base::c
  [21:25:26.556]             inherits <- base::inherits
  [21:25:26.556]             invokeRestart <- base::invokeRestart
  [21:25:26.556]             length <- base::length
  [21:25:26.556]             list <- base::list
  [21:25:26.556]             seq.int <- base::seq.int
  [21:25:26.556]             signalCondition <- base::signalCondition
  [21:25:26.556]             sys.calls <- base::sys.calls
  [21:25:26.556]             Sys.time <- base::Sys.time
  [21:25:26.556]             `[[` <- base::`[[`
  [21:25:26.556]             `+` <- base::`+`
  [21:25:26.556]             `<<-` <- base::`<<-`
  [21:25:26.556]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.556]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.556]                   3L)]
  [21:25:26.556]             }
  [21:25:26.556]             function(cond) {
  [21:25:26.556]                 if (inherits(cond, "error")) {
  [21:25:26.556]                   sessionInformation <- function() {
  [21:25:26.556]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.556]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.556]                       search = base::search(), system = base::Sys.info())
  [21:25:26.556]                   }
  [21:25:26.556]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.556]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.556]                     cond$call), session = sessionInformation(), 
  [21:25:26.556]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.556]                   signalCondition(cond)
  [21:25:26.556]                 }
  [21:25:26.556]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.556]                 ))) {
  [21:25:26.556]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.556]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.556]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.556]                   if (!signal) {
  [21:25:26.556]                     muffleCondition <- function (cond) 
  [21:25:26.556]                     {
  [21:25:26.556]                       inherits <- base::inherits
  [21:25:26.556]                       invokeRestart <- base::invokeRestart
  [21:25:26.556]                       muffled <- FALSE
  [21:25:26.556]                       if (inherits(cond, "message")) {
  [21:25:26.556]                         invokeRestart("muffleMessage")
  [21:25:26.556]                         muffled <- TRUE
  [21:25:26.556]                       }
  [21:25:26.556]                       else if (inherits(cond, "warning")) {
  [21:25:26.556]                         invokeRestart("muffleWarning")
  [21:25:26.556]                         muffled <- TRUE
  [21:25:26.556]                       }
  [21:25:26.556]                       else if (inherits(cond, "condition")) {
  [21:25:26.556]                         computeRestarts <- base::computeRestarts
  [21:25:26.556]                         grepl <- base::grepl
  [21:25:26.556]                         is.null <- base::is.null
  [21:25:26.556]                         restarts <- computeRestarts(cond)
  [21:25:26.556]                         for (restart in restarts) {
  [21:25:26.556]                           name <- restart$name
  [21:25:26.556]                           if (is.null(name)) 
  [21:25:26.556]                             next
  [21:25:26.556]                           if (!grepl("^muffle", name)) 
  [21:25:26.556]                             next
  [21:25:26.556]                           invokeRestart(restart)
  [21:25:26.556]                           muffled <- TRUE
  [21:25:26.556]                           break
  [21:25:26.556]                         }
  [21:25:26.556]                       }
  [21:25:26.556]                       invisible(muffled)
  [21:25:26.556]                     }
  [21:25:26.556]                     muffleCondition(cond)
  [21:25:26.556]                   }
  [21:25:26.556]                 }
  [21:25:26.556]             }
  [21:25:26.556]         }))
  [21:25:26.556]     }, error = function(ex) {
  [21:25:26.556]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.556]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.556]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.556]     }, finally = {
  [21:25:26.556]         {
  [21:25:26.556]             NULL
  [21:25:26.556]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.556]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.556]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.556]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.556]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.556]                 ...) 
  [21:25:26.556]             {
  [21:25:26.556]                 if (substitute) 
  [21:25:26.556]                   expr <- substitute(expr)
  [21:25:26.556]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.556]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.556]                   globals = globals, persistent = persistent, 
  [21:25:26.556]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.556]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.556]                   label = label, ...)
  [21:25:26.556]                 if (!future$lazy) 
  [21:25:26.556]                   future <- run(future)
  [21:25:26.556]                 invisible(future)
  [21:25:26.556]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.556]         }
  [21:25:26.556]         base::options(...future.oldOptions)
  [21:25:26.556]     })
  [21:25:26.556]     Sys.time
  [21:25:26.556]     if (base::is.na(TRUE)) {
  [21:25:26.556]     }
  [21:25:26.556]     else {
  [21:25:26.556]         base::sink(type = "output", split = FALSE)
  [21:25:26.556]         if (TRUE) {
  [21:25:26.556]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.556]         }
  [21:25:26.556]         else {
  [21:25:26.556]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.556]         }
  [21:25:26.556]         base::close(...future.stdout)
  [21:25:26.556]         ...future.stdout <- NULL
  [21:25:26.556]     }
  [21:25:26.556]     ...future.result$conditions <- ...future.conditions
  [21:25:26.556]     ...future.result
  [21:25:26.556] }
  [21:25:26.571] ClusterFuture started
  [21:25:26.571] getGlobalsAndPackages() ...
  [21:25:26.572] Searching for globals...
  [21:25:26.572] 
  [21:25:26.573] Searching for globals ... DONE
  [21:25:26.573] - globals: [0] <none>
  [21:25:26.573] getGlobalsAndPackages() ... DONE
  [21:25:26.582] Packages needed by the future expression (n = 0): <none>
  [21:25:26.583] Packages needed by future strategies (n = 0): <none>
  [21:25:26.587] {
  [21:25:26.587]     {
  [21:25:26.587]         ...future.startTime <- base::Sys.time()
  [21:25:26.587]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.587]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.587]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.587]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.587]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.587]         {
  [21:25:26.587]             {
  [21:25:26.587]                 base::local({
  [21:25:26.587]                   has_future <- base::requireNamespace("future", 
  [21:25:26.587]                     quietly = TRUE)
  [21:25:26.587]                   version <- if (has_future) 
  [21:25:26.587]                     utils::packageVersion("future")
  [21:25:26.587]                   else NULL
  [21:25:26.587]                   if (!has_future || version < "1.8.0") {
  [21:25:26.587]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.587]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.587]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.587]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.587]                         "release", "version")], collapse = " "), 
  [21:25:26.587]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.587]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.587]                       info)
  [21:25:26.587]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.587]                     if (!has_future) {
  [21:25:26.587]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.587]                         info)
  [21:25:26.587]                     }
  [21:25:26.587]                     else {
  [21:25:26.587]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.587]                         info, version)
  [21:25:26.587]                     }
  [21:25:26.587]                     base::stop(msg)
  [21:25:26.587]                   }
  [21:25:26.587]                 })
  [21:25:26.587]             }
  [21:25:26.587]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.587]         }
  [21:25:26.587]     }
  [21:25:26.587]     if (base::is.na(TRUE)) {
  [21:25:26.587]     }
  [21:25:26.587]     else {
  [21:25:26.587]         if (TRUE) {
  [21:25:26.587]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.587]                 open = "w")
  [21:25:26.587]         }
  [21:25:26.587]         else {
  [21:25:26.587]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.587]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.587]         }
  [21:25:26.587]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.587]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.587]             base::sink(type = "output", split = FALSE)
  [21:25:26.587]             base::close(...future.stdout)
  [21:25:26.587]         }, add = TRUE)
  [21:25:26.587]     }
  [21:25:26.587]     ...future.frame <- base::sys.nframe()
  [21:25:26.587]     ...future.conditions <- base::list()
  [21:25:26.587]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.587]     ...future.result <- base::tryCatch({
  [21:25:26.587]         base::withCallingHandlers({
  [21:25:26.587]             ...future.value <- base::withVisible(base::local({
  [21:25:26.587]                 ...future.sendCondition <- local({
  [21:25:26.587]                   sendCondition <- NULL
  [21:25:26.587]                   function(frame = 1L) {
  [21:25:26.587]                     if (is.function(sendCondition)) 
  [21:25:26.587]                       return(sendCondition)
  [21:25:26.587]                     ns <- getNamespace("parallel")
  [21:25:26.587]                     if (exists("sendData", mode = "function", 
  [21:25:26.587]                       envir = ns)) {
  [21:25:26.587]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.587]                         envir = ns)
  [21:25:26.587]                       envir <- sys.frame(frame)
  [21:25:26.587]                       master <- NULL
  [21:25:26.587]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.587]                         !identical(envir, emptyenv())) {
  [21:25:26.587]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.587]                           inherits = FALSE)) {
  [21:25:26.587]                           master <- get("master", mode = "list", 
  [21:25:26.587]                             envir = envir, inherits = FALSE)
  [21:25:26.587]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.587]                             sendCondition <<- function(cond) {
  [21:25:26.587]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.587]                                 success = TRUE)
  [21:25:26.587]                               parallel_sendData(master, data)
  [21:25:26.587]                             }
  [21:25:26.587]                             return(sendCondition)
  [21:25:26.587]                           }
  [21:25:26.587]                         }
  [21:25:26.587]                         frame <- frame + 1L
  [21:25:26.587]                         envir <- sys.frame(frame)
  [21:25:26.587]                       }
  [21:25:26.587]                     }
  [21:25:26.587]                     sendCondition <<- function(cond) NULL
  [21:25:26.587]                   }
  [21:25:26.587]                 })
  [21:25:26.587]                 withCallingHandlers({
  [21:25:26.587]                   NULL
  [21:25:26.587]                 }, immediateCondition = function(cond) {
  [21:25:26.587]                   sendCondition <- ...future.sendCondition()
  [21:25:26.587]                   sendCondition(cond)
  [21:25:26.587]                   muffleCondition <- function (cond) 
  [21:25:26.587]                   {
  [21:25:26.587]                     inherits <- base::inherits
  [21:25:26.587]                     invokeRestart <- base::invokeRestart
  [21:25:26.587]                     muffled <- FALSE
  [21:25:26.587]                     if (inherits(cond, "message")) {
  [21:25:26.587]                       invokeRestart("muffleMessage")
  [21:25:26.587]                       muffled <- TRUE
  [21:25:26.587]                     }
  [21:25:26.587]                     else if (inherits(cond, "warning")) {
  [21:25:26.587]                       invokeRestart("muffleWarning")
  [21:25:26.587]                       muffled <- TRUE
  [21:25:26.587]                     }
  [21:25:26.587]                     else if (inherits(cond, "condition")) {
  [21:25:26.587]                       computeRestarts <- base::computeRestarts
  [21:25:26.587]                       grepl <- base::grepl
  [21:25:26.587]                       is.null <- base::is.null
  [21:25:26.587]                       restarts <- computeRestarts(cond)
  [21:25:26.587]                       for (restart in restarts) {
  [21:25:26.587]                         name <- restart$name
  [21:25:26.587]                         if (is.null(name)) 
  [21:25:26.587]                           next
  [21:25:26.587]                         if (!grepl("^muffle", name)) 
  [21:25:26.587]                           next
  [21:25:26.587]                         invokeRestart(restart)
  [21:25:26.587]                         muffled <- TRUE
  [21:25:26.587]                         break
  [21:25:26.587]                       }
  [21:25:26.587]                     }
  [21:25:26.587]                     invisible(muffled)
  [21:25:26.587]                   }
  [21:25:26.587]                   muffleCondition(cond)
  [21:25:26.587]                 })
  [21:25:26.587]             }))
  [21:25:26.587]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.587]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.587]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.587]                 version = "1.8")
  [21:25:26.587]         }, condition = base::local({
  [21:25:26.587]             c <- base::c
  [21:25:26.587]             inherits <- base::inherits
  [21:25:26.587]             invokeRestart <- base::invokeRestart
  [21:25:26.587]             length <- base::length
  [21:25:26.587]             list <- base::list
  [21:25:26.587]             seq.int <- base::seq.int
  [21:25:26.587]             signalCondition <- base::signalCondition
  [21:25:26.587]             sys.calls <- base::sys.calls
  [21:25:26.587]             Sys.time <- base::Sys.time
  [21:25:26.587]             `[[` <- base::`[[`
  [21:25:26.587]             `+` <- base::`+`
  [21:25:26.587]             `<<-` <- base::`<<-`
  [21:25:26.587]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.587]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.587]                   3L)]
  [21:25:26.587]             }
  [21:25:26.587]             function(cond) {
  [21:25:26.587]                 if (inherits(cond, "error")) {
  [21:25:26.587]                   sessionInformation <- function() {
  [21:25:26.587]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.587]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.587]                       search = base::search(), system = base::Sys.info())
  [21:25:26.587]                   }
  [21:25:26.587]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.587]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.587]                     cond$call), session = sessionInformation(), 
  [21:25:26.587]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.587]                   signalCondition(cond)
  [21:25:26.587]                 }
  [21:25:26.587]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.587]                 ))) {
  [21:25:26.587]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.587]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.587]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.587]                   if (!signal) {
  [21:25:26.587]                     muffleCondition <- function (cond) 
  [21:25:26.587]                     {
  [21:25:26.587]                       inherits <- base::inherits
  [21:25:26.587]                       invokeRestart <- base::invokeRestart
  [21:25:26.587]                       muffled <- FALSE
  [21:25:26.587]                       if (inherits(cond, "message")) {
  [21:25:26.587]                         invokeRestart("muffleMessage")
  [21:25:26.587]                         muffled <- TRUE
  [21:25:26.587]                       }
  [21:25:26.587]                       else if (inherits(cond, "warning")) {
  [21:25:26.587]                         invokeRestart("muffleWarning")
  [21:25:26.587]                         muffled <- TRUE
  [21:25:26.587]                       }
  [21:25:26.587]                       else if (inherits(cond, "condition")) {
  [21:25:26.587]                         computeRestarts <- base::computeRestarts
  [21:25:26.587]                         grepl <- base::grepl
  [21:25:26.587]                         is.null <- base::is.null
  [21:25:26.587]                         restarts <- computeRestarts(cond)
  [21:25:26.587]                         for (restart in restarts) {
  [21:25:26.587]                           name <- restart$name
  [21:25:26.587]                           if (is.null(name)) 
  [21:25:26.587]                             next
  [21:25:26.587]                           if (!grepl("^muffle", name)) 
  [21:25:26.587]                             next
  [21:25:26.587]                           invokeRestart(restart)
  [21:25:26.587]                           muffled <- TRUE
  [21:25:26.587]                           break
  [21:25:26.587]                         }
  [21:25:26.587]                       }
  [21:25:26.587]                       invisible(muffled)
  [21:25:26.587]                     }
  [21:25:26.587]                     muffleCondition(cond)
  [21:25:26.587]                   }
  [21:25:26.587]                 }
  [21:25:26.587]             }
  [21:25:26.587]         }))
  [21:25:26.587]     }, error = function(ex) {
  [21:25:26.587]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.587]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.587]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.587]     }, finally = {
  [21:25:26.587]         {
  [21:25:26.587]             NULL
  [21:25:26.587]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.587]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.587]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.587]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.587]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.587]                 ...) 
  [21:25:26.587]             {
  [21:25:26.587]                 if (substitute) 
  [21:25:26.587]                   expr <- substitute(expr)
  [21:25:26.587]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.587]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.587]                   globals = globals, persistent = persistent, 
  [21:25:26.587]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.587]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.587]                   label = label, ...)
  [21:25:26.587]                 if (!future$lazy) 
  [21:25:26.587]                   future <- run(future)
  [21:25:26.587]                 invisible(future)
  [21:25:26.587]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.587]         }
  [21:25:26.587]         base::options(...future.oldOptions)
  [21:25:26.587]     })
  [21:25:26.587]     Sys.time
  [21:25:26.587]     if (base::is.na(TRUE)) {
  [21:25:26.587]     }
  [21:25:26.587]     else {
  [21:25:26.587]         base::sink(type = "output", split = FALSE)
  [21:25:26.587]         if (TRUE) {
  [21:25:26.587]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.587]         }
  [21:25:26.587]         else {
  [21:25:26.587]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.587]         }
  [21:25:26.587]         base::close(...future.stdout)
  [21:25:26.587]         ...future.stdout <- NULL
  [21:25:26.587]     }
  [21:25:26.587]     ...future.result$conditions <- ...future.conditions
  [21:25:26.587]     ...future.result
  [21:25:26.587] }
  [21:25:26.592] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:26.638] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.639] - Validating connection of ClusterFuture
  [21:25:26.639] - received message: FutureResult
  [21:25:26.639] - Received FutureResult
  [21:25:26.640] - Erased future from FutureRegistry
  [21:25:26.640] result() for ClusterFuture ...
  [21:25:26.640] - result already collected: FutureResult
  [21:25:26.641] result() for ClusterFuture ... done
  [21:25:26.641] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:26.641] result() for ClusterFuture ...
  [21:25:26.642] - result already collected: FutureResult
  [21:25:26.654] result() for ClusterFuture ... done
  [21:25:26.654] result() for ClusterFuture ...
  [21:25:26.655] - result already collected: FutureResult
  [21:25:26.655] result() for ClusterFuture ... done
  [21:25:26.671] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22cff580> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef21a93020> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22cff580> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef21a93020> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 1 6
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
  [21:25:26.718] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.718] - Validating connection of ClusterFuture
  [21:25:26.719] - received message: FutureResult
  [21:25:26.719] - Received FutureResult
  [21:25:26.719] - Erased future from FutureRegistry
  [21:25:26.720] result() for ClusterFuture ...
  [21:25:26.720] - result already collected: FutureResult
  [21:25:26.720] result() for ClusterFuture ... done
  [21:25:26.720] receiveMessageFromWorker() for ClusterFuture ... done
   logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:26.725] resolve() on list ...
  [21:25:26.725]  recursive: 0
  [21:25:26.726]  length: 6
  [21:25:26.726]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:26.726] signalConditionsASAP(numeric, pos=1) ...
  [21:25:26.726] - nx: 6
  [21:25:26.727] - relay: TRUE
  [21:25:26.727] - stdout: TRUE
  [21:25:26.727] - signal: TRUE
  [21:25:26.727] - resignal: FALSE
  [21:25:26.728] - force: TRUE
  [21:25:26.728] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.728] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.729]  - until=2
  [21:25:26.729]  - relaying element #2
  [21:25:26.729] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.729] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.731] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:26.731]  length: 5 (resolved future 1)
  [21:25:26.732] Future #2
  [21:25:26.732] result() for ClusterFuture ...
  [21:25:26.732] - result already collected: FutureResult
  [21:25:26.733] result() for ClusterFuture ... done
  [21:25:26.733] result() for ClusterFuture ...
  [21:25:26.733] - result already collected: FutureResult
  [21:25:26.733] result() for ClusterFuture ... done
  [21:25:26.734] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:26.734] - nx: 6
  [21:25:26.734] - relay: TRUE
  [21:25:26.735] - stdout: TRUE
  [21:25:26.735] - signal: TRUE
  [21:25:26.735] - resignal: FALSE
  [21:25:26.735] - force: TRUE
  [21:25:26.736] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.736] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.736]  - until=2
  [21:25:26.736]  - relaying element #2
  [21:25:26.737] result() for ClusterFuture ...
  [21:25:26.737] - result already collected: FutureResult
  [21:25:26.737] result() for ClusterFuture ... done
  [21:25:26.738] result() for ClusterFuture ...
  [21:25:26.742] - result already collected: FutureResult
  [21:25:26.742] result() for ClusterFuture ... done
  [21:25:26.742] result() for ClusterFuture ...
  [21:25:26.743] - result already collected: FutureResult
  [21:25:26.743] result() for ClusterFuture ... done
  [21:25:26.743] result() for ClusterFuture ...
  [21:25:26.744] - result already collected: FutureResult
  [21:25:26.744] result() for ClusterFuture ... done
  [21:25:26.744] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.744] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.745] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:26.745]  length: 4 (resolved future 2)
  [21:25:26.745] Future #3
  [21:25:26.746] result() for ClusterFuture ...
  [21:25:26.746] - result already collected: FutureResult
  [21:25:26.746] result() for ClusterFuture ... done
  [21:25:26.746] result() for ClusterFuture ...
  [21:25:26.747] - result already collected: FutureResult
  [21:25:26.747] result() for ClusterFuture ... done
  [21:25:26.747] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:26.748] - nx: 6
  [21:25:26.748] - relay: TRUE
  [21:25:26.748] - stdout: TRUE
  [21:25:26.748] - signal: TRUE
  [21:25:26.748] - resignal: FALSE
  [21:25:26.749] - force: TRUE
  [21:25:26.749] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.749] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.750]  - until=3
  [21:25:26.750]  - relaying element #3
  [21:25:26.750] result() for ClusterFuture ...
  [21:25:26.750] - result already collected: FutureResult
  [21:25:26.751] result() for ClusterFuture ... done
  [21:25:26.751] result() for ClusterFuture ...
  [21:25:26.751] - result already collected: FutureResult
  [21:25:26.751] result() for ClusterFuture ... done
  [21:25:26.752] result() for ClusterFuture ...
  [21:25:26.752] - result already collected: FutureResult
  [21:25:26.752] result() for ClusterFuture ... done
  [21:25:26.753] result() for ClusterFuture ...
  [21:25:26.753] - result already collected: FutureResult
  [21:25:26.753] result() for ClusterFuture ... done
  [21:25:26.754] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.754] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.755] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:26.755]  length: 3 (resolved future 3)
  [21:25:26.755] signalConditionsASAP(NULL, pos=4) ...
  [21:25:26.755] - nx: 6
  [21:25:26.756] - relay: TRUE
  [21:25:26.756] - stdout: TRUE
  [21:25:26.756] - signal: TRUE
  [21:25:26.756] - resignal: FALSE
  [21:25:26.757] - force: TRUE
  [21:25:26.757] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.757] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.758]  - until=5
  [21:25:26.758]  - relaying element #5
  [21:25:26.758] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.758] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.759] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:26.759]  length: 2 (resolved future 4)
  [21:25:26.759] signalConditionsASAP(NULL, pos=5) ...
  [21:25:26.760] - nx: 6
  [21:25:26.760] - relay: TRUE
  [21:25:26.760] - stdout: TRUE
  [21:25:26.760] - signal: TRUE
  [21:25:26.760] - resignal: FALSE
  [21:25:26.761] - force: TRUE
  [21:25:26.761] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.761] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.762]  - until=6
  [21:25:26.762]  - relaying element #6
  [21:25:26.762] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.763] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.763] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:26.763]  length: 1 (resolved future 5)
  [21:25:26.763] signalConditionsASAP(numeric, pos=6) ...
  [21:25:26.764] - nx: 6
  [21:25:26.764] - relay: TRUE
  [21:25:26.764] - stdout: TRUE
  [21:25:26.764] - signal: TRUE
  [21:25:26.765] - resignal: FALSE
  [21:25:26.765] - force: TRUE
  [21:25:26.765] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.765] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.766]  - until=6
  [21:25:26.766] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.766] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.767] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:26.767]  length: 0 (resolved future 6)
  [21:25:26.767] Relaying remaining futures
  [21:25:26.767] signalConditionsASAP(NULL, pos=0) ...
  [21:25:26.768] - nx: 6
  [21:25:26.768] - relay: TRUE
  [21:25:26.768] - stdout: TRUE
  [21:25:26.768] - signal: TRUE
  [21:25:26.769] - resignal: FALSE
  [21:25:26.769] - force: TRUE
  [21:25:26.769] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.769] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:26.770] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.770] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.771] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:26.771] resolve() on list ... DONE
  [21:25:26.771] result() for ClusterFuture ...
  [21:25:26.771] - result already collected: FutureResult
  [21:25:26.772] result() for ClusterFuture ... done
  [21:25:26.772] result() for ClusterFuture ...
  [21:25:26.772] - result already collected: FutureResult
  [21:25:26.772] result() for ClusterFuture ... done
  [21:25:26.773] result() for ClusterFuture ...
  [21:25:26.773] - result already collected: FutureResult
  [21:25:26.773] result() for ClusterFuture ... done
  [21:25:26.774] result() for ClusterFuture ...
  [21:25:26.774] - result already collected: FutureResult
  [21:25:26.774] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 1 6
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
  Dimensions: c(2, 3)
  [21:25:26.800] getGlobalsAndPackages() ...
  [21:25:26.801] Searching for globals...
  [21:25:26.801] 
  [21:25:26.802] Searching for globals ... DONE
  [21:25:26.802] - globals: [0] <none>
  [21:25:26.802] getGlobalsAndPackages() ... DONE
  [21:25:26.806] Packages needed by the future expression (n = 0): <none>
  [21:25:26.807] Packages needed by future strategies (n = 0): <none>
  [21:25:26.822] {
  [21:25:26.822]     {
  [21:25:26.822]         ...future.startTime <- base::Sys.time()
  [21:25:26.822]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.822]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.822]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.822]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.822]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.822]         {
  [21:25:26.822]             {
  [21:25:26.822]                 base::local({
  [21:25:26.822]                   has_future <- base::requireNamespace("future", 
  [21:25:26.822]                     quietly = TRUE)
  [21:25:26.822]                   version <- if (has_future) 
  [21:25:26.822]                     utils::packageVersion("future")
  [21:25:26.822]                   else NULL
  [21:25:26.822]                   if (!has_future || version < "1.8.0") {
  [21:25:26.822]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.822]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.822]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.822]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.822]                         "release", "version")], collapse = " "), 
  [21:25:26.822]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.822]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.822]                       info)
  [21:25:26.822]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.822]                     if (!has_future) {
  [21:25:26.822]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.822]                         info)
  [21:25:26.822]                     }
  [21:25:26.822]                     else {
  [21:25:26.822]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.822]                         info, version)
  [21:25:26.822]                     }
  [21:25:26.822]                     base::stop(msg)
  [21:25:26.822]                   }
  [21:25:26.822]                 })
  [21:25:26.822]             }
  [21:25:26.822]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.822]         }
  [21:25:26.822]     }
  [21:25:26.822]     if (base::is.na(TRUE)) {
  [21:25:26.822]     }
  [21:25:26.822]     else {
  [21:25:26.822]         if (TRUE) {
  [21:25:26.822]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.822]                 open = "w")
  [21:25:26.822]         }
  [21:25:26.822]         else {
  [21:25:26.822]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.822]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.822]         }
  [21:25:26.822]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.822]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.822]             base::sink(type = "output", split = FALSE)
  [21:25:26.822]             base::close(...future.stdout)
  [21:25:26.822]         }, add = TRUE)
  [21:25:26.822]     }
  [21:25:26.822]     ...future.frame <- base::sys.nframe()
  [21:25:26.822]     ...future.conditions <- base::list()
  [21:25:26.822]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.822]     ...future.result <- base::tryCatch({
  [21:25:26.822]         base::withCallingHandlers({
  [21:25:26.822]             ...future.value <- base::withVisible(base::local({
  [21:25:26.822]                 ...future.sendCondition <- local({
  [21:25:26.822]                   sendCondition <- NULL
  [21:25:26.822]                   function(frame = 1L) {
  [21:25:26.822]                     if (is.function(sendCondition)) 
  [21:25:26.822]                       return(sendCondition)
  [21:25:26.822]                     ns <- getNamespace("parallel")
  [21:25:26.822]                     if (exists("sendData", mode = "function", 
  [21:25:26.822]                       envir = ns)) {
  [21:25:26.822]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.822]                         envir = ns)
  [21:25:26.822]                       envir <- sys.frame(frame)
  [21:25:26.822]                       master <- NULL
  [21:25:26.822]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.822]                         !identical(envir, emptyenv())) {
  [21:25:26.822]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.822]                           inherits = FALSE)) {
  [21:25:26.822]                           master <- get("master", mode = "list", 
  [21:25:26.822]                             envir = envir, inherits = FALSE)
  [21:25:26.822]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.822]                             sendCondition <<- function(cond) {
  [21:25:26.822]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.822]                                 success = TRUE)
  [21:25:26.822]                               parallel_sendData(master, data)
  [21:25:26.822]                             }
  [21:25:26.822]                             return(sendCondition)
  [21:25:26.822]                           }
  [21:25:26.822]                         }
  [21:25:26.822]                         frame <- frame + 1L
  [21:25:26.822]                         envir <- sys.frame(frame)
  [21:25:26.822]                       }
  [21:25:26.822]                     }
  [21:25:26.822]                     sendCondition <<- function(cond) NULL
  [21:25:26.822]                   }
  [21:25:26.822]                 })
  [21:25:26.822]                 withCallingHandlers({
  [21:25:26.822]                   2
  [21:25:26.822]                 }, immediateCondition = function(cond) {
  [21:25:26.822]                   sendCondition <- ...future.sendCondition()
  [21:25:26.822]                   sendCondition(cond)
  [21:25:26.822]                   muffleCondition <- function (cond) 
  [21:25:26.822]                   {
  [21:25:26.822]                     inherits <- base::inherits
  [21:25:26.822]                     invokeRestart <- base::invokeRestart
  [21:25:26.822]                     muffled <- FALSE
  [21:25:26.822]                     if (inherits(cond, "message")) {
  [21:25:26.822]                       invokeRestart("muffleMessage")
  [21:25:26.822]                       muffled <- TRUE
  [21:25:26.822]                     }
  [21:25:26.822]                     else if (inherits(cond, "warning")) {
  [21:25:26.822]                       invokeRestart("muffleWarning")
  [21:25:26.822]                       muffled <- TRUE
  [21:25:26.822]                     }
  [21:25:26.822]                     else if (inherits(cond, "condition")) {
  [21:25:26.822]                       computeRestarts <- base::computeRestarts
  [21:25:26.822]                       grepl <- base::grepl
  [21:25:26.822]                       is.null <- base::is.null
  [21:25:26.822]                       restarts <- computeRestarts(cond)
  [21:25:26.822]                       for (restart in restarts) {
  [21:25:26.822]                         name <- restart$name
  [21:25:26.822]                         if (is.null(name)) 
  [21:25:26.822]                           next
  [21:25:26.822]                         if (!grepl("^muffle", name)) 
  [21:25:26.822]                           next
  [21:25:26.822]                         invokeRestart(restart)
  [21:25:26.822]                         muffled <- TRUE
  [21:25:26.822]                         break
  [21:25:26.822]                       }
  [21:25:26.822]                     }
  [21:25:26.822]                     invisible(muffled)
  [21:25:26.822]                   }
  [21:25:26.822]                   muffleCondition(cond)
  [21:25:26.822]                 })
  [21:25:26.822]             }))
  [21:25:26.822]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.822]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.822]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.822]                 version = "1.8")
  [21:25:26.822]         }, condition = base::local({
  [21:25:26.822]             c <- base::c
  [21:25:26.822]             inherits <- base::inherits
  [21:25:26.822]             invokeRestart <- base::invokeRestart
  [21:25:26.822]             length <- base::length
  [21:25:26.822]             list <- base::list
  [21:25:26.822]             seq.int <- base::seq.int
  [21:25:26.822]             signalCondition <- base::signalCondition
  [21:25:26.822]             sys.calls <- base::sys.calls
  [21:25:26.822]             Sys.time <- base::Sys.time
  [21:25:26.822]             `[[` <- base::`[[`
  [21:25:26.822]             `+` <- base::`+`
  [21:25:26.822]             `<<-` <- base::`<<-`
  [21:25:26.822]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.822]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.822]                   3L)]
  [21:25:26.822]             }
  [21:25:26.822]             function(cond) {
  [21:25:26.822]                 if (inherits(cond, "error")) {
  [21:25:26.822]                   sessionInformation <- function() {
  [21:25:26.822]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.822]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.822]                       search = base::search(), system = base::Sys.info())
  [21:25:26.822]                   }
  [21:25:26.822]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.822]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.822]                     cond$call), session = sessionInformation(), 
  [21:25:26.822]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.822]                   signalCondition(cond)
  [21:25:26.822]                 }
  [21:25:26.822]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.822]                 ))) {
  [21:25:26.822]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.822]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.822]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.822]                   if (!signal) {
  [21:25:26.822]                     muffleCondition <- function (cond) 
  [21:25:26.822]                     {
  [21:25:26.822]                       inherits <- base::inherits
  [21:25:26.822]                       invokeRestart <- base::invokeRestart
  [21:25:26.822]                       muffled <- FALSE
  [21:25:26.822]                       if (inherits(cond, "message")) {
  [21:25:26.822]                         invokeRestart("muffleMessage")
  [21:25:26.822]                         muffled <- TRUE
  [21:25:26.822]                       }
  [21:25:26.822]                       else if (inherits(cond, "warning")) {
  [21:25:26.822]                         invokeRestart("muffleWarning")
  [21:25:26.822]                         muffled <- TRUE
  [21:25:26.822]                       }
  [21:25:26.822]                       else if (inherits(cond, "condition")) {
  [21:25:26.822]                         computeRestarts <- base::computeRestarts
  [21:25:26.822]                         grepl <- base::grepl
  [21:25:26.822]                         is.null <- base::is.null
  [21:25:26.822]                         restarts <- computeRestarts(cond)
  [21:25:26.822]                         for (restart in restarts) {
  [21:25:26.822]                           name <- restart$name
  [21:25:26.822]                           if (is.null(name)) 
  [21:25:26.822]                             next
  [21:25:26.822]                           if (!grepl("^muffle", name)) 
  [21:25:26.822]                             next
  [21:25:26.822]                           invokeRestart(restart)
  [21:25:26.822]                           muffled <- TRUE
  [21:25:26.822]                           break
  [21:25:26.822]                         }
  [21:25:26.822]                       }
  [21:25:26.822]                       invisible(muffled)
  [21:25:26.822]                     }
  [21:25:26.822]                     muffleCondition(cond)
  [21:25:26.822]                   }
  [21:25:26.822]                 }
  [21:25:26.822]             }
  [21:25:26.822]         }))
  [21:25:26.822]     }, error = function(ex) {
  [21:25:26.822]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.822]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.822]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.822]     }, finally = {
  [21:25:26.822]         {
  [21:25:26.822]             NULL
  [21:25:26.822]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.822]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.822]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.822]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.822]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.822]                 ...) 
  [21:25:26.822]             {
  [21:25:26.822]                 if (substitute) 
  [21:25:26.822]                   expr <- substitute(expr)
  [21:25:26.822]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.822]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.822]                   globals = globals, persistent = persistent, 
  [21:25:26.822]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.822]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.822]                   label = label, ...)
  [21:25:26.822]                 if (!future$lazy) 
  [21:25:26.822]                   future <- run(future)
  [21:25:26.822]                 invisible(future)
  [21:25:26.822]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.822]         }
  [21:25:26.822]         base::options(...future.oldOptions)
  [21:25:26.822]     })
  [21:25:26.822]     Sys.time
  [21:25:26.822]     if (base::is.na(TRUE)) {
  [21:25:26.822]     }
  [21:25:26.822]     else {
  [21:25:26.822]         base::sink(type = "output", split = FALSE)
  [21:25:26.822]         if (TRUE) {
  [21:25:26.822]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.822]         }
  [21:25:26.822]         else {
  [21:25:26.822]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.822]         }
  [21:25:26.822]         base::close(...future.stdout)
  [21:25:26.822]         ...future.stdout <- NULL
  [21:25:26.822]     }
  [21:25:26.822]     ...future.result$conditions <- ...future.conditions
  [21:25:26.822]     ...future.result
  [21:25:26.822] }
  [21:25:26.830] ClusterFuture started
  [21:25:26.831] getGlobalsAndPackages() ...
  [21:25:26.831] Searching for globals...
  [21:25:26.832] 
  [21:25:26.832] Searching for globals ... DONE
  [21:25:26.832] - globals: [0] <none>
  [21:25:26.832] getGlobalsAndPackages() ... DONE
  [21:25:26.837] Packages needed by the future expression (n = 0): <none>
  [21:25:26.837] Packages needed by future strategies (n = 0): <none>
  [21:25:26.851] {
  [21:25:26.851]     {
  [21:25:26.851]         ...future.startTime <- base::Sys.time()
  [21:25:26.851]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:26.851]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:26.851]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:26.851]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:26.851]             future.resolve.recursive = NULL, width = 80L)
  [21:25:26.851]         {
  [21:25:26.851]             {
  [21:25:26.851]                 base::local({
  [21:25:26.851]                   has_future <- base::requireNamespace("future", 
  [21:25:26.851]                     quietly = TRUE)
  [21:25:26.851]                   version <- if (has_future) 
  [21:25:26.851]                     utils::packageVersion("future")
  [21:25:26.851]                   else NULL
  [21:25:26.851]                   if (!has_future || version < "1.8.0") {
  [21:25:26.851]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:26.851]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:26.851]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:26.851]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:26.851]                         "release", "version")], collapse = " "), 
  [21:25:26.851]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:26.851]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:26.851]                       info)
  [21:25:26.851]                     info <- base::paste(info, collapse = "; ")
  [21:25:26.851]                     if (!has_future) {
  [21:25:26.851]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:26.851]                         info)
  [21:25:26.851]                     }
  [21:25:26.851]                     else {
  [21:25:26.851]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:26.851]                         info, version)
  [21:25:26.851]                     }
  [21:25:26.851]                     base::stop(msg)
  [21:25:26.851]                   }
  [21:25:26.851]                 })
  [21:25:26.851]             }
  [21:25:26.851]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:26.851]         }
  [21:25:26.851]     }
  [21:25:26.851]     if (base::is.na(TRUE)) {
  [21:25:26.851]     }
  [21:25:26.851]     else {
  [21:25:26.851]         if (TRUE) {
  [21:25:26.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:26.851]                 open = "w")
  [21:25:26.851]         }
  [21:25:26.851]         else {
  [21:25:26.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:26.851]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:26.851]         }
  [21:25:26.851]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:26.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:26.851]             base::sink(type = "output", split = FALSE)
  [21:25:26.851]             base::close(...future.stdout)
  [21:25:26.851]         }, add = TRUE)
  [21:25:26.851]     }
  [21:25:26.851]     ...future.frame <- base::sys.nframe()
  [21:25:26.851]     ...future.conditions <- base::list()
  [21:25:26.851]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:26.851]     ...future.result <- base::tryCatch({
  [21:25:26.851]         base::withCallingHandlers({
  [21:25:26.851]             ...future.value <- base::withVisible(base::local({
  [21:25:26.851]                 ...future.sendCondition <- local({
  [21:25:26.851]                   sendCondition <- NULL
  [21:25:26.851]                   function(frame = 1L) {
  [21:25:26.851]                     if (is.function(sendCondition)) 
  [21:25:26.851]                       return(sendCondition)
  [21:25:26.851]                     ns <- getNamespace("parallel")
  [21:25:26.851]                     if (exists("sendData", mode = "function", 
  [21:25:26.851]                       envir = ns)) {
  [21:25:26.851]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:26.851]                         envir = ns)
  [21:25:26.851]                       envir <- sys.frame(frame)
  [21:25:26.851]                       master <- NULL
  [21:25:26.851]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:26.851]                         !identical(envir, emptyenv())) {
  [21:25:26.851]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:26.851]                           inherits = FALSE)) {
  [21:25:26.851]                           master <- get("master", mode = "list", 
  [21:25:26.851]                             envir = envir, inherits = FALSE)
  [21:25:26.851]                           if (inherits(master, "SOCKnode")) {
  [21:25:26.851]                             sendCondition <<- function(cond) {
  [21:25:26.851]                               data <- list(type = "VALUE", value = cond, 
  [21:25:26.851]                                 success = TRUE)
  [21:25:26.851]                               parallel_sendData(master, data)
  [21:25:26.851]                             }
  [21:25:26.851]                             return(sendCondition)
  [21:25:26.851]                           }
  [21:25:26.851]                         }
  [21:25:26.851]                         frame <- frame + 1L
  [21:25:26.851]                         envir <- sys.frame(frame)
  [21:25:26.851]                       }
  [21:25:26.851]                     }
  [21:25:26.851]                     sendCondition <<- function(cond) NULL
  [21:25:26.851]                   }
  [21:25:26.851]                 })
  [21:25:26.851]                 withCallingHandlers({
  [21:25:26.851]                   NULL
  [21:25:26.851]                 }, immediateCondition = function(cond) {
  [21:25:26.851]                   sendCondition <- ...future.sendCondition()
  [21:25:26.851]                   sendCondition(cond)
  [21:25:26.851]                   muffleCondition <- function (cond) 
  [21:25:26.851]                   {
  [21:25:26.851]                     inherits <- base::inherits
  [21:25:26.851]                     invokeRestart <- base::invokeRestart
  [21:25:26.851]                     muffled <- FALSE
  [21:25:26.851]                     if (inherits(cond, "message")) {
  [21:25:26.851]                       invokeRestart("muffleMessage")
  [21:25:26.851]                       muffled <- TRUE
  [21:25:26.851]                     }
  [21:25:26.851]                     else if (inherits(cond, "warning")) {
  [21:25:26.851]                       invokeRestart("muffleWarning")
  [21:25:26.851]                       muffled <- TRUE
  [21:25:26.851]                     }
  [21:25:26.851]                     else if (inherits(cond, "condition")) {
  [21:25:26.851]                       computeRestarts <- base::computeRestarts
  [21:25:26.851]                       grepl <- base::grepl
  [21:25:26.851]                       is.null <- base::is.null
  [21:25:26.851]                       restarts <- computeRestarts(cond)
  [21:25:26.851]                       for (restart in restarts) {
  [21:25:26.851]                         name <- restart$name
  [21:25:26.851]                         if (is.null(name)) 
  [21:25:26.851]                           next
  [21:25:26.851]                         if (!grepl("^muffle", name)) 
  [21:25:26.851]                           next
  [21:25:26.851]                         invokeRestart(restart)
  [21:25:26.851]                         muffled <- TRUE
  [21:25:26.851]                         break
  [21:25:26.851]                       }
  [21:25:26.851]                     }
  [21:25:26.851]                     invisible(muffled)
  [21:25:26.851]                   }
  [21:25:26.851]                   muffleCondition(cond)
  [21:25:26.851]                 })
  [21:25:26.851]             }))
  [21:25:26.851]             future::FutureResult(value = ...future.value$value, 
  [21:25:26.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.851]                   ...future.rng), started = ...future.startTime, 
  [21:25:26.851]                 version = "1.8")
  [21:25:26.851]         }, condition = base::local({
  [21:25:26.851]             c <- base::c
  [21:25:26.851]             inherits <- base::inherits
  [21:25:26.851]             invokeRestart <- base::invokeRestart
  [21:25:26.851]             length <- base::length
  [21:25:26.851]             list <- base::list
  [21:25:26.851]             seq.int <- base::seq.int
  [21:25:26.851]             signalCondition <- base::signalCondition
  [21:25:26.851]             sys.calls <- base::sys.calls
  [21:25:26.851]             Sys.time <- base::Sys.time
  [21:25:26.851]             `[[` <- base::`[[`
  [21:25:26.851]             `+` <- base::`+`
  [21:25:26.851]             `<<-` <- base::`<<-`
  [21:25:26.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:26.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:26.851]                   3L)]
  [21:25:26.851]             }
  [21:25:26.851]             function(cond) {
  [21:25:26.851]                 if (inherits(cond, "error")) {
  [21:25:26.851]                   sessionInformation <- function() {
  [21:25:26.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:26.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:26.851]                       search = base::search(), system = base::Sys.info())
  [21:25:26.851]                   }
  [21:25:26.851]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:26.851]                     cond$call), session = sessionInformation(), 
  [21:25:26.851]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:26.851]                   signalCondition(cond)
  [21:25:26.851]                 }
  [21:25:26.851]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:26.851]                 ))) {
  [21:25:26.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:26.851]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:26.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:26.851]                   if (!signal) {
  [21:25:26.851]                     muffleCondition <- function (cond) 
  [21:25:26.851]                     {
  [21:25:26.851]                       inherits <- base::inherits
  [21:25:26.851]                       invokeRestart <- base::invokeRestart
  [21:25:26.851]                       muffled <- FALSE
  [21:25:26.851]                       if (inherits(cond, "message")) {
  [21:25:26.851]                         invokeRestart("muffleMessage")
  [21:25:26.851]                         muffled <- TRUE
  [21:25:26.851]                       }
  [21:25:26.851]                       else if (inherits(cond, "warning")) {
  [21:25:26.851]                         invokeRestart("muffleWarning")
  [21:25:26.851]                         muffled <- TRUE
  [21:25:26.851]                       }
  [21:25:26.851]                       else if (inherits(cond, "condition")) {
  [21:25:26.851]                         computeRestarts <- base::computeRestarts
  [21:25:26.851]                         grepl <- base::grepl
  [21:25:26.851]                         is.null <- base::is.null
  [21:25:26.851]                         restarts <- computeRestarts(cond)
  [21:25:26.851]                         for (restart in restarts) {
  [21:25:26.851]                           name <- restart$name
  [21:25:26.851]                           if (is.null(name)) 
  [21:25:26.851]                             next
  [21:25:26.851]                           if (!grepl("^muffle", name)) 
  [21:25:26.851]                             next
  [21:25:26.851]                           invokeRestart(restart)
  [21:25:26.851]                           muffled <- TRUE
  [21:25:26.851]                           break
  [21:25:26.851]                         }
  [21:25:26.851]                       }
  [21:25:26.851]                       invisible(muffled)
  [21:25:26.851]                     }
  [21:25:26.851]                     muffleCondition(cond)
  [21:25:26.851]                   }
  [21:25:26.851]                 }
  [21:25:26.851]             }
  [21:25:26.851]         }))
  [21:25:26.851]     }, error = function(ex) {
  [21:25:26.851]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:26.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:26.851]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:26.851]     }, finally = {
  [21:25:26.851]         {
  [21:25:26.851]             NULL
  [21:25:26.851]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:26.851]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:26.851]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:26.851]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:26.851]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:26.851]                 ...) 
  [21:25:26.851]             {
  [21:25:26.851]                 if (substitute) 
  [21:25:26.851]                   expr <- substitute(expr)
  [21:25:26.851]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:26.851]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:26.851]                   globals = globals, persistent = persistent, 
  [21:25:26.851]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:26.851]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:26.851]                   label = label, ...)
  [21:25:26.851]                 if (!future$lazy) 
  [21:25:26.851]                   future <- run(future)
  [21:25:26.851]                 invisible(future)
  [21:25:26.851]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:26.851]         }
  [21:25:26.851]         base::options(...future.oldOptions)
  [21:25:26.851]     })
  [21:25:26.851]     Sys.time
  [21:25:26.851]     if (base::is.na(TRUE)) {
  [21:25:26.851]     }
  [21:25:26.851]     else {
  [21:25:26.851]         base::sink(type = "output", split = FALSE)
  [21:25:26.851]         if (TRUE) {
  [21:25:26.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:26.851]         }
  [21:25:26.851]         else {
  [21:25:26.851]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:26.851]         }
  [21:25:26.851]         base::close(...future.stdout)
  [21:25:26.851]         ...future.stdout <- NULL
  [21:25:26.851]     }
  [21:25:26.851]     ...future.result$conditions <- ...future.conditions
  [21:25:26.851]     ...future.result
  [21:25:26.851] }
  [21:25:26.865] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:26.877] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.878] - Validating connection of ClusterFuture
  [21:25:26.878] - received message: FutureResult
  [21:25:26.879] - Received FutureResult
  [21:25:26.879] - Erased future from FutureRegistry
  [21:25:26.879] result() for ClusterFuture ...
  [21:25:26.879] - result already collected: FutureResult
  [21:25:26.880] result() for ClusterFuture ... done
  [21:25:26.880] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:26.880] result() for ClusterFuture ...
  [21:25:26.882] - result already collected: FutureResult
  [21:25:26.882] result() for ClusterFuture ... done
  [21:25:26.882] result() for ClusterFuture ...
  [21:25:26.883] - result already collected: FutureResult
  [21:25:26.883] result() for ClusterFuture ... done
  [21:25:26.894] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef211d3f90> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef20eacb80> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef211d3f90> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef20eacb80> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 2 3
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
  [21:25:26.934] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:26.934] - Validating connection of ClusterFuture
  [21:25:26.935] - received message: FutureResult
  [21:25:26.935] - Received FutureResult
  [21:25:26.935] - Erased future from FutureRegistry
  [21:25:26.936] result() for ClusterFuture ...
  [21:25:26.936] - result already collected: FutureResult
  [21:25:26.936] result() for ClusterFuture ... done
  [21:25:26.937] receiveMessageFromWorker() for ClusterFuture ... done
   logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:26.945] resolve() on list ...
  [21:25:26.946]  recursive: 0
  [21:25:26.946]  length: 6
  [21:25:26.946]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:26.947] signalConditionsASAP(numeric, pos=1) ...
  [21:25:26.947] - nx: 6
  [21:25:26.947] - relay: TRUE
  [21:25:26.947] - stdout: TRUE
  [21:25:26.947] - signal: TRUE
  [21:25:26.948] - resignal: FALSE
  [21:25:26.948] - force: TRUE
  [21:25:26.948] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.948] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.949]  - until=2
  [21:25:26.949]  - relaying element #2
  [21:25:26.949] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.949] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.950] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:26.950]  length: 5 (resolved future 1)
  [21:25:26.950] Future #2
  [21:25:26.951] result() for ClusterFuture ...
  [21:25:26.951] - result already collected: FutureResult
  [21:25:26.951] result() for ClusterFuture ... done
  [21:25:26.951] result() for ClusterFuture ...
  [21:25:26.952] - result already collected: FutureResult
  [21:25:26.952] result() for ClusterFuture ... done
  [21:25:26.966] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:26.966] - nx: 6
  [21:25:26.967] - relay: TRUE
  [21:25:26.967] - stdout: TRUE
  [21:25:26.967] - signal: TRUE
  [21:25:26.967] - resignal: FALSE
  [21:25:26.968] - force: TRUE
  [21:25:26.968] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.968] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.968]  - until=2
  [21:25:26.969]  - relaying element #2
  [21:25:26.969] result() for ClusterFuture ...
  [21:25:26.969] - result already collected: FutureResult
  [21:25:26.969] result() for ClusterFuture ... done
  [21:25:26.970] result() for ClusterFuture ...
  [21:25:26.970] - result already collected: FutureResult
  [21:25:26.970] result() for ClusterFuture ... done
  [21:25:26.971] result() for ClusterFuture ...
  [21:25:26.971] - result already collected: FutureResult
  [21:25:26.971] result() for ClusterFuture ... done
  [21:25:26.971] result() for ClusterFuture ...
  [21:25:26.972] - result already collected: FutureResult
  [21:25:26.972] result() for ClusterFuture ... done
  [21:25:26.972] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.972] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.973] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:26.973]  length: 4 (resolved future 2)
  [21:25:26.973] Future #3
  [21:25:26.973] result() for ClusterFuture ...
  [21:25:26.974] - result already collected: FutureResult
  [21:25:26.974] result() for ClusterFuture ... done
  [21:25:26.974] result() for ClusterFuture ...
  [21:25:26.975] - result already collected: FutureResult
  [21:25:26.975] result() for ClusterFuture ... done
  [21:25:26.975] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:26.975] - nx: 6
  [21:25:26.976] - relay: TRUE
  [21:25:26.976] - stdout: TRUE
  [21:25:26.976] - signal: TRUE
  [21:25:26.976] - resignal: FALSE
  [21:25:26.976] - force: TRUE
  [21:25:26.977] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.977] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:26.977]  - until=3
  [21:25:26.977]  - relaying element #3
  [21:25:26.978] result() for ClusterFuture ...
  [21:25:26.978] - result already collected: FutureResult
  [21:25:26.978] result() for ClusterFuture ... done
  [21:25:26.979] result() for ClusterFuture ...
  [21:25:26.979] - result already collected: FutureResult
  [21:25:26.979] result() for ClusterFuture ... done
  [21:25:26.980] result() for ClusterFuture ...
  [21:25:26.980] - result already collected: FutureResult
  [21:25:26.980] result() for ClusterFuture ... done
  [21:25:26.981] result() for ClusterFuture ...
  [21:25:26.981] - result already collected: FutureResult
  [21:25:26.981] result() for ClusterFuture ... done
  [21:25:26.981] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.982] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.982] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:26.982]  length: 3 (resolved future 3)
  [21:25:26.983] signalConditionsASAP(NULL, pos=4) ...
  [21:25:26.983] - nx: 6
  [21:25:26.983] - relay: TRUE
  [21:25:26.983] - stdout: TRUE
  [21:25:26.984] - signal: TRUE
  [21:25:26.984] - resignal: FALSE
  [21:25:26.984] - force: TRUE
  [21:25:26.984] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.984] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.985]  - until=5
  [21:25:26.985]  - relaying element #5
  [21:25:26.985] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.986] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.986] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:26.986]  length: 2 (resolved future 4)
  [21:25:26.986] signalConditionsASAP(NULL, pos=5) ...
  [21:25:26.987] - nx: 6
  [21:25:26.987] - relay: TRUE
  [21:25:26.987] - stdout: TRUE
  [21:25:26.987] - signal: TRUE
  [21:25:26.988] - resignal: FALSE
  [21:25:26.988] - force: TRUE
  [21:25:26.988] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:26.988] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.989]  - until=6
  [21:25:26.989]  - relaying element #6
  [21:25:26.989] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.990] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.990] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:26.990]  length: 1 (resolved future 5)
  [21:25:26.991] signalConditionsASAP(numeric, pos=6) ...
  [21:25:26.991] - nx: 6
  [21:25:26.991] - relay: TRUE
  [21:25:26.991] - stdout: TRUE
  [21:25:26.992] - signal: TRUE
  [21:25:26.992] - resignal: FALSE
  [21:25:26.992] - force: TRUE
  [21:25:26.992] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:26.993] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.993]  - until=6
  [21:25:26.993] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.994] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.994] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:26.994]  length: 0 (resolved future 6)
  [21:25:26.994] Relaying remaining futures
  [21:25:26.995] signalConditionsASAP(NULL, pos=0) ...
  [21:25:26.995] - nx: 6
  [21:25:26.995] - relay: TRUE
  [21:25:26.995] - stdout: TRUE
  [21:25:26.996] - signal: TRUE
  [21:25:26.996] - resignal: FALSE
  [21:25:26.996] - force: TRUE
  [21:25:26.996] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.997] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:26.997] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:26.997] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:26.998] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:26.998] resolve() on list ... DONE
  [21:25:26.998] result() for ClusterFuture ...
  [21:25:26.998] - result already collected: FutureResult
  [21:25:26.999] result() for ClusterFuture ... done
  [21:25:26.999] result() for ClusterFuture ...
  [21:25:26.999] - result already collected: FutureResult
  [21:25:27.000] result() for ClusterFuture ... done
  [21:25:27.000] result() for ClusterFuture ...
  [21:25:27.000] - result already collected: FutureResult
  [21:25:27.000] result() for ClusterFuture ... done
  [21:25:27.001] result() for ClusterFuture ...
  [21:25:27.001] - result already collected: FutureResult
  [21:25:27.001] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:2] 2 3
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
  Dimensions: c(2, 3, 1)
  [21:25:27.011] getGlobalsAndPackages() ...
  [21:25:27.011] Searching for globals...
  [21:25:27.012] 
  [21:25:27.012] Searching for globals ... DONE
  [21:25:27.012] - globals: [0] <none>
  [21:25:27.012] getGlobalsAndPackages() ... DONE
  [21:25:27.017] Packages needed by the future expression (n = 0): <none>
  [21:25:27.017] Packages needed by future strategies (n = 0): <none>
  [21:25:27.025] {
  [21:25:27.025]     {
  [21:25:27.025]         ...future.startTime <- base::Sys.time()
  [21:25:27.025]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.025]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.025]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.025]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.025]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.025]         {
  [21:25:27.025]             {
  [21:25:27.025]                 base::local({
  [21:25:27.025]                   has_future <- base::requireNamespace("future", 
  [21:25:27.025]                     quietly = TRUE)
  [21:25:27.025]                   version <- if (has_future) 
  [21:25:27.025]                     utils::packageVersion("future")
  [21:25:27.025]                   else NULL
  [21:25:27.025]                   if (!has_future || version < "1.8.0") {
  [21:25:27.025]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.025]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.025]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.025]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.025]                         "release", "version")], collapse = " "), 
  [21:25:27.025]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.025]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.025]                       info)
  [21:25:27.025]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.025]                     if (!has_future) {
  [21:25:27.025]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.025]                         info)
  [21:25:27.025]                     }
  [21:25:27.025]                     else {
  [21:25:27.025]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.025]                         info, version)
  [21:25:27.025]                     }
  [21:25:27.025]                     base::stop(msg)
  [21:25:27.025]                   }
  [21:25:27.025]                 })
  [21:25:27.025]             }
  [21:25:27.025]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.025]         }
  [21:25:27.025]     }
  [21:25:27.025]     if (base::is.na(TRUE)) {
  [21:25:27.025]     }
  [21:25:27.025]     else {
  [21:25:27.025]         if (TRUE) {
  [21:25:27.025]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.025]                 open = "w")
  [21:25:27.025]         }
  [21:25:27.025]         else {
  [21:25:27.025]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.025]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.025]         }
  [21:25:27.025]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.025]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.025]             base::sink(type = "output", split = FALSE)
  [21:25:27.025]             base::close(...future.stdout)
  [21:25:27.025]         }, add = TRUE)
  [21:25:27.025]     }
  [21:25:27.025]     ...future.frame <- base::sys.nframe()
  [21:25:27.025]     ...future.conditions <- base::list()
  [21:25:27.025]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.025]     ...future.result <- base::tryCatch({
  [21:25:27.025]         base::withCallingHandlers({
  [21:25:27.025]             ...future.value <- base::withVisible(base::local({
  [21:25:27.025]                 ...future.sendCondition <- local({
  [21:25:27.025]                   sendCondition <- NULL
  [21:25:27.025]                   function(frame = 1L) {
  [21:25:27.025]                     if (is.function(sendCondition)) 
  [21:25:27.025]                       return(sendCondition)
  [21:25:27.025]                     ns <- getNamespace("parallel")
  [21:25:27.025]                     if (exists("sendData", mode = "function", 
  [21:25:27.025]                       envir = ns)) {
  [21:25:27.025]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:27.025]                         envir = ns)
  [21:25:27.025]                       envir <- sys.frame(frame)
  [21:25:27.025]                       master <- NULL
  [21:25:27.025]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:27.025]                         !identical(envir, emptyenv())) {
  [21:25:27.025]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:27.025]                           inherits = FALSE)) {
  [21:25:27.025]                           master <- get("master", mode = "list", 
  [21:25:27.025]                             envir = envir, inherits = FALSE)
  [21:25:27.025]                           if (inherits(master, "SOCKnode")) {
  [21:25:27.025]                             sendCondition <<- function(cond) {
  [21:25:27.025]                               data <- list(type = "VALUE", value = cond, 
  [21:25:27.025]                                 success = TRUE)
  [21:25:27.025]                               parallel_sendData(master, data)
  [21:25:27.025]                             }
  [21:25:27.025]                             return(sendCondition)
  [21:25:27.025]                           }
  [21:25:27.025]                         }
  [21:25:27.025]                         frame <- frame + 1L
  [21:25:27.025]                         envir <- sys.frame(frame)
  [21:25:27.025]                       }
  [21:25:27.025]                     }
  [21:25:27.025]                     sendCondition <<- function(cond) NULL
  [21:25:27.025]                   }
  [21:25:27.025]                 })
  [21:25:27.025]                 withCallingHandlers({
  [21:25:27.025]                   2
  [21:25:27.025]                 }, immediateCondition = function(cond) {
  [21:25:27.025]                   sendCondition <- ...future.sendCondition()
  [21:25:27.025]                   sendCondition(cond)
  [21:25:27.025]                   muffleCondition <- function (cond) 
  [21:25:27.025]                   {
  [21:25:27.025]                     inherits <- base::inherits
  [21:25:27.025]                     invokeRestart <- base::invokeRestart
  [21:25:27.025]                     muffled <- FALSE
  [21:25:27.025]                     if (inherits(cond, "message")) {
  [21:25:27.025]                       invokeRestart("muffleMessage")
  [21:25:27.025]                       muffled <- TRUE
  [21:25:27.025]                     }
  [21:25:27.025]                     else if (inherits(cond, "warning")) {
  [21:25:27.025]                       invokeRestart("muffleWarning")
  [21:25:27.025]                       muffled <- TRUE
  [21:25:27.025]                     }
  [21:25:27.025]                     else if (inherits(cond, "condition")) {
  [21:25:27.025]                       computeRestarts <- base::computeRestarts
  [21:25:27.025]                       grepl <- base::grepl
  [21:25:27.025]                       is.null <- base::is.null
  [21:25:27.025]                       restarts <- computeRestarts(cond)
  [21:25:27.025]                       for (restart in restarts) {
  [21:25:27.025]                         name <- restart$name
  [21:25:27.025]                         if (is.null(name)) 
  [21:25:27.025]                           next
  [21:25:27.025]                         if (!grepl("^muffle", name)) 
  [21:25:27.025]                           next
  [21:25:27.025]                         invokeRestart(restart)
  [21:25:27.025]                         muffled <- TRUE
  [21:25:27.025]                         break
  [21:25:27.025]                       }
  [21:25:27.025]                     }
  [21:25:27.025]                     invisible(muffled)
  [21:25:27.025]                   }
  [21:25:27.025]                   muffleCondition(cond)
  [21:25:27.025]                 })
  [21:25:27.025]             }))
  [21:25:27.025]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.025]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.025]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.025]                 version = "1.8")
  [21:25:27.025]         }, condition = base::local({
  [21:25:27.025]             c <- base::c
  [21:25:27.025]             inherits <- base::inherits
  [21:25:27.025]             invokeRestart <- base::invokeRestart
  [21:25:27.025]             length <- base::length
  [21:25:27.025]             list <- base::list
  [21:25:27.025]             seq.int <- base::seq.int
  [21:25:27.025]             signalCondition <- base::signalCondition
  [21:25:27.025]             sys.calls <- base::sys.calls
  [21:25:27.025]             Sys.time <- base::Sys.time
  [21:25:27.025]             `[[` <- base::`[[`
  [21:25:27.025]             `+` <- base::`+`
  [21:25:27.025]             `<<-` <- base::`<<-`
  [21:25:27.025]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.025]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.025]                   3L)]
  [21:25:27.025]             }
  [21:25:27.025]             function(cond) {
  [21:25:27.025]                 if (inherits(cond, "error")) {
  [21:25:27.025]                   sessionInformation <- function() {
  [21:25:27.025]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.025]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.025]                       search = base::search(), system = base::Sys.info())
  [21:25:27.025]                   }
  [21:25:27.025]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.025]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.025]                     cond$call), session = sessionInformation(), 
  [21:25:27.025]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.025]                   signalCondition(cond)
  [21:25:27.025]                 }
  [21:25:27.025]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.025]                 ))) {
  [21:25:27.025]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.025]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.025]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.025]                   if (!signal) {
  [21:25:27.025]                     muffleCondition <- function (cond) 
  [21:25:27.025]                     {
  [21:25:27.025]                       inherits <- base::inherits
  [21:25:27.025]                       invokeRestart <- base::invokeRestart
  [21:25:27.025]                       muffled <- FALSE
  [21:25:27.025]                       if (inherits(cond, "message")) {
  [21:25:27.025]                         invokeRestart("muffleMessage")
  [21:25:27.025]                         muffled <- TRUE
  [21:25:27.025]                       }
  [21:25:27.025]                       else if (inherits(cond, "warning")) {
  [21:25:27.025]                         invokeRestart("muffleWarning")
  [21:25:27.025]                         muffled <- TRUE
  [21:25:27.025]                       }
  [21:25:27.025]                       else if (inherits(cond, "condition")) {
  [21:25:27.025]                         computeRestarts <- base::computeRestarts
  [21:25:27.025]                         grepl <- base::grepl
  [21:25:27.025]                         is.null <- base::is.null
  [21:25:27.025]                         restarts <- computeRestarts(cond)
  [21:25:27.025]                         for (restart in restarts) {
  [21:25:27.025]                           name <- restart$name
  [21:25:27.025]                           if (is.null(name)) 
  [21:25:27.025]                             next
  [21:25:27.025]                           if (!grepl("^muffle", name)) 
  [21:25:27.025]                             next
  [21:25:27.025]                           invokeRestart(restart)
  [21:25:27.025]                           muffled <- TRUE
  [21:25:27.025]                           break
  [21:25:27.025]                         }
  [21:25:27.025]                       }
  [21:25:27.025]                       invisible(muffled)
  [21:25:27.025]                     }
  [21:25:27.025]                     muffleCondition(cond)
  [21:25:27.025]                   }
  [21:25:27.025]                 }
  [21:25:27.025]             }
  [21:25:27.025]         }))
  [21:25:27.025]     }, error = function(ex) {
  [21:25:27.025]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.025]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.025]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.025]     }, finally = {
  [21:25:27.025]         {
  [21:25:27.025]             NULL
  [21:25:27.025]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.025]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.025]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:27.025]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:27.025]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:27.025]                 ...) 
  [21:25:27.025]             {
  [21:25:27.025]                 if (substitute) 
  [21:25:27.025]                   expr <- substitute(expr)
  [21:25:27.025]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:27.025]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.025]                   globals = globals, persistent = persistent, 
  [21:25:27.025]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:27.025]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:27.025]                   label = label, ...)
  [21:25:27.025]                 if (!future$lazy) 
  [21:25:27.025]                   future <- run(future)
  [21:25:27.025]                 invisible(future)
  [21:25:27.025]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.025]         }
  [21:25:27.025]         base::options(...future.oldOptions)
  [21:25:27.025]     })
  [21:25:27.025]     Sys.time
  [21:25:27.025]     if (base::is.na(TRUE)) {
  [21:25:27.025]     }
  [21:25:27.025]     else {
  [21:25:27.025]         base::sink(type = "output", split = FALSE)
  [21:25:27.025]         if (TRUE) {
  [21:25:27.025]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.025]         }
  [21:25:27.025]         else {
  [21:25:27.025]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.025]         }
  [21:25:27.025]         base::close(...future.stdout)
  [21:25:27.025]         ...future.stdout <- NULL
  [21:25:27.025]     }
  [21:25:27.025]     ...future.result$conditions <- ...future.conditions
  [21:25:27.025]     ...future.result
  [21:25:27.025] }
  [21:25:27.032] ClusterFuture started
  [21:25:27.032] getGlobalsAndPackages() ...
  [21:25:27.032] Searching for globals...
  [21:25:27.033] 
  [21:25:27.033] Searching for globals ... DONE
  [21:25:27.034] - globals: [0] <none>
  [21:25:27.034] getGlobalsAndPackages() ... DONE
  [21:25:27.038] Packages needed by the future expression (n = 0): <none>
  [21:25:27.039] Packages needed by future strategies (n = 0): <none>
  [21:25:27.043] {
  [21:25:27.043]     {
  [21:25:27.043]         ...future.startTime <- base::Sys.time()
  [21:25:27.043]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.043]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.043]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.043]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.043]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.043]         {
  [21:25:27.043]             {
  [21:25:27.043]                 base::local({
  [21:25:27.043]                   has_future <- base::requireNamespace("future", 
  [21:25:27.043]                     quietly = TRUE)
  [21:25:27.043]                   version <- if (has_future) 
  [21:25:27.043]                     utils::packageVersion("future")
  [21:25:27.043]                   else NULL
  [21:25:27.043]                   if (!has_future || version < "1.8.0") {
  [21:25:27.043]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.043]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.043]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.043]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.043]                         "release", "version")], collapse = " "), 
  [21:25:27.043]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.043]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.043]                       info)
  [21:25:27.043]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.043]                     if (!has_future) {
  [21:25:27.043]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.043]                         info)
  [21:25:27.043]                     }
  [21:25:27.043]                     else {
  [21:25:27.043]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.043]                         info, version)
  [21:25:27.043]                     }
  [21:25:27.043]                     base::stop(msg)
  [21:25:27.043]                   }
  [21:25:27.043]                 })
  [21:25:27.043]             }
  [21:25:27.043]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.043]         }
  [21:25:27.043]     }
  [21:25:27.043]     if (base::is.na(TRUE)) {
  [21:25:27.043]     }
  [21:25:27.043]     else {
  [21:25:27.043]         if (TRUE) {
  [21:25:27.043]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.043]                 open = "w")
  [21:25:27.043]         }
  [21:25:27.043]         else {
  [21:25:27.043]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.043]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.043]         }
  [21:25:27.043]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.043]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.043]             base::sink(type = "output", split = FALSE)
  [21:25:27.043]             base::close(...future.stdout)
  [21:25:27.043]         }, add = TRUE)
  [21:25:27.043]     }
  [21:25:27.043]     ...future.frame <- base::sys.nframe()
  [21:25:27.043]     ...future.conditions <- base::list()
  [21:25:27.043]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.043]     ...future.result <- base::tryCatch({
  [21:25:27.043]         base::withCallingHandlers({
  [21:25:27.043]             ...future.value <- base::withVisible(base::local({
  [21:25:27.043]                 ...future.sendCondition <- local({
  [21:25:27.043]                   sendCondition <- NULL
  [21:25:27.043]                   function(frame = 1L) {
  [21:25:27.043]                     if (is.function(sendCondition)) 
  [21:25:27.043]                       return(sendCondition)
  [21:25:27.043]                     ns <- getNamespace("parallel")
  [21:25:27.043]                     if (exists("sendData", mode = "function", 
  [21:25:27.043]                       envir = ns)) {
  [21:25:27.043]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:27.043]                         envir = ns)
  [21:25:27.043]                       envir <- sys.frame(frame)
  [21:25:27.043]                       master <- NULL
  [21:25:27.043]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:27.043]                         !identical(envir, emptyenv())) {
  [21:25:27.043]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:27.043]                           inherits = FALSE)) {
  [21:25:27.043]                           master <- get("master", mode = "list", 
  [21:25:27.043]                             envir = envir, inherits = FALSE)
  [21:25:27.043]                           if (inherits(master, "SOCKnode")) {
  [21:25:27.043]                             sendCondition <<- function(cond) {
  [21:25:27.043]                               data <- list(type = "VALUE", value = cond, 
  [21:25:27.043]                                 success = TRUE)
  [21:25:27.043]                               parallel_sendData(master, data)
  [21:25:27.043]                             }
  [21:25:27.043]                             return(sendCondition)
  [21:25:27.043]                           }
  [21:25:27.043]                         }
  [21:25:27.043]                         frame <- frame + 1L
  [21:25:27.043]                         envir <- sys.frame(frame)
  [21:25:27.043]                       }
  [21:25:27.043]                     }
  [21:25:27.043]                     sendCondition <<- function(cond) NULL
  [21:25:27.043]                   }
  [21:25:27.043]                 })
  [21:25:27.043]                 withCallingHandlers({
  [21:25:27.043]                   NULL
  [21:25:27.043]                 }, immediateCondition = function(cond) {
  [21:25:27.043]                   sendCondition <- ...future.sendCondition()
  [21:25:27.043]                   sendCondition(cond)
  [21:25:27.043]                   muffleCondition <- function (cond) 
  [21:25:27.043]                   {
  [21:25:27.043]                     inherits <- base::inherits
  [21:25:27.043]                     invokeRestart <- base::invokeRestart
  [21:25:27.043]                     muffled <- FALSE
  [21:25:27.043]                     if (inherits(cond, "message")) {
  [21:25:27.043]                       invokeRestart("muffleMessage")
  [21:25:27.043]                       muffled <- TRUE
  [21:25:27.043]                     }
  [21:25:27.043]                     else if (inherits(cond, "warning")) {
  [21:25:27.043]                       invokeRestart("muffleWarning")
  [21:25:27.043]                       muffled <- TRUE
  [21:25:27.043]                     }
  [21:25:27.043]                     else if (inherits(cond, "condition")) {
  [21:25:27.043]                       computeRestarts <- base::computeRestarts
  [21:25:27.043]                       grepl <- base::grepl
  [21:25:27.043]                       is.null <- base::is.null
  [21:25:27.043]                       restarts <- computeRestarts(cond)
  [21:25:27.043]                       for (restart in restarts) {
  [21:25:27.043]                         name <- restart$name
  [21:25:27.043]                         if (is.null(name)) 
  [21:25:27.043]                           next
  [21:25:27.043]                         if (!grepl("^muffle", name)) 
  [21:25:27.043]                           next
  [21:25:27.043]                         invokeRestart(restart)
  [21:25:27.043]                         muffled <- TRUE
  [21:25:27.043]                         break
  [21:25:27.043]                       }
  [21:25:27.043]                     }
  [21:25:27.043]                     invisible(muffled)
  [21:25:27.043]                   }
  [21:25:27.043]                   muffleCondition(cond)
  [21:25:27.043]                 })
  [21:25:27.043]             }))
  [21:25:27.043]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.043]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.043]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.043]                 version = "1.8")
  [21:25:27.043]         }, condition = base::local({
  [21:25:27.043]             c <- base::c
  [21:25:27.043]             inherits <- base::inherits
  [21:25:27.043]             invokeRestart <- base::invokeRestart
  [21:25:27.043]             length <- base::length
  [21:25:27.043]             list <- base::list
  [21:25:27.043]             seq.int <- base::seq.int
  [21:25:27.043]             signalCondition <- base::signalCondition
  [21:25:27.043]             sys.calls <- base::sys.calls
  [21:25:27.043]             Sys.time <- base::Sys.time
  [21:25:27.043]             `[[` <- base::`[[`
  [21:25:27.043]             `+` <- base::`+`
  [21:25:27.043]             `<<-` <- base::`<<-`
  [21:25:27.043]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.043]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.043]                   3L)]
  [21:25:27.043]             }
  [21:25:27.043]             function(cond) {
  [21:25:27.043]                 if (inherits(cond, "error")) {
  [21:25:27.043]                   sessionInformation <- function() {
  [21:25:27.043]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.043]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.043]                       search = base::search(), system = base::Sys.info())
  [21:25:27.043]                   }
  [21:25:27.043]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.043]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.043]                     cond$call), session = sessionInformation(), 
  [21:25:27.043]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.043]                   signalCondition(cond)
  [21:25:27.043]                 }
  [21:25:27.043]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.043]                 ))) {
  [21:25:27.043]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.043]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.043]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.043]                   if (!signal) {
  [21:25:27.043]                     muffleCondition <- function (cond) 
  [21:25:27.043]                     {
  [21:25:27.043]                       inherits <- base::inherits
  [21:25:27.043]                       invokeRestart <- base::invokeRestart
  [21:25:27.043]                       muffled <- FALSE
  [21:25:27.043]                       if (inherits(cond, "message")) {
  [21:25:27.043]                         invokeRestart("muffleMessage")
  [21:25:27.043]                         muffled <- TRUE
  [21:25:27.043]                       }
  [21:25:27.043]                       else if (inherits(cond, "warning")) {
  [21:25:27.043]                         invokeRestart("muffleWarning")
  [21:25:27.043]                         muffled <- TRUE
  [21:25:27.043]                       }
  [21:25:27.043]                       else if (inherits(cond, "condition")) {
  [21:25:27.043]                         computeRestarts <- base::computeRestarts
  [21:25:27.043]                         grepl <- base::grepl
  [21:25:27.043]                         is.null <- base::is.null
  [21:25:27.043]                         restarts <- computeRestarts(cond)
  [21:25:27.043]                         for (restart in restarts) {
  [21:25:27.043]                           name <- restart$name
  [21:25:27.043]                           if (is.null(name)) 
  [21:25:27.043]                             next
  [21:25:27.043]                           if (!grepl("^muffle", name)) 
  [21:25:27.043]                             next
  [21:25:27.043]                           invokeRestart(restart)
  [21:25:27.043]                           muffled <- TRUE
  [21:25:27.043]                           break
  [21:25:27.043]                         }
  [21:25:27.043]                       }
  [21:25:27.043]                       invisible(muffled)
  [21:25:27.043]                     }
  [21:25:27.043]                     muffleCondition(cond)
  [21:25:27.043]                   }
  [21:25:27.043]                 }
  [21:25:27.043]             }
  [21:25:27.043]         }))
  [21:25:27.043]     }, error = function(ex) {
  [21:25:27.043]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.043]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.043]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.043]     }, finally = {
  [21:25:27.043]         {
  [21:25:27.043]             NULL
  [21:25:27.043]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.043]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.043]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:27.043]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:27.043]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:27.043]                 ...) 
  [21:25:27.043]             {
  [21:25:27.043]                 if (substitute) 
  [21:25:27.043]                   expr <- substitute(expr)
  [21:25:27.043]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:27.043]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.043]                   globals = globals, persistent = persistent, 
  [21:25:27.043]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:27.043]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:27.043]                   label = label, ...)
  [21:25:27.043]                 if (!future$lazy) 
  [21:25:27.043]                   future <- run(future)
  [21:25:27.043]                 invisible(future)
  [21:25:27.043]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.043]         }
  [21:25:27.043]         base::options(...future.oldOptions)
  [21:25:27.043]     })
  [21:25:27.043]     Sys.time
  [21:25:27.043]     if (base::is.na(TRUE)) {
  [21:25:27.043]     }
  [21:25:27.043]     else {
  [21:25:27.043]         base::sink(type = "output", split = FALSE)
  [21:25:27.043]         if (TRUE) {
  [21:25:27.043]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.043]         }
  [21:25:27.043]         else {
  [21:25:27.043]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.043]         }
  [21:25:27.043]         base::close(...future.stdout)
  [21:25:27.043]         ...future.stdout <- NULL
  [21:25:27.043]     }
  [21:25:27.043]     ...future.result$conditions <- ...future.conditions
  [21:25:27.043]     ...future.result
  [21:25:27.043] }
  [21:25:27.048] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:27.078] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:27.078] - Validating connection of ClusterFuture
  [21:25:27.079] - received message: FutureResult
  [21:25:27.079] - Received FutureResult
  [21:25:27.079] - Erased future from FutureRegistry
  [21:25:27.080] result() for ClusterFuture ...
  [21:25:27.080] - result already collected: FutureResult
  [21:25:27.080] result() for ClusterFuture ... done
  [21:25:27.081] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:27.081] result() for ClusterFuture ...
  [21:25:27.081] - result already collected: FutureResult
  [21:25:27.082] result() for ClusterFuture ... done
  [21:25:27.082] result() for ClusterFuture ...
  [21:25:27.082] - result already collected: FutureResult
  [21:25:27.083] result() for ClusterFuture ... done
  [21:25:27.085] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22a56300> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef21017b30> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22a56300> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef21017b30> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:3] 2 3 1
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  [21:25:27.130] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:27.130] - Validating connection of ClusterFuture
  [21:25:27.131] - received message: FutureResult
  [21:25:27.131] - Received FutureResult
  [21:25:27.131] - Erased future from FutureRegistry
  [21:25:27.132] result() for ClusterFuture ...
  [21:25:27.132] - result already collected: FutureResult
  [21:25:27.132] result() for ClusterFuture ... done
  [21:25:27.133] receiveMessageFromWorker() for ClusterFuture ... done
   logi [1:2, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:27.138] resolve() on list ...
  [21:25:27.139]  recursive: 0
  [21:25:27.139]  length: 6
  [21:25:27.139]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:27.140] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.140] - nx: 6
  [21:25:27.140] - relay: TRUE
  [21:25:27.140] - stdout: TRUE
  [21:25:27.141] - signal: TRUE
  [21:25:27.141] - resignal: FALSE
  [21:25:27.141] - force: TRUE
  [21:25:27.141] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.142] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.142]  - until=2
  [21:25:27.142]  - relaying element #2
  [21:25:27.142] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.143] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.143] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.143]  length: 5 (resolved future 1)
  [21:25:27.144] Future #2
  [21:25:27.144] result() for ClusterFuture ...
  [21:25:27.144] - result already collected: FutureResult
  [21:25:27.144] result() for ClusterFuture ... done
  [21:25:27.145] result() for ClusterFuture ...
  [21:25:27.145] - result already collected: FutureResult
  [21:25:27.145] result() for ClusterFuture ... done
  [21:25:27.146] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:27.158] - nx: 6
  [21:25:27.158] - relay: TRUE
  [21:25:27.159] - stdout: TRUE
  [21:25:27.159] - signal: TRUE
  [21:25:27.159] - resignal: FALSE
  [21:25:27.159] - force: TRUE
  [21:25:27.160] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.164] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.164]  - until=2
  [21:25:27.164]  - relaying element #2
  [21:25:27.165] result() for ClusterFuture ...
  [21:25:27.165] - result already collected: FutureResult
  [21:25:27.165] result() for ClusterFuture ... done
  [21:25:27.166] result() for ClusterFuture ...
  [21:25:27.166] - result already collected: FutureResult
  [21:25:27.166] result() for ClusterFuture ... done
  [21:25:27.166] result() for ClusterFuture ...
  [21:25:27.167] - result already collected: FutureResult
  [21:25:27.167] result() for ClusterFuture ... done
  [21:25:27.167] result() for ClusterFuture ...
  [21:25:27.168] - result already collected: FutureResult
  [21:25:27.168] result() for ClusterFuture ... done
  [21:25:27.168] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.168] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.169] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:27.169]  length: 4 (resolved future 2)
  [21:25:27.169] Future #3
  [21:25:27.182] result() for ClusterFuture ...
  [21:25:27.182] - result already collected: FutureResult
  [21:25:27.183] result() for ClusterFuture ... done
  [21:25:27.183] result() for ClusterFuture ...
  [21:25:27.183] - result already collected: FutureResult
  [21:25:27.184] result() for ClusterFuture ... done
  [21:25:27.184] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:27.184] - nx: 6
  [21:25:27.184] - relay: TRUE
  [21:25:27.185] - stdout: TRUE
  [21:25:27.185] - signal: TRUE
  [21:25:27.185] - resignal: FALSE
  [21:25:27.185] - force: TRUE
  [21:25:27.186] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.186] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.186]  - until=3
  [21:25:27.186]  - relaying element #3
  [21:25:27.187] result() for ClusterFuture ...
  [21:25:27.187] - result already collected: FutureResult
  [21:25:27.187] result() for ClusterFuture ... done
  [21:25:27.188] result() for ClusterFuture ...
  [21:25:27.188] - result already collected: FutureResult
  [21:25:27.188] result() for ClusterFuture ... done
  [21:25:27.189] result() for ClusterFuture ...
  [21:25:27.189] - result already collected: FutureResult
  [21:25:27.189] result() for ClusterFuture ... done
  [21:25:27.189] result() for ClusterFuture ...
  [21:25:27.190] - result already collected: FutureResult
  [21:25:27.190] result() for ClusterFuture ... done
  [21:25:27.190] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.191] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.191] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:27.191]  length: 3 (resolved future 3)
  [21:25:27.191] signalConditionsASAP(NULL, pos=4) ...
  [21:25:27.192] - nx: 6
  [21:25:27.192] - relay: TRUE
  [21:25:27.192] - stdout: TRUE
  [21:25:27.192] - signal: TRUE
  [21:25:27.193] - resignal: FALSE
  [21:25:27.193] - force: TRUE
  [21:25:27.193] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.193] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.194]  - until=5
  [21:25:27.194]  - relaying element #5
  [21:25:27.194] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:27.195] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.195] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:27.195]  length: 2 (resolved future 4)
  [21:25:27.195] signalConditionsASAP(NULL, pos=5) ...
  [21:25:27.196] - nx: 6
  [21:25:27.196] - relay: TRUE
  [21:25:27.196] - stdout: TRUE
  [21:25:27.196] - signal: TRUE
  [21:25:27.197] - resignal: FALSE
  [21:25:27.197] - force: TRUE
  [21:25:27.197] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:27.197] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.218]  - until=6
  [21:25:27.218]  - relaying element #6
  [21:25:27.218] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:27.219] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.219] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:27.219]  length: 1 (resolved future 5)
  [21:25:27.220] signalConditionsASAP(numeric, pos=6) ...
  [21:25:27.220] - nx: 6
  [21:25:27.220] - relay: TRUE
  [21:25:27.220] - stdout: TRUE
  [21:25:27.221] - signal: TRUE
  [21:25:27.221] - resignal: FALSE
  [21:25:27.221] - force: TRUE
  [21:25:27.221] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:27.222] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.222]  - until=6
  [21:25:27.222] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.222] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.223] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:27.223]  length: 0 (resolved future 6)
  [21:25:27.223] Relaying remaining futures
  [21:25:27.224] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.224] - nx: 6
  [21:25:27.224] - relay: TRUE
  [21:25:27.224] - stdout: TRUE
  [21:25:27.225] - signal: TRUE
  [21:25:27.225] - resignal: FALSE
  [21:25:27.225] - force: TRUE
  [21:25:27.225] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.226] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:27.226] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.226] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.227] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.227] resolve() on list ... DONE
  [21:25:27.227] result() for ClusterFuture ...
  [21:25:27.227] - result already collected: FutureResult
  [21:25:27.228] result() for ClusterFuture ... done
  [21:25:27.228] result() for ClusterFuture ...
  [21:25:27.228] - result already collected: FutureResult
  [21:25:27.228] result() for ClusterFuture ... done
  [21:25:27.229] result() for ClusterFuture ...
  [21:25:27.229] - result already collected: FutureResult
  [21:25:27.229] result() for ClusterFuture ... done
  [21:25:27.230] result() for ClusterFuture ...
  [21:25:27.230] - result already collected: FutureResult
  [21:25:27.230] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:3] 2 3 1
   - attr(*, "dimnames")=List of 3
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  Dimensions: c(2, 1, 3, 1)
  [21:25:27.255] getGlobalsAndPackages() ...
  [21:25:27.256] Searching for globals...
  [21:25:27.256] 
  [21:25:27.257] Searching for globals ... DONE
  [21:25:27.257] - globals: [0] <none>
  [21:25:27.257] getGlobalsAndPackages() ... DONE
  [21:25:27.261] Packages needed by the future expression (n = 0): <none>
  [21:25:27.262] Packages needed by future strategies (n = 0): <none>
  [21:25:27.282] {
  [21:25:27.282]     {
  [21:25:27.282]         ...future.startTime <- base::Sys.time()
  [21:25:27.282]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.282]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.282]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.282]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.282]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.282]         {
  [21:25:27.282]             {
  [21:25:27.282]                 base::local({
  [21:25:27.282]                   has_future <- base::requireNamespace("future", 
  [21:25:27.282]                     quietly = TRUE)
  [21:25:27.282]                   version <- if (has_future) 
  [21:25:27.282]                     utils::packageVersion("future")
  [21:25:27.282]                   else NULL
  [21:25:27.282]                   if (!has_future || version < "1.8.0") {
  [21:25:27.282]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.282]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.282]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.282]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.282]                         "release", "version")], collapse = " "), 
  [21:25:27.282]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.282]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.282]                       info)
  [21:25:27.282]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.282]                     if (!has_future) {
  [21:25:27.282]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.282]                         info)
  [21:25:27.282]                     }
  [21:25:27.282]                     else {
  [21:25:27.282]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.282]                         info, version)
  [21:25:27.282]                     }
  [21:25:27.282]                     base::stop(msg)
  [21:25:27.282]                   }
  [21:25:27.282]                 })
  [21:25:27.282]             }
  [21:25:27.282]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.282]         }
  [21:25:27.282]     }
  [21:25:27.282]     if (base::is.na(TRUE)) {
  [21:25:27.282]     }
  [21:25:27.282]     else {
  [21:25:27.282]         if (TRUE) {
  [21:25:27.282]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.282]                 open = "w")
  [21:25:27.282]         }
  [21:25:27.282]         else {
  [21:25:27.282]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.282]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.282]         }
  [21:25:27.282]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.282]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.282]             base::sink(type = "output", split = FALSE)
  [21:25:27.282]             base::close(...future.stdout)
  [21:25:27.282]         }, add = TRUE)
  [21:25:27.282]     }
  [21:25:27.282]     ...future.frame <- base::sys.nframe()
  [21:25:27.282]     ...future.conditions <- base::list()
  [21:25:27.282]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.282]     ...future.result <- base::tryCatch({
  [21:25:27.282]         base::withCallingHandlers({
  [21:25:27.282]             ...future.value <- base::withVisible(base::local({
  [21:25:27.282]                 ...future.sendCondition <- local({
  [21:25:27.282]                   sendCondition <- NULL
  [21:25:27.282]                   function(frame = 1L) {
  [21:25:27.282]                     if (is.function(sendCondition)) 
  [21:25:27.282]                       return(sendCondition)
  [21:25:27.282]                     ns <- getNamespace("parallel")
  [21:25:27.282]                     if (exists("sendData", mode = "function", 
  [21:25:27.282]                       envir = ns)) {
  [21:25:27.282]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:27.282]                         envir = ns)
  [21:25:27.282]                       envir <- sys.frame(frame)
  [21:25:27.282]                       master <- NULL
  [21:25:27.282]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:27.282]                         !identical(envir, emptyenv())) {
  [21:25:27.282]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:27.282]                           inherits = FALSE)) {
  [21:25:27.282]                           master <- get("master", mode = "list", 
  [21:25:27.282]                             envir = envir, inherits = FALSE)
  [21:25:27.282]                           if (inherits(master, "SOCKnode")) {
  [21:25:27.282]                             sendCondition <<- function(cond) {
  [21:25:27.282]                               data <- list(type = "VALUE", value = cond, 
  [21:25:27.282]                                 success = TRUE)
  [21:25:27.282]                               parallel_sendData(master, data)
  [21:25:27.282]                             }
  [21:25:27.282]                             return(sendCondition)
  [21:25:27.282]                           }
  [21:25:27.282]                         }
  [21:25:27.282]                         frame <- frame + 1L
  [21:25:27.282]                         envir <- sys.frame(frame)
  [21:25:27.282]                       }
  [21:25:27.282]                     }
  [21:25:27.282]                     sendCondition <<- function(cond) NULL
  [21:25:27.282]                   }
  [21:25:27.282]                 })
  [21:25:27.282]                 withCallingHandlers({
  [21:25:27.282]                   2
  [21:25:27.282]                 }, immediateCondition = function(cond) {
  [21:25:27.282]                   sendCondition <- ...future.sendCondition()
  [21:25:27.282]                   sendCondition(cond)
  [21:25:27.282]                   muffleCondition <- function (cond) 
  [21:25:27.282]                   {
  [21:25:27.282]                     inherits <- base::inherits
  [21:25:27.282]                     invokeRestart <- base::invokeRestart
  [21:25:27.282]                     muffled <- FALSE
  [21:25:27.282]                     if (inherits(cond, "message")) {
  [21:25:27.282]                       invokeRestart("muffleMessage")
  [21:25:27.282]                       muffled <- TRUE
  [21:25:27.282]                     }
  [21:25:27.282]                     else if (inherits(cond, "warning")) {
  [21:25:27.282]                       invokeRestart("muffleWarning")
  [21:25:27.282]                       muffled <- TRUE
  [21:25:27.282]                     }
  [21:25:27.282]                     else if (inherits(cond, "condition")) {
  [21:25:27.282]                       computeRestarts <- base::computeRestarts
  [21:25:27.282]                       grepl <- base::grepl
  [21:25:27.282]                       is.null <- base::is.null
  [21:25:27.282]                       restarts <- computeRestarts(cond)
  [21:25:27.282]                       for (restart in restarts) {
  [21:25:27.282]                         name <- restart$name
  [21:25:27.282]                         if (is.null(name)) 
  [21:25:27.282]                           next
  [21:25:27.282]                         if (!grepl("^muffle", name)) 
  [21:25:27.282]                           next
  [21:25:27.282]                         invokeRestart(restart)
  [21:25:27.282]                         muffled <- TRUE
  [21:25:27.282]                         break
  [21:25:27.282]                       }
  [21:25:27.282]                     }
  [21:25:27.282]                     invisible(muffled)
  [21:25:27.282]                   }
  [21:25:27.282]                   muffleCondition(cond)
  [21:25:27.282]                 })
  [21:25:27.282]             }))
  [21:25:27.282]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.282]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.282]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.282]                 version = "1.8")
  [21:25:27.282]         }, condition = base::local({
  [21:25:27.282]             c <- base::c
  [21:25:27.282]             inherits <- base::inherits
  [21:25:27.282]             invokeRestart <- base::invokeRestart
  [21:25:27.282]             length <- base::length
  [21:25:27.282]             list <- base::list
  [21:25:27.282]             seq.int <- base::seq.int
  [21:25:27.282]             signalCondition <- base::signalCondition
  [21:25:27.282]             sys.calls <- base::sys.calls
  [21:25:27.282]             Sys.time <- base::Sys.time
  [21:25:27.282]             `[[` <- base::`[[`
  [21:25:27.282]             `+` <- base::`+`
  [21:25:27.282]             `<<-` <- base::`<<-`
  [21:25:27.282]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.282]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.282]                   3L)]
  [21:25:27.282]             }
  [21:25:27.282]             function(cond) {
  [21:25:27.282]                 if (inherits(cond, "error")) {
  [21:25:27.282]                   sessionInformation <- function() {
  [21:25:27.282]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.282]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.282]                       search = base::search(), system = base::Sys.info())
  [21:25:27.282]                   }
  [21:25:27.282]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.282]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.282]                     cond$call), session = sessionInformation(), 
  [21:25:27.282]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.282]                   signalCondition(cond)
  [21:25:27.282]                 }
  [21:25:27.282]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.282]                 ))) {
  [21:25:27.282]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.282]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.282]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.282]                   if (!signal) {
  [21:25:27.282]                     muffleCondition <- function (cond) 
  [21:25:27.282]                     {
  [21:25:27.282]                       inherits <- base::inherits
  [21:25:27.282]                       invokeRestart <- base::invokeRestart
  [21:25:27.282]                       muffled <- FALSE
  [21:25:27.282]                       if (inherits(cond, "message")) {
  [21:25:27.282]                         invokeRestart("muffleMessage")
  [21:25:27.282]                         muffled <- TRUE
  [21:25:27.282]                       }
  [21:25:27.282]                       else if (inherits(cond, "warning")) {
  [21:25:27.282]                         invokeRestart("muffleWarning")
  [21:25:27.282]                         muffled <- TRUE
  [21:25:27.282]                       }
  [21:25:27.282]                       else if (inherits(cond, "condition")) {
  [21:25:27.282]                         computeRestarts <- base::computeRestarts
  [21:25:27.282]                         grepl <- base::grepl
  [21:25:27.282]                         is.null <- base::is.null
  [21:25:27.282]                         restarts <- computeRestarts(cond)
  [21:25:27.282]                         for (restart in restarts) {
  [21:25:27.282]                           name <- restart$name
  [21:25:27.282]                           if (is.null(name)) 
  [21:25:27.282]                             next
  [21:25:27.282]                           if (!grepl("^muffle", name)) 
  [21:25:27.282]                             next
  [21:25:27.282]                           invokeRestart(restart)
  [21:25:27.282]                           muffled <- TRUE
  [21:25:27.282]                           break
  [21:25:27.282]                         }
  [21:25:27.282]                       }
  [21:25:27.282]                       invisible(muffled)
  [21:25:27.282]                     }
  [21:25:27.282]                     muffleCondition(cond)
  [21:25:27.282]                   }
  [21:25:27.282]                 }
  [21:25:27.282]             }
  [21:25:27.282]         }))
  [21:25:27.282]     }, error = function(ex) {
  [21:25:27.282]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.282]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.282]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.282]     }, finally = {
  [21:25:27.282]         {
  [21:25:27.282]             NULL
  [21:25:27.282]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.282]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.282]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:27.282]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:27.282]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:27.282]                 ...) 
  [21:25:27.282]             {
  [21:25:27.282]                 if (substitute) 
  [21:25:27.282]                   expr <- substitute(expr)
  [21:25:27.282]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:27.282]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.282]                   globals = globals, persistent = persistent, 
  [21:25:27.282]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:27.282]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:27.282]                   label = label, ...)
  [21:25:27.282]                 if (!future$lazy) 
  [21:25:27.282]                   future <- run(future)
  [21:25:27.282]                 invisible(future)
  [21:25:27.282]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.282]         }
  [21:25:27.282]         base::options(...future.oldOptions)
  [21:25:27.282]     })
  [21:25:27.282]     Sys.time
  [21:25:27.282]     if (base::is.na(TRUE)) {
  [21:25:27.282]     }
  [21:25:27.282]     else {
  [21:25:27.282]         base::sink(type = "output", split = FALSE)
  [21:25:27.282]         if (TRUE) {
  [21:25:27.282]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.282]         }
  [21:25:27.282]         else {
  [21:25:27.282]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.282]         }
  [21:25:27.282]         base::close(...future.stdout)
  [21:25:27.282]         ...future.stdout <- NULL
  [21:25:27.282]     }
  [21:25:27.282]     ...future.result$conditions <- ...future.conditions
  [21:25:27.282]     ...future.result
  [21:25:27.282] }
  [21:25:27.288] ClusterFuture started
  [21:25:27.289] getGlobalsAndPackages() ...
  [21:25:27.289] Searching for globals...
  [21:25:27.290] 
  [21:25:27.290] Searching for globals ... DONE
  [21:25:27.290] - globals: [0] <none>
  [21:25:27.291] getGlobalsAndPackages() ... DONE
  [21:25:27.298] Packages needed by the future expression (n = 0): <none>
  [21:25:27.298] Packages needed by future strategies (n = 0): <none>
  [21:25:27.319] {
  [21:25:27.319]     {
  [21:25:27.319]         ...future.startTime <- base::Sys.time()
  [21:25:27.319]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.319]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.319]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.319]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.319]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.319]         {
  [21:25:27.319]             {
  [21:25:27.319]                 base::local({
  [21:25:27.319]                   has_future <- base::requireNamespace("future", 
  [21:25:27.319]                     quietly = TRUE)
  [21:25:27.319]                   version <- if (has_future) 
  [21:25:27.319]                     utils::packageVersion("future")
  [21:25:27.319]                   else NULL
  [21:25:27.319]                   if (!has_future || version < "1.8.0") {
  [21:25:27.319]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.319]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.319]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.319]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.319]                         "release", "version")], collapse = " "), 
  [21:25:27.319]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.319]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.319]                       info)
  [21:25:27.319]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.319]                     if (!has_future) {
  [21:25:27.319]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.319]                         info)
  [21:25:27.319]                     }
  [21:25:27.319]                     else {
  [21:25:27.319]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.319]                         info, version)
  [21:25:27.319]                     }
  [21:25:27.319]                     base::stop(msg)
  [21:25:27.319]                   }
  [21:25:27.319]                 })
  [21:25:27.319]             }
  [21:25:27.319]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.319]         }
  [21:25:27.319]     }
  [21:25:27.319]     if (base::is.na(TRUE)) {
  [21:25:27.319]     }
  [21:25:27.319]     else {
  [21:25:27.319]         if (TRUE) {
  [21:25:27.319]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.319]                 open = "w")
  [21:25:27.319]         }
  [21:25:27.319]         else {
  [21:25:27.319]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.319]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.319]         }
  [21:25:27.319]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.319]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.319]             base::sink(type = "output", split = FALSE)
  [21:25:27.319]             base::close(...future.stdout)
  [21:25:27.319]         }, add = TRUE)
  [21:25:27.319]     }
  [21:25:27.319]     ...future.frame <- base::sys.nframe()
  [21:25:27.319]     ...future.conditions <- base::list()
  [21:25:27.319]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.319]     ...future.result <- base::tryCatch({
  [21:25:27.319]         base::withCallingHandlers({
  [21:25:27.319]             ...future.value <- base::withVisible(base::local({
  [21:25:27.319]                 ...future.sendCondition <- local({
  [21:25:27.319]                   sendCondition <- NULL
  [21:25:27.319]                   function(frame = 1L) {
  [21:25:27.319]                     if (is.function(sendCondition)) 
  [21:25:27.319]                       return(sendCondition)
  [21:25:27.319]                     ns <- getNamespace("parallel")
  [21:25:27.319]                     if (exists("sendData", mode = "function", 
  [21:25:27.319]                       envir = ns)) {
  [21:25:27.319]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:27.319]                         envir = ns)
  [21:25:27.319]                       envir <- sys.frame(frame)
  [21:25:27.319]                       master <- NULL
  [21:25:27.319]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:27.319]                         !identical(envir, emptyenv())) {
  [21:25:27.319]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:27.319]                           inherits = FALSE)) {
  [21:25:27.319]                           master <- get("master", mode = "list", 
  [21:25:27.319]                             envir = envir, inherits = FALSE)
  [21:25:27.319]                           if (inherits(master, "SOCKnode")) {
  [21:25:27.319]                             sendCondition <<- function(cond) {
  [21:25:27.319]                               data <- list(type = "VALUE", value = cond, 
  [21:25:27.319]                                 success = TRUE)
  [21:25:27.319]                               parallel_sendData(master, data)
  [21:25:27.319]                             }
  [21:25:27.319]                             return(sendCondition)
  [21:25:27.319]                           }
  [21:25:27.319]                         }
  [21:25:27.319]                         frame <- frame + 1L
  [21:25:27.319]                         envir <- sys.frame(frame)
  [21:25:27.319]                       }
  [21:25:27.319]                     }
  [21:25:27.319]                     sendCondition <<- function(cond) NULL
  [21:25:27.319]                   }
  [21:25:27.319]                 })
  [21:25:27.319]                 withCallingHandlers({
  [21:25:27.319]                   NULL
  [21:25:27.319]                 }, immediateCondition = function(cond) {
  [21:25:27.319]                   sendCondition <- ...future.sendCondition()
  [21:25:27.319]                   sendCondition(cond)
  [21:25:27.319]                   muffleCondition <- function (cond) 
  [21:25:27.319]                   {
  [21:25:27.319]                     inherits <- base::inherits
  [21:25:27.319]                     invokeRestart <- base::invokeRestart
  [21:25:27.319]                     muffled <- FALSE
  [21:25:27.319]                     if (inherits(cond, "message")) {
  [21:25:27.319]                       invokeRestart("muffleMessage")
  [21:25:27.319]                       muffled <- TRUE
  [21:25:27.319]                     }
  [21:25:27.319]                     else if (inherits(cond, "warning")) {
  [21:25:27.319]                       invokeRestart("muffleWarning")
  [21:25:27.319]                       muffled <- TRUE
  [21:25:27.319]                     }
  [21:25:27.319]                     else if (inherits(cond, "condition")) {
  [21:25:27.319]                       computeRestarts <- base::computeRestarts
  [21:25:27.319]                       grepl <- base::grepl
  [21:25:27.319]                       is.null <- base::is.null
  [21:25:27.319]                       restarts <- computeRestarts(cond)
  [21:25:27.319]                       for (restart in restarts) {
  [21:25:27.319]                         name <- restart$name
  [21:25:27.319]                         if (is.null(name)) 
  [21:25:27.319]                           next
  [21:25:27.319]                         if (!grepl("^muffle", name)) 
  [21:25:27.319]                           next
  [21:25:27.319]                         invokeRestart(restart)
  [21:25:27.319]                         muffled <- TRUE
  [21:25:27.319]                         break
  [21:25:27.319]                       }
  [21:25:27.319]                     }
  [21:25:27.319]                     invisible(muffled)
  [21:25:27.319]                   }
  [21:25:27.319]                   muffleCondition(cond)
  [21:25:27.319]                 })
  [21:25:27.319]             }))
  [21:25:27.319]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.319]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.319]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.319]                 version = "1.8")
  [21:25:27.319]         }, condition = base::local({
  [21:25:27.319]             c <- base::c
  [21:25:27.319]             inherits <- base::inherits
  [21:25:27.319]             invokeRestart <- base::invokeRestart
  [21:25:27.319]             length <- base::length
  [21:25:27.319]             list <- base::list
  [21:25:27.319]             seq.int <- base::seq.int
  [21:25:27.319]             signalCondition <- base::signalCondition
  [21:25:27.319]             sys.calls <- base::sys.calls
  [21:25:27.319]             Sys.time <- base::Sys.time
  [21:25:27.319]             `[[` <- base::`[[`
  [21:25:27.319]             `+` <- base::`+`
  [21:25:27.319]             `<<-` <- base::`<<-`
  [21:25:27.319]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.319]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.319]                   3L)]
  [21:25:27.319]             }
  [21:25:27.319]             function(cond) {
  [21:25:27.319]                 if (inherits(cond, "error")) {
  [21:25:27.319]                   sessionInformation <- function() {
  [21:25:27.319]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.319]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.319]                       search = base::search(), system = base::Sys.info())
  [21:25:27.319]                   }
  [21:25:27.319]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.319]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.319]                     cond$call), session = sessionInformation(), 
  [21:25:27.319]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.319]                   signalCondition(cond)
  [21:25:27.319]                 }
  [21:25:27.319]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.319]                 ))) {
  [21:25:27.319]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.319]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.319]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.319]                   if (!signal) {
  [21:25:27.319]                     muffleCondition <- function (cond) 
  [21:25:27.319]                     {
  [21:25:27.319]                       inherits <- base::inherits
  [21:25:27.319]                       invokeRestart <- base::invokeRestart
  [21:25:27.319]                       muffled <- FALSE
  [21:25:27.319]                       if (inherits(cond, "message")) {
  [21:25:27.319]                         invokeRestart("muffleMessage")
  [21:25:27.319]                         muffled <- TRUE
  [21:25:27.319]                       }
  [21:25:27.319]                       else if (inherits(cond, "warning")) {
  [21:25:27.319]                         invokeRestart("muffleWarning")
  [21:25:27.319]                         muffled <- TRUE
  [21:25:27.319]                       }
  [21:25:27.319]                       else if (inherits(cond, "condition")) {
  [21:25:27.319]                         computeRestarts <- base::computeRestarts
  [21:25:27.319]                         grepl <- base::grepl
  [21:25:27.319]                         is.null <- base::is.null
  [21:25:27.319]                         restarts <- computeRestarts(cond)
  [21:25:27.319]                         for (restart in restarts) {
  [21:25:27.319]                           name <- restart$name
  [21:25:27.319]                           if (is.null(name)) 
  [21:25:27.319]                             next
  [21:25:27.319]                           if (!grepl("^muffle", name)) 
  [21:25:27.319]                             next
  [21:25:27.319]                           invokeRestart(restart)
  [21:25:27.319]                           muffled <- TRUE
  [21:25:27.319]                           break
  [21:25:27.319]                         }
  [21:25:27.319]                       }
  [21:25:27.319]                       invisible(muffled)
  [21:25:27.319]                     }
  [21:25:27.319]                     muffleCondition(cond)
  [21:25:27.319]                   }
  [21:25:27.319]                 }
  [21:25:27.319]             }
  [21:25:27.319]         }))
  [21:25:27.319]     }, error = function(ex) {
  [21:25:27.319]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.319]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.319]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.319]     }, finally = {
  [21:25:27.319]         {
  [21:25:27.319]             NULL
  [21:25:27.319]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.319]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.319]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:27.319]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:27.319]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:27.319]                 ...) 
  [21:25:27.319]             {
  [21:25:27.319]                 if (substitute) 
  [21:25:27.319]                   expr <- substitute(expr)
  [21:25:27.319]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:27.319]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.319]                   globals = globals, persistent = persistent, 
  [21:25:27.319]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:27.319]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:27.319]                   label = label, ...)
  [21:25:27.319]                 if (!future$lazy) 
  [21:25:27.319]                   future <- run(future)
  [21:25:27.319]                 invisible(future)
  [21:25:27.319]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.319]         }
  [21:25:27.319]         base::options(...future.oldOptions)
  [21:25:27.319]     })
  [21:25:27.319]     Sys.time
  [21:25:27.319]     if (base::is.na(TRUE)) {
  [21:25:27.319]     }
  [21:25:27.319]     else {
  [21:25:27.319]         base::sink(type = "output", split = FALSE)
  [21:25:27.319]         if (TRUE) {
  [21:25:27.319]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.319]         }
  [21:25:27.319]         else {
  [21:25:27.319]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.319]         }
  [21:25:27.319]         base::close(...future.stdout)
  [21:25:27.319]         ...future.stdout <- NULL
  [21:25:27.319]     }
  [21:25:27.319]     ...future.result$conditions <- ...future.conditions
  [21:25:27.319]     ...future.result
  [21:25:27.319] }
  [21:25:27.323] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:27.335] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:27.336] - Validating connection of ClusterFuture
  [21:25:27.336] - received message: FutureResult
  [21:25:27.336] - Received FutureResult
  [21:25:27.337] - Erased future from FutureRegistry
  [21:25:27.337] result() for ClusterFuture ...
  [21:25:27.337] - result already collected: FutureResult
  [21:25:27.338] result() for ClusterFuture ... done
  [21:25:27.338] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:27.338] result() for ClusterFuture ...
  [21:25:27.339] - result already collected: FutureResult
  [21:25:27.339] result() for ClusterFuture ... done
  [21:25:27.339] result() for ClusterFuture ...
  [21:25:27.340] - result already collected: FutureResult
  [21:25:27.340] result() for ClusterFuture ... done
  [21:25:27.342] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef2285aba8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22c47058> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef2285aba8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ef22c47058> 
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:4] 2 1 3 1
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  [21:25:27.386] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:27.386] - Validating connection of ClusterFuture
  [21:25:27.387] - received message: FutureResult
  [21:25:27.387] - Received FutureResult
  [21:25:27.387] - Erased future from FutureRegistry
  [21:25:27.388] result() for ClusterFuture ...
  [21:25:27.388] - result already collected: FutureResult
  [21:25:27.388] result() for ClusterFuture ... done
  [21:25:27.389] receiveMessageFromWorker() for ClusterFuture ... done
   logi [1:2, 1, 1:3, 1] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [21:25:27.394] resolve() on list ...
  [21:25:27.395]  recursive: 0
  [21:25:27.395]  length: 6
  [21:25:27.395]  elements: 'a', 'b', 'c', '', '', ''
  [21:25:27.396] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.396] - nx: 6
  [21:25:27.396] - relay: TRUE
  [21:25:27.396] - stdout: TRUE
  [21:25:27.397] - signal: TRUE
  [21:25:27.397] - resignal: FALSE
  [21:25:27.397] - force: TRUE
  [21:25:27.397] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.398] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.398]  - until=2
  [21:25:27.398]  - relaying element #2
  [21:25:27.399] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.399] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.399] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.399]  length: 5 (resolved future 1)
  [21:25:27.400] Future #2
  [21:25:27.400] result() for ClusterFuture ...
  [21:25:27.400] - result already collected: FutureResult
  [21:25:27.401] result() for ClusterFuture ... done
  [21:25:27.401] result() for ClusterFuture ...
  [21:25:27.401] - result already collected: FutureResult
  [21:25:27.401] result() for ClusterFuture ... done
  [21:25:27.402] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:27.402] - nx: 6
  [21:25:27.402] - relay: TRUE
  [21:25:27.403] - stdout: TRUE
  [21:25:27.403] - signal: TRUE
  [21:25:27.403] - resignal: FALSE
  [21:25:27.403] - force: TRUE
  [21:25:27.404] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.404] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.404]  - until=2
  [21:25:27.404]  - relaying element #2
  [21:25:27.405] result() for ClusterFuture ...
  [21:25:27.405] - result already collected: FutureResult
  [21:25:27.405] result() for ClusterFuture ... done
  [21:25:27.406] result() for ClusterFuture ...
  [21:25:27.406] - result already collected: FutureResult
  [21:25:27.406] result() for ClusterFuture ... done
  [21:25:27.407] result() for ClusterFuture ...
  [21:25:27.407] - result already collected: FutureResult
  [21:25:27.407] result() for ClusterFuture ... done
  [21:25:27.407] result() for ClusterFuture ...
  [21:25:27.408] - result already collected: FutureResult
  [21:25:27.408] result() for ClusterFuture ... done
  [21:25:27.408] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.409] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.409] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:27.409]  length: 4 (resolved future 2)
  [21:25:27.409] Future #3
  [21:25:27.410] result() for ClusterFuture ...
  [21:25:27.410] - result already collected: FutureResult
  [21:25:27.410] result() for ClusterFuture ... done
  [21:25:27.416] result() for ClusterFuture ...
  [21:25:27.417] - result already collected: FutureResult
  [21:25:27.417] result() for ClusterFuture ... done
  [21:25:27.417] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:27.418] - nx: 6
  [21:25:27.418] - relay: TRUE
  [21:25:27.421] - stdout: TRUE
  [21:25:27.422] - signal: TRUE
  [21:25:27.422] - resignal: FALSE
  [21:25:27.422] - force: TRUE
  [21:25:27.422] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.423] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:27.423]  - until=3
  [21:25:27.423]  - relaying element #3
  [21:25:27.423] result() for ClusterFuture ...
  [21:25:27.424] - result already collected: FutureResult
  [21:25:27.424] result() for ClusterFuture ... done
  [21:25:27.424] result() for ClusterFuture ...
  [21:25:27.425] - result already collected: FutureResult
  [21:25:27.425] result() for ClusterFuture ... done
  [21:25:27.425] result() for ClusterFuture ...
  [21:25:27.425] - result already collected: FutureResult
  [21:25:27.426] result() for ClusterFuture ... done
  [21:25:27.426] result() for ClusterFuture ...
  [21:25:27.426] - result already collected: FutureResult
  [21:25:27.427] result() for ClusterFuture ... done
  [21:25:27.427] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.427] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.427] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:27.428]  length: 3 (resolved future 3)
  [21:25:27.428] signalConditionsASAP(NULL, pos=4) ...
  [21:25:27.428] - nx: 6
  [21:25:27.428] - relay: TRUE
  [21:25:27.429] - stdout: TRUE
  [21:25:27.429] - signal: TRUE
  [21:25:27.429] - resignal: FALSE
  [21:25:27.429] - force: TRUE
  [21:25:27.430] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.430] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.431]  - until=5
  [21:25:27.431]  - relaying element #5
  [21:25:27.431] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:27.431] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.432] signalConditionsASAP(NULL, pos=4) ... done
  [21:25:27.432]  length: 2 (resolved future 4)
  [21:25:27.432] signalConditionsASAP(NULL, pos=5) ...
  [21:25:27.432] - nx: 6
  [21:25:27.433] - relay: TRUE
  [21:25:27.433] - stdout: TRUE
  [21:25:27.433] - signal: TRUE
  [21:25:27.433] - resignal: FALSE
  [21:25:27.434] - force: TRUE
  [21:25:27.434] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:27.434] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.435]  - until=6
  [21:25:27.435]  - relaying element #6
  [21:25:27.435] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:27.435] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.436] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:27.436]  length: 1 (resolved future 5)
  [21:25:27.436] signalConditionsASAP(numeric, pos=6) ...
  [21:25:27.436] - nx: 6
  [21:25:27.437] - relay: TRUE
  [21:25:27.437] - stdout: TRUE
  [21:25:27.437] - signal: TRUE
  [21:25:27.437] - resignal: FALSE
  [21:25:27.438] - force: TRUE
  [21:25:27.438] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:27.438] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.438]  - until=6
  [21:25:27.439] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.439] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.439] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:27.440]  length: 0 (resolved future 6)
  [21:25:27.440] Relaying remaining futures
  [21:25:27.440] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.440] - nx: 6
  [21:25:27.441] - relay: TRUE
  [21:25:27.441] - stdout: TRUE
  [21:25:27.441] - signal: TRUE
  [21:25:27.441] - resignal: FALSE
  [21:25:27.442] - force: TRUE
  [21:25:27.442] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.442] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [21:25:27.443] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:27.443] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:27.443] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.443] resolve() on list ... DONE
  [21:25:27.444] result() for ClusterFuture ...
  [21:25:27.444] - result already collected: FutureResult
  [21:25:27.444] result() for ClusterFuture ... done
  [21:25:27.444] result() for ClusterFuture ...
  [21:25:27.445] - result already collected: FutureResult
  [21:25:27.445] result() for ClusterFuture ... done
  [21:25:27.445] result() for ClusterFuture ...
  [21:25:27.446] - result already collected: FutureResult
  [21:25:27.446] result() for ClusterFuture ... done
  [21:25:27.446] result() for ClusterFuture ...
  [21:25:27.446] - result already collected: FutureResult
  [21:25:27.447] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
   - attr(*, "dim")= int [1:4] 2 1 3 1
   - attr(*, "dimnames")=List of 4
    ..$ : chr [1:2] "a" "b"
    ..$ : chr "a"
    ..$ : chr [1:3] "a" "b" "c"
    ..$ : chr "a"
  *** futures() - list ... DONE
  Type of object: environment
  Type of future: sequential
  [21:25:27.467] plan(): Setting new future strategy stack:
  [21:25:27.467] List of future strategies:
  [21:25:27.467] 1. sequential:
  [21:25:27.467]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.467]    - tweaked: FALSE
  [21:25:27.467]    - call: plan(strategy)
  [21:25:27.469] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [21:25:27.470] getGlobalsAndPackages() ...
  [21:25:27.470] Searching for globals...
  [21:25:27.471] 
  [21:25:27.471] Searching for globals ... DONE
  [21:25:27.471] - globals: [0] <none>
  [21:25:27.472] getGlobalsAndPackages() ... DONE
  [21:25:27.473] Packages needed by the future expression (n = 0): <none>
  [21:25:27.474] Packages needed by future strategies (n = 0): <none>
  [21:25:27.482] {
  [21:25:27.482]     {
  [21:25:27.482]         ...future.startTime <- base::Sys.time()
  [21:25:27.482]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.482]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.482]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.482]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.482]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.482]         {
  [21:25:27.482]             {
  [21:25:27.482]                 base::local({
  [21:25:27.482]                   has_future <- base::requireNamespace("future", 
  [21:25:27.482]                     quietly = TRUE)
  [21:25:27.482]                   version <- if (has_future) 
  [21:25:27.482]                     utils::packageVersion("future")
  [21:25:27.482]                   else NULL
  [21:25:27.482]                   if (!has_future || version < "1.8.0") {
  [21:25:27.482]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.482]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.482]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.482]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.482]                         "release", "version")], collapse = " "), 
  [21:25:27.482]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.482]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.482]                       info)
  [21:25:27.482]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.482]                     if (!has_future) {
  [21:25:27.482]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.482]                         info)
  [21:25:27.482]                     }
  [21:25:27.482]                     else {
  [21:25:27.482]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.482]                         info, version)
  [21:25:27.482]                     }
  [21:25:27.482]                     base::stop(msg)
  [21:25:27.482]                   }
  [21:25:27.482]                 })
  [21:25:27.482]             }
  [21:25:27.482]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.482]         }
  [21:25:27.482]     }
  [21:25:27.482]     if (base::is.na(TRUE)) {
  [21:25:27.482]     }
  [21:25:27.482]     else {
  [21:25:27.482]         if (TRUE) {
  [21:25:27.482]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.482]                 open = "w")
  [21:25:27.482]         }
  [21:25:27.482]         else {
  [21:25:27.482]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.482]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.482]         }
  [21:25:27.482]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.482]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.482]             base::sink(type = "output", split = FALSE)
  [21:25:27.482]             base::close(...future.stdout)
  [21:25:27.482]         }, add = TRUE)
  [21:25:27.482]     }
  [21:25:27.482]     ...future.frame <- base::sys.nframe()
  [21:25:27.482]     ...future.conditions <- base::list()
  [21:25:27.482]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.482]     ...future.result <- base::tryCatch({
  [21:25:27.482]         base::withCallingHandlers({
  [21:25:27.482]             ...future.value <- base::withVisible(base::local(2))
  [21:25:27.482]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.482]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.482]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.482]                 version = "1.8")
  [21:25:27.482]         }, condition = base::local({
  [21:25:27.482]             c <- base::c
  [21:25:27.482]             inherits <- base::inherits
  [21:25:27.482]             invokeRestart <- base::invokeRestart
  [21:25:27.482]             length <- base::length
  [21:25:27.482]             list <- base::list
  [21:25:27.482]             seq.int <- base::seq.int
  [21:25:27.482]             signalCondition <- base::signalCondition
  [21:25:27.482]             sys.calls <- base::sys.calls
  [21:25:27.482]             Sys.time <- base::Sys.time
  [21:25:27.482]             `[[` <- base::`[[`
  [21:25:27.482]             `+` <- base::`+`
  [21:25:27.482]             `<<-` <- base::`<<-`
  [21:25:27.482]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.482]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.482]                   3L)]
  [21:25:27.482]             }
  [21:25:27.482]             function(cond) {
  [21:25:27.482]                 if (inherits(cond, "error")) {
  [21:25:27.482]                   sessionInformation <- function() {
  [21:25:27.482]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.482]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.482]                       search = base::search(), system = base::Sys.info())
  [21:25:27.482]                   }
  [21:25:27.482]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.482]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.482]                     cond$call), session = sessionInformation(), 
  [21:25:27.482]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.482]                   signalCondition(cond)
  [21:25:27.482]                 }
  [21:25:27.482]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.482]                 ))) {
  [21:25:27.482]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.482]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.482]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.482]                   if (!signal) {
  [21:25:27.482]                     muffleCondition <- function (cond) 
  [21:25:27.482]                     {
  [21:25:27.482]                       inherits <- base::inherits
  [21:25:27.482]                       invokeRestart <- base::invokeRestart
  [21:25:27.482]                       muffled <- FALSE
  [21:25:27.482]                       if (inherits(cond, "message")) {
  [21:25:27.482]                         invokeRestart("muffleMessage")
  [21:25:27.482]                         muffled <- TRUE
  [21:25:27.482]                       }
  [21:25:27.482]                       else if (inherits(cond, "warning")) {
  [21:25:27.482]                         invokeRestart("muffleWarning")
  [21:25:27.482]                         muffled <- TRUE
  [21:25:27.482]                       }
  [21:25:27.482]                       else if (inherits(cond, "condition")) {
  [21:25:27.482]                         computeRestarts <- base::computeRestarts
  [21:25:27.482]                         grepl <- base::grepl
  [21:25:27.482]                         is.null <- base::is.null
  [21:25:27.482]                         restarts <- computeRestarts(cond)
  [21:25:27.482]                         for (restart in restarts) {
  [21:25:27.482]                           name <- restart$name
  [21:25:27.482]                           if (is.null(name)) 
  [21:25:27.482]                             next
  [21:25:27.482]                           if (!grepl("^muffle", name)) 
  [21:25:27.482]                             next
  [21:25:27.482]                           invokeRestart(restart)
  [21:25:27.482]                           muffled <- TRUE
  [21:25:27.482]                           break
  [21:25:27.482]                         }
  [21:25:27.482]                       }
  [21:25:27.482]                       invisible(muffled)
  [21:25:27.482]                     }
  [21:25:27.482]                     muffleCondition(cond)
  [21:25:27.482]                   }
  [21:25:27.482]                 }
  [21:25:27.482]             }
  [21:25:27.482]         }))
  [21:25:27.482]     }, error = function(ex) {
  [21:25:27.482]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.482]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.482]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.482]     }, finally = {
  [21:25:27.482]         {
  [21:25:27.482]             NULL
  [21:25:27.482]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.482]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.482]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.482]                 label = NULL, ...) 
  [21:25:27.482]             {
  [21:25:27.482]                 if (substitute) 
  [21:25:27.482]                   expr <- substitute(expr)
  [21:25:27.482]                 local <- as.logical(local)
  [21:25:27.482]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.482]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.482]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.482]                   label = label, ...)
  [21:25:27.482]                 if (!future$lazy) 
  [21:25:27.482]                   future <- run(future)
  [21:25:27.482]                 invisible(future)
  [21:25:27.482]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.482]         }
  [21:25:27.482]         base::options(...future.oldOptions)
  [21:25:27.482]     })
  [21:25:27.482]     Sys.time
  [21:25:27.482]     if (base::is.na(TRUE)) {
  [21:25:27.482]     }
  [21:25:27.482]     else {
  [21:25:27.482]         base::sink(type = "output", split = FALSE)
  [21:25:27.482]         if (TRUE) {
  [21:25:27.482]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.482]         }
  [21:25:27.482]         else {
  [21:25:27.482]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.482]         }
  [21:25:27.482]         base::close(...future.stdout)
  [21:25:27.482]         ...future.stdout <- NULL
  [21:25:27.482]     }
  [21:25:27.482]     ...future.result$conditions <- ...future.conditions
  [21:25:27.482]     ...future.result
  [21:25:27.482] }
  [21:25:27.486] plan(): Setting new future strategy stack:
  [21:25:27.487] List of future strategies:
  [21:25:27.487] 1. sequential:
  [21:25:27.487]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.487]    - tweaked: FALSE
  [21:25:27.487]    - call: NULL
  [21:25:27.488] plan(): nbrOfWorkers() = 1
  [21:25:27.489] plan(): Setting new future strategy stack:
  [21:25:27.489] List of future strategies:
  [21:25:27.489] 1. sequential:
  [21:25:27.489]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.489]    - tweaked: FALSE
  [21:25:27.489]    - call: plan(strategy)
  [21:25:27.490] plan(): nbrOfWorkers() = 1
  [21:25:27.490] SequentialFuture started (and completed)
  [21:25:27.491] getGlobalsAndPackages() ...
  [21:25:27.491] Searching for globals...
  [21:25:27.492] 
  [21:25:27.492] Searching for globals ... DONE
  [21:25:27.492] - globals: [0] <none>
  [21:25:27.493] getGlobalsAndPackages() ... DONE
  [21:25:27.494] Packages needed by the future expression (n = 0): <none>
  [21:25:27.495] Packages needed by future strategies (n = 0): <none>
  [21:25:27.499] {
  [21:25:27.499]     {
  [21:25:27.499]         ...future.startTime <- base::Sys.time()
  [21:25:27.499]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.499]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.499]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.499]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.499]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.499]         {
  [21:25:27.499]             {
  [21:25:27.499]                 base::local({
  [21:25:27.499]                   has_future <- base::requireNamespace("future", 
  [21:25:27.499]                     quietly = TRUE)
  [21:25:27.499]                   version <- if (has_future) 
  [21:25:27.499]                     utils::packageVersion("future")
  [21:25:27.499]                   else NULL
  [21:25:27.499]                   if (!has_future || version < "1.8.0") {
  [21:25:27.499]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.499]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.499]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.499]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.499]                         "release", "version")], collapse = " "), 
  [21:25:27.499]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.499]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.499]                       info)
  [21:25:27.499]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.499]                     if (!has_future) {
  [21:25:27.499]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.499]                         info)
  [21:25:27.499]                     }
  [21:25:27.499]                     else {
  [21:25:27.499]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.499]                         info, version)
  [21:25:27.499]                     }
  [21:25:27.499]                     base::stop(msg)
  [21:25:27.499]                   }
  [21:25:27.499]                 })
  [21:25:27.499]             }
  [21:25:27.499]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.499]         }
  [21:25:27.499]     }
  [21:25:27.499]     if (base::is.na(TRUE)) {
  [21:25:27.499]     }
  [21:25:27.499]     else {
  [21:25:27.499]         if (TRUE) {
  [21:25:27.499]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.499]                 open = "w")
  [21:25:27.499]         }
  [21:25:27.499]         else {
  [21:25:27.499]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.499]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.499]         }
  [21:25:27.499]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.499]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.499]             base::sink(type = "output", split = FALSE)
  [21:25:27.499]             base::close(...future.stdout)
  [21:25:27.499]         }, add = TRUE)
  [21:25:27.499]     }
  [21:25:27.499]     ...future.frame <- base::sys.nframe()
  [21:25:27.499]     ...future.conditions <- base::list()
  [21:25:27.499]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.499]     ...future.result <- base::tryCatch({
  [21:25:27.499]         base::withCallingHandlers({
  [21:25:27.499]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:27.499]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.499]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.499]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.499]                 version = "1.8")
  [21:25:27.499]         }, condition = base::local({
  [21:25:27.499]             c <- base::c
  [21:25:27.499]             inherits <- base::inherits
  [21:25:27.499]             invokeRestart <- base::invokeRestart
  [21:25:27.499]             length <- base::length
  [21:25:27.499]             list <- base::list
  [21:25:27.499]             seq.int <- base::seq.int
  [21:25:27.499]             signalCondition <- base::signalCondition
  [21:25:27.499]             sys.calls <- base::sys.calls
  [21:25:27.499]             Sys.time <- base::Sys.time
  [21:25:27.499]             `[[` <- base::`[[`
  [21:25:27.499]             `+` <- base::`+`
  [21:25:27.499]             `<<-` <- base::`<<-`
  [21:25:27.499]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.499]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.499]                   3L)]
  [21:25:27.499]             }
  [21:25:27.499]             function(cond) {
  [21:25:27.499]                 if (inherits(cond, "error")) {
  [21:25:27.499]                   sessionInformation <- function() {
  [21:25:27.499]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.499]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.499]                       search = base::search(), system = base::Sys.info())
  [21:25:27.499]                   }
  [21:25:27.499]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.499]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.499]                     cond$call), session = sessionInformation(), 
  [21:25:27.499]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.499]                   signalCondition(cond)
  [21:25:27.499]                 }
  [21:25:27.499]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.499]                 ))) {
  [21:25:27.499]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.499]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.499]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.499]                   if (!signal) {
  [21:25:27.499]                     muffleCondition <- function (cond) 
  [21:25:27.499]                     {
  [21:25:27.499]                       inherits <- base::inherits
  [21:25:27.499]                       invokeRestart <- base::invokeRestart
  [21:25:27.499]                       muffled <- FALSE
  [21:25:27.499]                       if (inherits(cond, "message")) {
  [21:25:27.499]                         invokeRestart("muffleMessage")
  [21:25:27.499]                         muffled <- TRUE
  [21:25:27.499]                       }
  [21:25:27.499]                       else if (inherits(cond, "warning")) {
  [21:25:27.499]                         invokeRestart("muffleWarning")
  [21:25:27.499]                         muffled <- TRUE
  [21:25:27.499]                       }
  [21:25:27.499]                       else if (inherits(cond, "condition")) {
  [21:25:27.499]                         computeRestarts <- base::computeRestarts
  [21:25:27.499]                         grepl <- base::grepl
  [21:25:27.499]                         is.null <- base::is.null
  [21:25:27.499]                         restarts <- computeRestarts(cond)
  [21:25:27.499]                         for (restart in restarts) {
  [21:25:27.499]                           name <- restart$name
  [21:25:27.499]                           if (is.null(name)) 
  [21:25:27.499]                             next
  [21:25:27.499]                           if (!grepl("^muffle", name)) 
  [21:25:27.499]                             next
  [21:25:27.499]                           invokeRestart(restart)
  [21:25:27.499]                           muffled <- TRUE
  [21:25:27.499]                           break
  [21:25:27.499]                         }
  [21:25:27.499]                       }
  [21:25:27.499]                       invisible(muffled)
  [21:25:27.499]                     }
  [21:25:27.499]                     muffleCondition(cond)
  [21:25:27.499]                   }
  [21:25:27.499]                 }
  [21:25:27.499]             }
  [21:25:27.499]         }))
  [21:25:27.499]     }, error = function(ex) {
  [21:25:27.499]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.499]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.499]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.499]     }, finally = {
  [21:25:27.499]         {
  [21:25:27.499]             NULL
  [21:25:27.499]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.499]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.499]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.499]                 label = NULL, ...) 
  [21:25:27.499]             {
  [21:25:27.499]                 if (substitute) 
  [21:25:27.499]                   expr <- substitute(expr)
  [21:25:27.499]                 local <- as.logical(local)
  [21:25:27.499]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.499]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.499]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.499]                   label = label, ...)
  [21:25:27.499]                 if (!future$lazy) 
  [21:25:27.499]                   future <- run(future)
  [21:25:27.499]                 invisible(future)
  [21:25:27.499]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.499]         }
  [21:25:27.499]         base::options(...future.oldOptions)
  [21:25:27.499]     })
  [21:25:27.499]     Sys.time
  [21:25:27.499]     if (base::is.na(TRUE)) {
  [21:25:27.499]     }
  [21:25:27.499]     else {
  [21:25:27.499]         base::sink(type = "output", split = FALSE)
  [21:25:27.499]         if (TRUE) {
  [21:25:27.499]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.499]         }
  [21:25:27.499]         else {
  [21:25:27.499]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.499]         }
  [21:25:27.499]         base::close(...future.stdout)
  [21:25:27.499]         ...future.stdout <- NULL
  [21:25:27.499]     }
  [21:25:27.499]     ...future.result$conditions <- ...future.conditions
  [21:25:27.499]     ...future.result
  [21:25:27.499] }
  [21:25:27.510] plan(): Setting new future strategy stack:
  [21:25:27.511] List of future strategies:
  [21:25:27.511] 1. sequential:
  [21:25:27.511]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.511]    - tweaked: FALSE
  [21:25:27.511]    - call: NULL
  [21:25:27.512] plan(): nbrOfWorkers() = 1
  [21:25:27.513] plan(): Setting new future strategy stack:
  [21:25:27.513] List of future strategies:
  [21:25:27.513] 1. sequential:
  [21:25:27.513]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.513]    - tweaked: FALSE
  [21:25:27.513]    - call: plan(strategy)
  [21:25:27.514] plan(): nbrOfWorkers() = 1
  [21:25:27.514] SequentialFuture started (and completed)
  [21:25:27.517] getGlobalsAndPackages() ...
  [21:25:27.518] Searching for globals...
  [21:25:27.522] - globals found: [1] '{'
  [21:25:27.523] Searching for globals ... DONE
  [21:25:27.523] Resolving globals: FALSE
  [21:25:27.524] 
  [21:25:27.524] 
  [21:25:27.525] getGlobalsAndPackages() ... DONE
  [21:25:27.526] Packages needed by the future expression (n = 0): <none>
  [21:25:27.527] Packages needed by future strategies (n = 0): <none>
  [21:25:27.531] {
  [21:25:27.531]     {
  [21:25:27.531]         ...future.startTime <- base::Sys.time()
  [21:25:27.531]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.531]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.531]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.531]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.531]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.531]         {
  [21:25:27.531]             {
  [21:25:27.531]                 base::local({
  [21:25:27.531]                   has_future <- base::requireNamespace("future", 
  [21:25:27.531]                     quietly = TRUE)
  [21:25:27.531]                   version <- if (has_future) 
  [21:25:27.531]                     utils::packageVersion("future")
  [21:25:27.531]                   else NULL
  [21:25:27.531]                   if (!has_future || version < "1.8.0") {
  [21:25:27.531]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.531]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.531]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.531]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.531]                         "release", "version")], collapse = " "), 
  [21:25:27.531]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.531]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.531]                       info)
  [21:25:27.531]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.531]                     if (!has_future) {
  [21:25:27.531]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.531]                         info)
  [21:25:27.531]                     }
  [21:25:27.531]                     else {
  [21:25:27.531]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.531]                         info, version)
  [21:25:27.531]                     }
  [21:25:27.531]                     base::stop(msg)
  [21:25:27.531]                   }
  [21:25:27.531]                 })
  [21:25:27.531]             }
  [21:25:27.531]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.531]         }
  [21:25:27.531]     }
  [21:25:27.531]     if (base::is.na(TRUE)) {
  [21:25:27.531]     }
  [21:25:27.531]     else {
  [21:25:27.531]         if (TRUE) {
  [21:25:27.531]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.531]                 open = "w")
  [21:25:27.531]         }
  [21:25:27.531]         else {
  [21:25:27.531]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.531]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.531]         }
  [21:25:27.531]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.531]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.531]             base::sink(type = "output", split = FALSE)
  [21:25:27.531]             base::close(...future.stdout)
  [21:25:27.531]         }, add = TRUE)
  [21:25:27.531]     }
  [21:25:27.531]     ...future.frame <- base::sys.nframe()
  [21:25:27.531]     ...future.conditions <- base::list()
  [21:25:27.531]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.531]     ...future.result <- base::tryCatch({
  [21:25:27.531]         base::withCallingHandlers({
  [21:25:27.531]             ...future.value <- base::withVisible(base::local({
  [21:25:27.531]                 4
  [21:25:27.531]             }))
  [21:25:27.531]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.531]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.531]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.531]                 version = "1.8")
  [21:25:27.531]         }, condition = base::local({
  [21:25:27.531]             c <- base::c
  [21:25:27.531]             inherits <- base::inherits
  [21:25:27.531]             invokeRestart <- base::invokeRestart
  [21:25:27.531]             length <- base::length
  [21:25:27.531]             list <- base::list
  [21:25:27.531]             seq.int <- base::seq.int
  [21:25:27.531]             signalCondition <- base::signalCondition
  [21:25:27.531]             sys.calls <- base::sys.calls
  [21:25:27.531]             Sys.time <- base::Sys.time
  [21:25:27.531]             `[[` <- base::`[[`
  [21:25:27.531]             `+` <- base::`+`
  [21:25:27.531]             `<<-` <- base::`<<-`
  [21:25:27.531]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.531]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.531]                   3L)]
  [21:25:27.531]             }
  [21:25:27.531]             function(cond) {
  [21:25:27.531]                 if (inherits(cond, "error")) {
  [21:25:27.531]                   sessionInformation <- function() {
  [21:25:27.531]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.531]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.531]                       search = base::search(), system = base::Sys.info())
  [21:25:27.531]                   }
  [21:25:27.531]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.531]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.531]                     cond$call), session = sessionInformation(), 
  [21:25:27.531]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.531]                   signalCondition(cond)
  [21:25:27.531]                 }
  [21:25:27.531]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.531]                 ))) {
  [21:25:27.531]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.531]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.531]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.531]                   if (!signal) {
  [21:25:27.531]                     muffleCondition <- function (cond) 
  [21:25:27.531]                     {
  [21:25:27.531]                       inherits <- base::inherits
  [21:25:27.531]                       invokeRestart <- base::invokeRestart
  [21:25:27.531]                       muffled <- FALSE
  [21:25:27.531]                       if (inherits(cond, "message")) {
  [21:25:27.531]                         invokeRestart("muffleMessage")
  [21:25:27.531]                         muffled <- TRUE
  [21:25:27.531]                       }
  [21:25:27.531]                       else if (inherits(cond, "warning")) {
  [21:25:27.531]                         invokeRestart("muffleWarning")
  [21:25:27.531]                         muffled <- TRUE
  [21:25:27.531]                       }
  [21:25:27.531]                       else if (inherits(cond, "condition")) {
  [21:25:27.531]                         computeRestarts <- base::computeRestarts
  [21:25:27.531]                         grepl <- base::grepl
  [21:25:27.531]                         is.null <- base::is.null
  [21:25:27.531]                         restarts <- computeRestarts(cond)
  [21:25:27.531]                         for (restart in restarts) {
  [21:25:27.531]                           name <- restart$name
  [21:25:27.531]                           if (is.null(name)) 
  [21:25:27.531]                             next
  [21:25:27.531]                           if (!grepl("^muffle", name)) 
  [21:25:27.531]                             next
  [21:25:27.531]                           invokeRestart(restart)
  [21:25:27.531]                           muffled <- TRUE
  [21:25:27.531]                           break
  [21:25:27.531]                         }
  [21:25:27.531]                       }
  [21:25:27.531]                       invisible(muffled)
  [21:25:27.531]                     }
  [21:25:27.531]                     muffleCondition(cond)
  [21:25:27.531]                   }
  [21:25:27.531]                 }
  [21:25:27.531]             }
  [21:25:27.531]         }))
  [21:25:27.531]     }, error = function(ex) {
  [21:25:27.531]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.531]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.531]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.531]     }, finally = {
  [21:25:27.531]         {
  [21:25:27.531]             NULL
  [21:25:27.531]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.531]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.531]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.531]                 label = NULL, ...) 
  [21:25:27.531]             {
  [21:25:27.531]                 if (substitute) 
  [21:25:27.531]                   expr <- substitute(expr)
  [21:25:27.531]                 local <- as.logical(local)
  [21:25:27.531]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.531]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.531]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.531]                   label = label, ...)
  [21:25:27.531]                 if (!future$lazy) 
  [21:25:27.531]                   future <- run(future)
  [21:25:27.531]                 invisible(future)
  [21:25:27.531]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.531]         }
  [21:25:27.531]         base::options(...future.oldOptions)
  [21:25:27.531]     })
  [21:25:27.531]     Sys.time
  [21:25:27.531]     if (base::is.na(TRUE)) {
  [21:25:27.531]     }
  [21:25:27.531]     else {
  [21:25:27.531]         base::sink(type = "output", split = FALSE)
  [21:25:27.531]         if (TRUE) {
  [21:25:27.531]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.531]         }
  [21:25:27.531]         else {
  [21:25:27.531]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.531]         }
  [21:25:27.531]         base::close(...future.stdout)
  [21:25:27.531]         ...future.stdout <- NULL
  [21:25:27.531]     }
  [21:25:27.531]     ...future.result$conditions <- ...future.conditions
  [21:25:27.531]     ...future.result
  [21:25:27.531] }
  [21:25:27.536] plan(): Setting new future strategy stack:
  [21:25:27.536] List of future strategies:
  [21:25:27.536] 1. sequential:
  [21:25:27.536]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.536]    - tweaked: FALSE
  [21:25:27.536]    - call: NULL
  [21:25:27.537] plan(): nbrOfWorkers() = 1
  [21:25:27.538] plan(): Setting new future strategy stack:
  [21:25:27.538] List of future strategies:
  [21:25:27.538] 1. sequential:
  [21:25:27.538]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.538]    - tweaked: FALSE
  [21:25:27.538]    - call: plan(strategy)
  [21:25:27.539] plan(): nbrOfWorkers() = 1
  [21:25:27.540] SequentialFuture started (and completed)
  <environment: 0x55ef229afc98> 
  <environment: 0x55ef228f4b08> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:27.547] resolve() on environment ...
  [21:25:27.547]  recursive: 0
  [21:25:27.548]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:27.549] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.549] - nx: 4
  [21:25:27.549] - relay: TRUE
  [21:25:27.549] - stdout: TRUE
  [21:25:27.550] - signal: TRUE
  [21:25:27.550] - resignal: FALSE
  [21:25:27.550] - force: TRUE
  [21:25:27.550] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.551] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.551]  - until=2
  [21:25:27.551]  - relaying element #2
  [21:25:27.551] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.552] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.552] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.552]  length: 3 (resolved future 1)
  [21:25:27.553] Future #2
  [21:25:27.553] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:27.553] - nx: 4
  [21:25:27.554] - relay: TRUE
  [21:25:27.554] - stdout: TRUE
  [21:25:27.554] - signal: TRUE
  [21:25:27.554] - resignal: FALSE
  [21:25:27.598] - force: TRUE
  [21:25:27.599] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.599] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.599]  - until=2
  [21:25:27.599]  - relaying element #2
  [21:25:27.600] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.600] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.601] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:27.601]  length: 2 (resolved future 2)
  [21:25:27.601] Future #3
  [21:25:27.602] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:27.602] - nx: 4
  [21:25:27.602] - relay: TRUE
  [21:25:27.602] - stdout: TRUE
  [21:25:27.603] - signal: TRUE
  [21:25:27.603] - resignal: FALSE
  [21:25:27.603] - force: TRUE
  [21:25:27.604] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.604] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.604]  - until=3
  [21:25:27.604]  - relaying element #3
  [21:25:27.605] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.605] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.606] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:27.606]  length: 1 (resolved future 3)
  [21:25:27.606] Future #4
  [21:25:27.607] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:27.607] - nx: 4
  [21:25:27.607] - relay: TRUE
  [21:25:27.607] - stdout: TRUE
  [21:25:27.608] - signal: TRUE
  [21:25:27.608] - resignal: FALSE
  [21:25:27.608] - force: TRUE
  [21:25:27.608] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.609] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.609]  - until=4
  [21:25:27.609]  - relaying element #4
  [21:25:27.610] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.610] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.610] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:27.611]  length: 0 (resolved future 4)
  [21:25:27.611] Relaying remaining futures
  [21:25:27.611] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.612] - nx: 4
  [21:25:27.612] - relay: TRUE
  [21:25:27.612] - stdout: TRUE
  [21:25:27.612] - signal: TRUE
  [21:25:27.613] - resignal: FALSE
  [21:25:27.613] - force: TRUE
  [21:25:27.613] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.613] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:27.614] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.614] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.614] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.615] resolve() on environment ... DONE
  <environment: 0x55ef229aeae0> 
  Dimensions: c(1, 6)
  [21:25:27.616] getGlobalsAndPackages() ...
  [21:25:27.616] Searching for globals...
  [21:25:27.617] 
  [21:25:27.617] Searching for globals ... DONE
  [21:25:27.618] - globals: [0] <none>
  [21:25:27.618] getGlobalsAndPackages() ... DONE
  [21:25:27.620] Packages needed by the future expression (n = 0): <none>
  [21:25:27.620] Packages needed by future strategies (n = 0): <none>
  [21:25:27.625] {
  [21:25:27.625]     {
  [21:25:27.625]         ...future.startTime <- base::Sys.time()
  [21:25:27.625]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.625]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.625]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.625]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.625]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.625]         {
  [21:25:27.625]             {
  [21:25:27.625]                 base::local({
  [21:25:27.625]                   has_future <- base::requireNamespace("future", 
  [21:25:27.625]                     quietly = TRUE)
  [21:25:27.625]                   version <- if (has_future) 
  [21:25:27.625]                     utils::packageVersion("future")
  [21:25:27.625]                   else NULL
  [21:25:27.625]                   if (!has_future || version < "1.8.0") {
  [21:25:27.625]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.625]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.625]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.625]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.625]                         "release", "version")], collapse = " "), 
  [21:25:27.625]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.625]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.625]                       info)
  [21:25:27.625]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.625]                     if (!has_future) {
  [21:25:27.625]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.625]                         info)
  [21:25:27.625]                     }
  [21:25:27.625]                     else {
  [21:25:27.625]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.625]                         info, version)
  [21:25:27.625]                     }
  [21:25:27.625]                     base::stop(msg)
  [21:25:27.625]                   }
  [21:25:27.625]                 })
  [21:25:27.625]             }
  [21:25:27.625]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.625]         }
  [21:25:27.625]     }
  [21:25:27.625]     if (base::is.na(TRUE)) {
  [21:25:27.625]     }
  [21:25:27.625]     else {
  [21:25:27.625]         if (TRUE) {
  [21:25:27.625]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.625]                 open = "w")
  [21:25:27.625]         }
  [21:25:27.625]         else {
  [21:25:27.625]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.625]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.625]         }
  [21:25:27.625]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.625]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.625]             base::sink(type = "output", split = FALSE)
  [21:25:27.625]             base::close(...future.stdout)
  [21:25:27.625]         }, add = TRUE)
  [21:25:27.625]     }
  [21:25:27.625]     ...future.frame <- base::sys.nframe()
  [21:25:27.625]     ...future.conditions <- base::list()
  [21:25:27.625]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.625]     ...future.result <- base::tryCatch({
  [21:25:27.625]         base::withCallingHandlers({
  [21:25:27.625]             ...future.value <- base::withVisible(base::local(2))
  [21:25:27.625]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.625]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.625]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.625]                 version = "1.8")
  [21:25:27.625]         }, condition = base::local({
  [21:25:27.625]             c <- base::c
  [21:25:27.625]             inherits <- base::inherits
  [21:25:27.625]             invokeRestart <- base::invokeRestart
  [21:25:27.625]             length <- base::length
  [21:25:27.625]             list <- base::list
  [21:25:27.625]             seq.int <- base::seq.int
  [21:25:27.625]             signalCondition <- base::signalCondition
  [21:25:27.625]             sys.calls <- base::sys.calls
  [21:25:27.625]             Sys.time <- base::Sys.time
  [21:25:27.625]             `[[` <- base::`[[`
  [21:25:27.625]             `+` <- base::`+`
  [21:25:27.625]             `<<-` <- base::`<<-`
  [21:25:27.625]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.625]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.625]                   3L)]
  [21:25:27.625]             }
  [21:25:27.625]             function(cond) {
  [21:25:27.625]                 if (inherits(cond, "error")) {
  [21:25:27.625]                   sessionInformation <- function() {
  [21:25:27.625]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.625]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.625]                       search = base::search(), system = base::Sys.info())
  [21:25:27.625]                   }
  [21:25:27.625]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.625]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.625]                     cond$call), session = sessionInformation(), 
  [21:25:27.625]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.625]                   signalCondition(cond)
  [21:25:27.625]                 }
  [21:25:27.625]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.625]                 ))) {
  [21:25:27.625]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.625]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.625]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.625]                   if (!signal) {
  [21:25:27.625]                     muffleCondition <- function (cond) 
  [21:25:27.625]                     {
  [21:25:27.625]                       inherits <- base::inherits
  [21:25:27.625]                       invokeRestart <- base::invokeRestart
  [21:25:27.625]                       muffled <- FALSE
  [21:25:27.625]                       if (inherits(cond, "message")) {
  [21:25:27.625]                         invokeRestart("muffleMessage")
  [21:25:27.625]                         muffled <- TRUE
  [21:25:27.625]                       }
  [21:25:27.625]                       else if (inherits(cond, "warning")) {
  [21:25:27.625]                         invokeRestart("muffleWarning")
  [21:25:27.625]                         muffled <- TRUE
  [21:25:27.625]                       }
  [21:25:27.625]                       else if (inherits(cond, "condition")) {
  [21:25:27.625]                         computeRestarts <- base::computeRestarts
  [21:25:27.625]                         grepl <- base::grepl
  [21:25:27.625]                         is.null <- base::is.null
  [21:25:27.625]                         restarts <- computeRestarts(cond)
  [21:25:27.625]                         for (restart in restarts) {
  [21:25:27.625]                           name <- restart$name
  [21:25:27.625]                           if (is.null(name)) 
  [21:25:27.625]                             next
  [21:25:27.625]                           if (!grepl("^muffle", name)) 
  [21:25:27.625]                             next
  [21:25:27.625]                           invokeRestart(restart)
  [21:25:27.625]                           muffled <- TRUE
  [21:25:27.625]                           break
  [21:25:27.625]                         }
  [21:25:27.625]                       }
  [21:25:27.625]                       invisible(muffled)
  [21:25:27.625]                     }
  [21:25:27.625]                     muffleCondition(cond)
  [21:25:27.625]                   }
  [21:25:27.625]                 }
  [21:25:27.625]             }
  [21:25:27.625]         }))
  [21:25:27.625]     }, error = function(ex) {
  [21:25:27.625]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.625]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.625]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.625]     }, finally = {
  [21:25:27.625]         {
  [21:25:27.625]             NULL
  [21:25:27.625]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.625]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.625]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.625]                 label = NULL, ...) 
  [21:25:27.625]             {
  [21:25:27.625]                 if (substitute) 
  [21:25:27.625]                   expr <- substitute(expr)
  [21:25:27.625]                 local <- as.logical(local)
  [21:25:27.625]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.625]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.625]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.625]                   label = label, ...)
  [21:25:27.625]                 if (!future$lazy) 
  [21:25:27.625]                   future <- run(future)
  [21:25:27.625]                 invisible(future)
  [21:25:27.625]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.625]         }
  [21:25:27.625]         base::options(...future.oldOptions)
  [21:25:27.625]     })
  [21:25:27.625]     Sys.time
  [21:25:27.625]     if (base::is.na(TRUE)) {
  [21:25:27.625]     }
  [21:25:27.625]     else {
  [21:25:27.625]         base::sink(type = "output", split = FALSE)
  [21:25:27.625]         if (TRUE) {
  [21:25:27.625]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.625]         }
  [21:25:27.625]         else {
  [21:25:27.625]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.625]         }
  [21:25:27.625]         base::close(...future.stdout)
  [21:25:27.625]         ...future.stdout <- NULL
  [21:25:27.625]     }
  [21:25:27.625]     ...future.result$conditions <- ...future.conditions
  [21:25:27.625]     ...future.result
  [21:25:27.625] }
  [21:25:27.629] plan(): Setting new future strategy stack:
  [21:25:27.630] List of future strategies:
  [21:25:27.630] 1. sequential:
  [21:25:27.630]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.630]    - tweaked: FALSE
  [21:25:27.630]    - call: NULL
  [21:25:27.631] plan(): nbrOfWorkers() = 1
  [21:25:27.632] plan(): Setting new future strategy stack:
  [21:25:27.632] List of future strategies:
  [21:25:27.632] 1. sequential:
  [21:25:27.632]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.632]    - tweaked: FALSE
  [21:25:27.632]    - call: plan(strategy)
  [21:25:27.633] plan(): nbrOfWorkers() = 1
  [21:25:27.633] SequentialFuture started (and completed)
  [21:25:27.634] getGlobalsAndPackages() ...
  [21:25:27.634] Searching for globals...
  [21:25:27.635] 
  [21:25:27.635] Searching for globals ... DONE
  [21:25:27.635] - globals: [0] <none>
  [21:25:27.636] getGlobalsAndPackages() ... DONE
  [21:25:27.637] Packages needed by the future expression (n = 0): <none>
  [21:25:27.638] Packages needed by future strategies (n = 0): <none>
  [21:25:27.642] {
  [21:25:27.642]     {
  [21:25:27.642]         ...future.startTime <- base::Sys.time()
  [21:25:27.642]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.642]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.642]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.642]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.642]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.642]         {
  [21:25:27.642]             {
  [21:25:27.642]                 base::local({
  [21:25:27.642]                   has_future <- base::requireNamespace("future", 
  [21:25:27.642]                     quietly = TRUE)
  [21:25:27.642]                   version <- if (has_future) 
  [21:25:27.642]                     utils::packageVersion("future")
  [21:25:27.642]                   else NULL
  [21:25:27.642]                   if (!has_future || version < "1.8.0") {
  [21:25:27.642]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.642]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.642]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.642]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.642]                         "release", "version")], collapse = " "), 
  [21:25:27.642]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.642]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.642]                       info)
  [21:25:27.642]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.642]                     if (!has_future) {
  [21:25:27.642]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.642]                         info)
  [21:25:27.642]                     }
  [21:25:27.642]                     else {
  [21:25:27.642]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.642]                         info, version)
  [21:25:27.642]                     }
  [21:25:27.642]                     base::stop(msg)
  [21:25:27.642]                   }
  [21:25:27.642]                 })
  [21:25:27.642]             }
  [21:25:27.642]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.642]         }
  [21:25:27.642]     }
  [21:25:27.642]     if (base::is.na(TRUE)) {
  [21:25:27.642]     }
  [21:25:27.642]     else {
  [21:25:27.642]         if (TRUE) {
  [21:25:27.642]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.642]                 open = "w")
  [21:25:27.642]         }
  [21:25:27.642]         else {
  [21:25:27.642]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.642]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.642]         }
  [21:25:27.642]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.642]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.642]             base::sink(type = "output", split = FALSE)
  [21:25:27.642]             base::close(...future.stdout)
  [21:25:27.642]         }, add = TRUE)
  [21:25:27.642]     }
  [21:25:27.642]     ...future.frame <- base::sys.nframe()
  [21:25:27.642]     ...future.conditions <- base::list()
  [21:25:27.642]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.642]     ...future.result <- base::tryCatch({
  [21:25:27.642]         base::withCallingHandlers({
  [21:25:27.642]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:27.642]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.642]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.642]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.642]                 version = "1.8")
  [21:25:27.642]         }, condition = base::local({
  [21:25:27.642]             c <- base::c
  [21:25:27.642]             inherits <- base::inherits
  [21:25:27.642]             invokeRestart <- base::invokeRestart
  [21:25:27.642]             length <- base::length
  [21:25:27.642]             list <- base::list
  [21:25:27.642]             seq.int <- base::seq.int
  [21:25:27.642]             signalCondition <- base::signalCondition
  [21:25:27.642]             sys.calls <- base::sys.calls
  [21:25:27.642]             Sys.time <- base::Sys.time
  [21:25:27.642]             `[[` <- base::`[[`
  [21:25:27.642]             `+` <- base::`+`
  [21:25:27.642]             `<<-` <- base::`<<-`
  [21:25:27.642]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.642]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.642]                   3L)]
  [21:25:27.642]             }
  [21:25:27.642]             function(cond) {
  [21:25:27.642]                 if (inherits(cond, "error")) {
  [21:25:27.642]                   sessionInformation <- function() {
  [21:25:27.642]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.642]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.642]                       search = base::search(), system = base::Sys.info())
  [21:25:27.642]                   }
  [21:25:27.642]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.642]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.642]                     cond$call), session = sessionInformation(), 
  [21:25:27.642]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.642]                   signalCondition(cond)
  [21:25:27.642]                 }
  [21:25:27.642]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.642]                 ))) {
  [21:25:27.642]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.642]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.642]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.642]                   if (!signal) {
  [21:25:27.642]                     muffleCondition <- function (cond) 
  [21:25:27.642]                     {
  [21:25:27.642]                       inherits <- base::inherits
  [21:25:27.642]                       invokeRestart <- base::invokeRestart
  [21:25:27.642]                       muffled <- FALSE
  [21:25:27.642]                       if (inherits(cond, "message")) {
  [21:25:27.642]                         invokeRestart("muffleMessage")
  [21:25:27.642]                         muffled <- TRUE
  [21:25:27.642]                       }
  [21:25:27.642]                       else if (inherits(cond, "warning")) {
  [21:25:27.642]                         invokeRestart("muffleWarning")
  [21:25:27.642]                         muffled <- TRUE
  [21:25:27.642]                       }
  [21:25:27.642]                       else if (inherits(cond, "condition")) {
  [21:25:27.642]                         computeRestarts <- base::computeRestarts
  [21:25:27.642]                         grepl <- base::grepl
  [21:25:27.642]                         is.null <- base::is.null
  [21:25:27.642]                         restarts <- computeRestarts(cond)
  [21:25:27.642]                         for (restart in restarts) {
  [21:25:27.642]                           name <- restart$name
  [21:25:27.642]                           if (is.null(name)) 
  [21:25:27.642]                             next
  [21:25:27.642]                           if (!grepl("^muffle", name)) 
  [21:25:27.642]                             next
  [21:25:27.642]                           invokeRestart(restart)
  [21:25:27.642]                           muffled <- TRUE
  [21:25:27.642]                           break
  [21:25:27.642]                         }
  [21:25:27.642]                       }
  [21:25:27.642]                       invisible(muffled)
  [21:25:27.642]                     }
  [21:25:27.642]                     muffleCondition(cond)
  [21:25:27.642]                   }
  [21:25:27.642]                 }
  [21:25:27.642]             }
  [21:25:27.642]         }))
  [21:25:27.642]     }, error = function(ex) {
  [21:25:27.642]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.642]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.642]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.642]     }, finally = {
  [21:25:27.642]         {
  [21:25:27.642]             NULL
  [21:25:27.642]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.642]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.642]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.642]                 label = NULL, ...) 
  [21:25:27.642]             {
  [21:25:27.642]                 if (substitute) 
  [21:25:27.642]                   expr <- substitute(expr)
  [21:25:27.642]                 local <- as.logical(local)
  [21:25:27.642]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.642]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.642]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.642]                   label = label, ...)
  [21:25:27.642]                 if (!future$lazy) 
  [21:25:27.642]                   future <- run(future)
  [21:25:27.642]                 invisible(future)
  [21:25:27.642]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.642]         }
  [21:25:27.642]         base::options(...future.oldOptions)
  [21:25:27.642]     })
  [21:25:27.642]     Sys.time
  [21:25:27.642]     if (base::is.na(TRUE)) {
  [21:25:27.642]     }
  [21:25:27.642]     else {
  [21:25:27.642]         base::sink(type = "output", split = FALSE)
  [21:25:27.642]         if (TRUE) {
  [21:25:27.642]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.642]         }
  [21:25:27.642]         else {
  [21:25:27.642]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.642]         }
  [21:25:27.642]         base::close(...future.stdout)
  [21:25:27.642]         ...future.stdout <- NULL
  [21:25:27.642]     }
  [21:25:27.642]     ...future.result$conditions <- ...future.conditions
  [21:25:27.642]     ...future.result
  [21:25:27.642] }
  [21:25:27.647] plan(): Setting new future strategy stack:
  [21:25:27.647] List of future strategies:
  [21:25:27.647] 1. sequential:
  [21:25:27.647]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.647]    - tweaked: FALSE
  [21:25:27.647]    - call: NULL
  [21:25:27.648] plan(): nbrOfWorkers() = 1
  [21:25:27.649] plan(): Setting new future strategy stack:
  [21:25:27.649] List of future strategies:
  [21:25:27.649] 1. sequential:
  [21:25:27.649]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.649]    - tweaked: FALSE
  [21:25:27.649]    - call: plan(strategy)
  [21:25:27.650] plan(): nbrOfWorkers() = 1
  [21:25:27.651] SequentialFuture started (and completed)
  [21:25:27.652] getGlobalsAndPackages() ...
  [21:25:27.652] Searching for globals...
  [21:25:27.653] - globals found: [1] '{'
  [21:25:27.654] Searching for globals ... DONE
  [21:25:27.654] Resolving globals: FALSE
  [21:25:27.655] 
  [21:25:27.655] 
  [21:25:27.655] getGlobalsAndPackages() ... DONE
  [21:25:27.657] Packages needed by the future expression (n = 0): <none>
  [21:25:27.657] Packages needed by future strategies (n = 0): <none>
  [21:25:27.662] {
  [21:25:27.662]     {
  [21:25:27.662]         ...future.startTime <- base::Sys.time()
  [21:25:27.662]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.662]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.662]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.662]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.662]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.662]         {
  [21:25:27.662]             {
  [21:25:27.662]                 base::local({
  [21:25:27.662]                   has_future <- base::requireNamespace("future", 
  [21:25:27.662]                     quietly = TRUE)
  [21:25:27.662]                   version <- if (has_future) 
  [21:25:27.662]                     utils::packageVersion("future")
  [21:25:27.662]                   else NULL
  [21:25:27.662]                   if (!has_future || version < "1.8.0") {
  [21:25:27.662]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.662]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.662]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.662]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.662]                         "release", "version")], collapse = " "), 
  [21:25:27.662]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.662]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.662]                       info)
  [21:25:27.662]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.662]                     if (!has_future) {
  [21:25:27.662]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.662]                         info)
  [21:25:27.662]                     }
  [21:25:27.662]                     else {
  [21:25:27.662]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.662]                         info, version)
  [21:25:27.662]                     }
  [21:25:27.662]                     base::stop(msg)
  [21:25:27.662]                   }
  [21:25:27.662]                 })
  [21:25:27.662]             }
  [21:25:27.662]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.662]         }
  [21:25:27.662]     }
  [21:25:27.662]     if (base::is.na(TRUE)) {
  [21:25:27.662]     }
  [21:25:27.662]     else {
  [21:25:27.662]         if (TRUE) {
  [21:25:27.662]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.662]                 open = "w")
  [21:25:27.662]         }
  [21:25:27.662]         else {
  [21:25:27.662]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.662]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.662]         }
  [21:25:27.662]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.662]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.662]             base::sink(type = "output", split = FALSE)
  [21:25:27.662]             base::close(...future.stdout)
  [21:25:27.662]         }, add = TRUE)
  [21:25:27.662]     }
  [21:25:27.662]     ...future.frame <- base::sys.nframe()
  [21:25:27.662]     ...future.conditions <- base::list()
  [21:25:27.662]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.662]     ...future.result <- base::tryCatch({
  [21:25:27.662]         base::withCallingHandlers({
  [21:25:27.662]             ...future.value <- base::withVisible(base::local({
  [21:25:27.662]                 4
  [21:25:27.662]             }))
  [21:25:27.662]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.662]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.662]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.662]                 version = "1.8")
  [21:25:27.662]         }, condition = base::local({
  [21:25:27.662]             c <- base::c
  [21:25:27.662]             inherits <- base::inherits
  [21:25:27.662]             invokeRestart <- base::invokeRestart
  [21:25:27.662]             length <- base::length
  [21:25:27.662]             list <- base::list
  [21:25:27.662]             seq.int <- base::seq.int
  [21:25:27.662]             signalCondition <- base::signalCondition
  [21:25:27.662]             sys.calls <- base::sys.calls
  [21:25:27.662]             Sys.time <- base::Sys.time
  [21:25:27.662]             `[[` <- base::`[[`
  [21:25:27.662]             `+` <- base::`+`
  [21:25:27.662]             `<<-` <- base::`<<-`
  [21:25:27.662]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.662]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.662]                   3L)]
  [21:25:27.662]             }
  [21:25:27.662]             function(cond) {
  [21:25:27.662]                 if (inherits(cond, "error")) {
  [21:25:27.662]                   sessionInformation <- function() {
  [21:25:27.662]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.662]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.662]                       search = base::search(), system = base::Sys.info())
  [21:25:27.662]                   }
  [21:25:27.662]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.662]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.662]                     cond$call), session = sessionInformation(), 
  [21:25:27.662]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.662]                   signalCondition(cond)
  [21:25:27.662]                 }
  [21:25:27.662]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.662]                 ))) {
  [21:25:27.662]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.662]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.662]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.662]                   if (!signal) {
  [21:25:27.662]                     muffleCondition <- function (cond) 
  [21:25:27.662]                     {
  [21:25:27.662]                       inherits <- base::inherits
  [21:25:27.662]                       invokeRestart <- base::invokeRestart
  [21:25:27.662]                       muffled <- FALSE
  [21:25:27.662]                       if (inherits(cond, "message")) {
  [21:25:27.662]                         invokeRestart("muffleMessage")
  [21:25:27.662]                         muffled <- TRUE
  [21:25:27.662]                       }
  [21:25:27.662]                       else if (inherits(cond, "warning")) {
  [21:25:27.662]                         invokeRestart("muffleWarning")
  [21:25:27.662]                         muffled <- TRUE
  [21:25:27.662]                       }
  [21:25:27.662]                       else if (inherits(cond, "condition")) {
  [21:25:27.662]                         computeRestarts <- base::computeRestarts
  [21:25:27.662]                         grepl <- base::grepl
  [21:25:27.662]                         is.null <- base::is.null
  [21:25:27.662]                         restarts <- computeRestarts(cond)
  [21:25:27.662]                         for (restart in restarts) {
  [21:25:27.662]                           name <- restart$name
  [21:25:27.662]                           if (is.null(name)) 
  [21:25:27.662]                             next
  [21:25:27.662]                           if (!grepl("^muffle", name)) 
  [21:25:27.662]                             next
  [21:25:27.662]                           invokeRestart(restart)
  [21:25:27.662]                           muffled <- TRUE
  [21:25:27.662]                           break
  [21:25:27.662]                         }
  [21:25:27.662]                       }
  [21:25:27.662]                       invisible(muffled)
  [21:25:27.662]                     }
  [21:25:27.662]                     muffleCondition(cond)
  [21:25:27.662]                   }
  [21:25:27.662]                 }
  [21:25:27.662]             }
  [21:25:27.662]         }))
  [21:25:27.662]     }, error = function(ex) {
  [21:25:27.662]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.662]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.662]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.662]     }, finally = {
  [21:25:27.662]         {
  [21:25:27.662]             NULL
  [21:25:27.662]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.662]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.662]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.662]                 label = NULL, ...) 
  [21:25:27.662]             {
  [21:25:27.662]                 if (substitute) 
  [21:25:27.662]                   expr <- substitute(expr)
  [21:25:27.662]                 local <- as.logical(local)
  [21:25:27.662]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.662]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.662]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.662]                   label = label, ...)
  [21:25:27.662]                 if (!future$lazy) 
  [21:25:27.662]                   future <- run(future)
  [21:25:27.662]                 invisible(future)
  [21:25:27.662]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.662]         }
  [21:25:27.662]         base::options(...future.oldOptions)
  [21:25:27.662]     })
  [21:25:27.662]     Sys.time
  [21:25:27.662]     if (base::is.na(TRUE)) {
  [21:25:27.662]     }
  [21:25:27.662]     else {
  [21:25:27.662]         base::sink(type = "output", split = FALSE)
  [21:25:27.662]         if (TRUE) {
  [21:25:27.662]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.662]         }
  [21:25:27.662]         else {
  [21:25:27.662]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.662]         }
  [21:25:27.662]         base::close(...future.stdout)
  [21:25:27.662]         ...future.stdout <- NULL
  [21:25:27.662]     }
  [21:25:27.662]     ...future.result$conditions <- ...future.conditions
  [21:25:27.662]     ...future.result
  [21:25:27.662] }
  [21:25:27.671] plan(): Setting new future strategy stack:
  [21:25:27.671] List of future strategies:
  [21:25:27.671] 1. sequential:
  [21:25:27.671]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.671]    - tweaked: FALSE
  [21:25:27.671]    - call: NULL
  [21:25:27.672] plan(): nbrOfWorkers() = 1
  [21:25:27.673] plan(): Setting new future strategy stack:
  [21:25:27.674] List of future strategies:
  [21:25:27.674] 1. sequential:
  [21:25:27.674]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.674]    - tweaked: FALSE
  [21:25:27.674]    - call: plan(strategy)
  [21:25:27.675] plan(): nbrOfWorkers() = 1
  [21:25:27.675] SequentialFuture started (and completed)
  <environment: 0x55ef20e90888> 
  <environment: 0x55ef2194c058> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:27.681] resolve() on environment ...
  [21:25:27.681]  recursive: 0
  [21:25:27.683]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:27.683] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.683] - nx: 4
  [21:25:27.683] - relay: TRUE
  [21:25:27.684] - stdout: TRUE
  [21:25:27.684] - signal: TRUE
  [21:25:27.684] - resignal: FALSE
  [21:25:27.684] - force: TRUE
  [21:25:27.685] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.685] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.685]  - until=2
  [21:25:27.685]  - relaying element #2
  [21:25:27.686] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.686] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.686] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.687]  length: 3 (resolved future 1)
  [21:25:27.687] Future #2
  [21:25:27.687] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:27.688] - nx: 4
  [21:25:27.688] - relay: TRUE
  [21:25:27.688] - stdout: TRUE
  [21:25:27.688] - signal: TRUE
  [21:25:27.689] - resignal: FALSE
  [21:25:27.689] - force: TRUE
  [21:25:27.689] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.689] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.690]  - until=2
  [21:25:27.690]  - relaying element #2
  [21:25:27.690] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.691] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.691] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:27.691]  length: 2 (resolved future 2)
  [21:25:27.692] Future #3
  [21:25:27.692] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:27.692] - nx: 4
  [21:25:27.693] - relay: TRUE
  [21:25:27.693] - stdout: TRUE
  [21:25:27.693] - signal: TRUE
  [21:25:27.693] - resignal: FALSE
  [21:25:27.694] - force: TRUE
  [21:25:27.694] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.694] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.694]  - until=3
  [21:25:27.695]  - relaying element #3
  [21:25:27.695] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.695] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.696] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:27.696]  length: 1 (resolved future 3)
  [21:25:27.696] Future #4
  [21:25:27.697] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:27.697] - nx: 4
  [21:25:27.697] - relay: TRUE
  [21:25:27.698] - stdout: TRUE
  [21:25:27.698] - signal: TRUE
  [21:25:27.698] - resignal: FALSE
  [21:25:27.698] - force: TRUE
  [21:25:27.699] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.699] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.699]  - until=4
  [21:25:27.699]  - relaying element #4
  [21:25:27.700] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.700] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.700] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:27.701]  length: 0 (resolved future 4)
  [21:25:27.701] Relaying remaining futures
  [21:25:27.701] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.702] - nx: 4
  [21:25:27.702] - relay: TRUE
  [21:25:27.702] - stdout: TRUE
  [21:25:27.703] - signal: TRUE
  [21:25:27.703] - resignal: FALSE
  [21:25:27.703] - force: TRUE
  [21:25:27.703] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.704] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:27.704] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.704] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.705] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.705] resolve() on environment ... DONE
  <environment: 0x55ef2144c490> 
  Dimensions: c(2, 3)
  [21:25:27.706] getGlobalsAndPackages() ...
  [21:25:27.707] Searching for globals...
  [21:25:27.707] 
  [21:25:27.708] Searching for globals ... DONE
  [21:25:27.708] - globals: [0] <none>
  [21:25:27.708] getGlobalsAndPackages() ... DONE
  [21:25:27.710] Packages needed by the future expression (n = 0): <none>
  [21:25:27.710] Packages needed by future strategies (n = 0): <none>
  [21:25:27.715] {
  [21:25:27.715]     {
  [21:25:27.715]         ...future.startTime <- base::Sys.time()
  [21:25:27.715]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.715]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.715]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.715]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.715]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.715]         {
  [21:25:27.715]             {
  [21:25:27.715]                 base::local({
  [21:25:27.715]                   has_future <- base::requireNamespace("future", 
  [21:25:27.715]                     quietly = TRUE)
  [21:25:27.715]                   version <- if (has_future) 
  [21:25:27.715]                     utils::packageVersion("future")
  [21:25:27.715]                   else NULL
  [21:25:27.715]                   if (!has_future || version < "1.8.0") {
  [21:25:27.715]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.715]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.715]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.715]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.715]                         "release", "version")], collapse = " "), 
  [21:25:27.715]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.715]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.715]                       info)
  [21:25:27.715]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.715]                     if (!has_future) {
  [21:25:27.715]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.715]                         info)
  [21:25:27.715]                     }
  [21:25:27.715]                     else {
  [21:25:27.715]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.715]                         info, version)
  [21:25:27.715]                     }
  [21:25:27.715]                     base::stop(msg)
  [21:25:27.715]                   }
  [21:25:27.715]                 })
  [21:25:27.715]             }
  [21:25:27.715]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.715]         }
  [21:25:27.715]     }
  [21:25:27.715]     if (base::is.na(TRUE)) {
  [21:25:27.715]     }
  [21:25:27.715]     else {
  [21:25:27.715]         if (TRUE) {
  [21:25:27.715]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.715]                 open = "w")
  [21:25:27.715]         }
  [21:25:27.715]         else {
  [21:25:27.715]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.715]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.715]         }
  [21:25:27.715]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.715]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.715]             base::sink(type = "output", split = FALSE)
  [21:25:27.715]             base::close(...future.stdout)
  [21:25:27.715]         }, add = TRUE)
  [21:25:27.715]     }
  [21:25:27.715]     ...future.frame <- base::sys.nframe()
  [21:25:27.715]     ...future.conditions <- base::list()
  [21:25:27.715]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.715]     ...future.result <- base::tryCatch({
  [21:25:27.715]         base::withCallingHandlers({
  [21:25:27.715]             ...future.value <- base::withVisible(base::local(2))
  [21:25:27.715]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.715]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.715]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.715]                 version = "1.8")
  [21:25:27.715]         }, condition = base::local({
  [21:25:27.715]             c <- base::c
  [21:25:27.715]             inherits <- base::inherits
  [21:25:27.715]             invokeRestart <- base::invokeRestart
  [21:25:27.715]             length <- base::length
  [21:25:27.715]             list <- base::list
  [21:25:27.715]             seq.int <- base::seq.int
  [21:25:27.715]             signalCondition <- base::signalCondition
  [21:25:27.715]             sys.calls <- base::sys.calls
  [21:25:27.715]             Sys.time <- base::Sys.time
  [21:25:27.715]             `[[` <- base::`[[`
  [21:25:27.715]             `+` <- base::`+`
  [21:25:27.715]             `<<-` <- base::`<<-`
  [21:25:27.715]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.715]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.715]                   3L)]
  [21:25:27.715]             }
  [21:25:27.715]             function(cond) {
  [21:25:27.715]                 if (inherits(cond, "error")) {
  [21:25:27.715]                   sessionInformation <- function() {
  [21:25:27.715]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.715]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.715]                       search = base::search(), system = base::Sys.info())
  [21:25:27.715]                   }
  [21:25:27.715]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.715]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.715]                     cond$call), session = sessionInformation(), 
  [21:25:27.715]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.715]                   signalCondition(cond)
  [21:25:27.715]                 }
  [21:25:27.715]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.715]                 ))) {
  [21:25:27.715]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.715]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.715]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.715]                   if (!signal) {
  [21:25:27.715]                     muffleCondition <- function (cond) 
  [21:25:27.715]                     {
  [21:25:27.715]                       inherits <- base::inherits
  [21:25:27.715]                       invokeRestart <- base::invokeRestart
  [21:25:27.715]                       muffled <- FALSE
  [21:25:27.715]                       if (inherits(cond, "message")) {
  [21:25:27.715]                         invokeRestart("muffleMessage")
  [21:25:27.715]                         muffled <- TRUE
  [21:25:27.715]                       }
  [21:25:27.715]                       else if (inherits(cond, "warning")) {
  [21:25:27.715]                         invokeRestart("muffleWarning")
  [21:25:27.715]                         muffled <- TRUE
  [21:25:27.715]                       }
  [21:25:27.715]                       else if (inherits(cond, "condition")) {
  [21:25:27.715]                         computeRestarts <- base::computeRestarts
  [21:25:27.715]                         grepl <- base::grepl
  [21:25:27.715]                         is.null <- base::is.null
  [21:25:27.715]                         restarts <- computeRestarts(cond)
  [21:25:27.715]                         for (restart in restarts) {
  [21:25:27.715]                           name <- restart$name
  [21:25:27.715]                           if (is.null(name)) 
  [21:25:27.715]                             next
  [21:25:27.715]                           if (!grepl("^muffle", name)) 
  [21:25:27.715]                             next
  [21:25:27.715]                           invokeRestart(restart)
  [21:25:27.715]                           muffled <- TRUE
  [21:25:27.715]                           break
  [21:25:27.715]                         }
  [21:25:27.715]                       }
  [21:25:27.715]                       invisible(muffled)
  [21:25:27.715]                     }
  [21:25:27.715]                     muffleCondition(cond)
  [21:25:27.715]                   }
  [21:25:27.715]                 }
  [21:25:27.715]             }
  [21:25:27.715]         }))
  [21:25:27.715]     }, error = function(ex) {
  [21:25:27.715]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.715]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.715]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.715]     }, finally = {
  [21:25:27.715]         {
  [21:25:27.715]             NULL
  [21:25:27.715]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.715]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.715]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.715]                 label = NULL, ...) 
  [21:25:27.715]             {
  [21:25:27.715]                 if (substitute) 
  [21:25:27.715]                   expr <- substitute(expr)
  [21:25:27.715]                 local <- as.logical(local)
  [21:25:27.715]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.715]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.715]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.715]                   label = label, ...)
  [21:25:27.715]                 if (!future$lazy) 
  [21:25:27.715]                   future <- run(future)
  [21:25:27.715]                 invisible(future)
  [21:25:27.715]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.715]         }
  [21:25:27.715]         base::options(...future.oldOptions)
  [21:25:27.715]     })
  [21:25:27.715]     Sys.time
  [21:25:27.715]     if (base::is.na(TRUE)) {
  [21:25:27.715]     }
  [21:25:27.715]     else {
  [21:25:27.715]         base::sink(type = "output", split = FALSE)
  [21:25:27.715]         if (TRUE) {
  [21:25:27.715]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.715]         }
  [21:25:27.715]         else {
  [21:25:27.715]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.715]         }
  [21:25:27.715]         base::close(...future.stdout)
  [21:25:27.715]         ...future.stdout <- NULL
  [21:25:27.715]     }
  [21:25:27.715]     ...future.result$conditions <- ...future.conditions
  [21:25:27.715]     ...future.result
  [21:25:27.715] }
  [21:25:27.719] plan(): Setting new future strategy stack:
  [21:25:27.720] List of future strategies:
  [21:25:27.720] 1. sequential:
  [21:25:27.720]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.720]    - tweaked: FALSE
  [21:25:27.720]    - call: NULL
  [21:25:27.720] plan(): nbrOfWorkers() = 1
  [21:25:27.721] plan(): Setting new future strategy stack:
  [21:25:27.722] List of future strategies:
  [21:25:27.722] 1. sequential:
  [21:25:27.722]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.722]    - tweaked: FALSE
  [21:25:27.722]    - call: plan(strategy)
  [21:25:27.723] plan(): nbrOfWorkers() = 1
  [21:25:27.723] SequentialFuture started (and completed)
  [21:25:27.724] getGlobalsAndPackages() ...
  [21:25:27.724] Searching for globals...
  [21:25:27.725] 
  [21:25:27.725] Searching for globals ... DONE
  [21:25:27.725] - globals: [0] <none>
  [21:25:27.725] getGlobalsAndPackages() ... DONE
  [21:25:27.727] Packages needed by the future expression (n = 0): <none>
  [21:25:27.727] Packages needed by future strategies (n = 0): <none>
  [21:25:27.732] {
  [21:25:27.732]     {
  [21:25:27.732]         ...future.startTime <- base::Sys.time()
  [21:25:27.732]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.732]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.732]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.732]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.732]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.732]         {
  [21:25:27.732]             {
  [21:25:27.732]                 base::local({
  [21:25:27.732]                   has_future <- base::requireNamespace("future", 
  [21:25:27.732]                     quietly = TRUE)
  [21:25:27.732]                   version <- if (has_future) 
  [21:25:27.732]                     utils::packageVersion("future")
  [21:25:27.732]                   else NULL
  [21:25:27.732]                   if (!has_future || version < "1.8.0") {
  [21:25:27.732]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.732]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.732]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.732]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.732]                         "release", "version")], collapse = " "), 
  [21:25:27.732]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.732]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.732]                       info)
  [21:25:27.732]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.732]                     if (!has_future) {
  [21:25:27.732]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.732]                         info)
  [21:25:27.732]                     }
  [21:25:27.732]                     else {
  [21:25:27.732]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.732]                         info, version)
  [21:25:27.732]                     }
  [21:25:27.732]                     base::stop(msg)
  [21:25:27.732]                   }
  [21:25:27.732]                 })
  [21:25:27.732]             }
  [21:25:27.732]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.732]         }
  [21:25:27.732]     }
  [21:25:27.732]     if (base::is.na(TRUE)) {
  [21:25:27.732]     }
  [21:25:27.732]     else {
  [21:25:27.732]         if (TRUE) {
  [21:25:27.732]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.732]                 open = "w")
  [21:25:27.732]         }
  [21:25:27.732]         else {
  [21:25:27.732]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.732]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.732]         }
  [21:25:27.732]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.732]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.732]             base::sink(type = "output", split = FALSE)
  [21:25:27.732]             base::close(...future.stdout)
  [21:25:27.732]         }, add = TRUE)
  [21:25:27.732]     }
  [21:25:27.732]     ...future.frame <- base::sys.nframe()
  [21:25:27.732]     ...future.conditions <- base::list()
  [21:25:27.732]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.732]     ...future.result <- base::tryCatch({
  [21:25:27.732]         base::withCallingHandlers({
  [21:25:27.732]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:27.732]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.732]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.732]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.732]                 version = "1.8")
  [21:25:27.732]         }, condition = base::local({
  [21:25:27.732]             c <- base::c
  [21:25:27.732]             inherits <- base::inherits
  [21:25:27.732]             invokeRestart <- base::invokeRestart
  [21:25:27.732]             length <- base::length
  [21:25:27.732]             list <- base::list
  [21:25:27.732]             seq.int <- base::seq.int
  [21:25:27.732]             signalCondition <- base::signalCondition
  [21:25:27.732]             sys.calls <- base::sys.calls
  [21:25:27.732]             Sys.time <- base::Sys.time
  [21:25:27.732]             `[[` <- base::`[[`
  [21:25:27.732]             `+` <- base::`+`
  [21:25:27.732]             `<<-` <- base::`<<-`
  [21:25:27.732]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.732]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.732]                   3L)]
  [21:25:27.732]             }
  [21:25:27.732]             function(cond) {
  [21:25:27.732]                 if (inherits(cond, "error")) {
  [21:25:27.732]                   sessionInformation <- function() {
  [21:25:27.732]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.732]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.732]                       search = base::search(), system = base::Sys.info())
  [21:25:27.732]                   }
  [21:25:27.732]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.732]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.732]                     cond$call), session = sessionInformation(), 
  [21:25:27.732]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.732]                   signalCondition(cond)
  [21:25:27.732]                 }
  [21:25:27.732]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.732]                 ))) {
  [21:25:27.732]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.732]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.732]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.732]                   if (!signal) {
  [21:25:27.732]                     muffleCondition <- function (cond) 
  [21:25:27.732]                     {
  [21:25:27.732]                       inherits <- base::inherits
  [21:25:27.732]                       invokeRestart <- base::invokeRestart
  [21:25:27.732]                       muffled <- FALSE
  [21:25:27.732]                       if (inherits(cond, "message")) {
  [21:25:27.732]                         invokeRestart("muffleMessage")
  [21:25:27.732]                         muffled <- TRUE
  [21:25:27.732]                       }
  [21:25:27.732]                       else if (inherits(cond, "warning")) {
  [21:25:27.732]                         invokeRestart("muffleWarning")
  [21:25:27.732]                         muffled <- TRUE
  [21:25:27.732]                       }
  [21:25:27.732]                       else if (inherits(cond, "condition")) {
  [21:25:27.732]                         computeRestarts <- base::computeRestarts
  [21:25:27.732]                         grepl <- base::grepl
  [21:25:27.732]                         is.null <- base::is.null
  [21:25:27.732]                         restarts <- computeRestarts(cond)
  [21:25:27.732]                         for (restart in restarts) {
  [21:25:27.732]                           name <- restart$name
  [21:25:27.732]                           if (is.null(name)) 
  [21:25:27.732]                             next
  [21:25:27.732]                           if (!grepl("^muffle", name)) 
  [21:25:27.732]                             next
  [21:25:27.732]                           invokeRestart(restart)
  [21:25:27.732]                           muffled <- TRUE
  [21:25:27.732]                           break
  [21:25:27.732]                         }
  [21:25:27.732]                       }
  [21:25:27.732]                       invisible(muffled)
  [21:25:27.732]                     }
  [21:25:27.732]                     muffleCondition(cond)
  [21:25:27.732]                   }
  [21:25:27.732]                 }
  [21:25:27.732]             }
  [21:25:27.732]         }))
  [21:25:27.732]     }, error = function(ex) {
  [21:25:27.732]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.732]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.732]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.732]     }, finally = {
  [21:25:27.732]         {
  [21:25:27.732]             NULL
  [21:25:27.732]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.732]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.732]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.732]                 label = NULL, ...) 
  [21:25:27.732]             {
  [21:25:27.732]                 if (substitute) 
  [21:25:27.732]                   expr <- substitute(expr)
  [21:25:27.732]                 local <- as.logical(local)
  [21:25:27.732]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.732]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.732]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.732]                   label = label, ...)
  [21:25:27.732]                 if (!future$lazy) 
  [21:25:27.732]                   future <- run(future)
  [21:25:27.732]                 invisible(future)
  [21:25:27.732]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.732]         }
  [21:25:27.732]         base::options(...future.oldOptions)
  [21:25:27.732]     })
  [21:25:27.732]     Sys.time
  [21:25:27.732]     if (base::is.na(TRUE)) {
  [21:25:27.732]     }
  [21:25:27.732]     else {
  [21:25:27.732]         base::sink(type = "output", split = FALSE)
  [21:25:27.732]         if (TRUE) {
  [21:25:27.732]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.732]         }
  [21:25:27.732]         else {
  [21:25:27.732]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.732]         }
  [21:25:27.732]         base::close(...future.stdout)
  [21:25:27.732]         ...future.stdout <- NULL
  [21:25:27.732]     }
  [21:25:27.732]     ...future.result$conditions <- ...future.conditions
  [21:25:27.732]     ...future.result
  [21:25:27.732] }
  [21:25:27.737] plan(): Setting new future strategy stack:
  [21:25:27.737] List of future strategies:
  [21:25:27.737] 1. sequential:
  [21:25:27.737]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.737]    - tweaked: FALSE
  [21:25:27.737]    - call: NULL
  [21:25:27.741] plan(): nbrOfWorkers() = 1
  [21:25:27.743] plan(): Setting new future strategy stack:
  [21:25:27.743] List of future strategies:
  [21:25:27.743] 1. sequential:
  [21:25:27.743]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.743]    - tweaked: FALSE
  [21:25:27.743]    - call: plan(strategy)
  [21:25:27.744] plan(): nbrOfWorkers() = 1
  [21:25:27.745] SequentialFuture started (and completed)
  [21:25:27.745] getGlobalsAndPackages() ...
  [21:25:27.746] Searching for globals...
  [21:25:27.747] - globals found: [1] '{'
  [21:25:27.747] Searching for globals ... DONE
  [21:25:27.748] Resolving globals: FALSE
  [21:25:27.748] 
  [21:25:27.749] 
  [21:25:27.749] getGlobalsAndPackages() ... DONE
  [21:25:27.751] Packages needed by the future expression (n = 0): <none>
  [21:25:27.751] Packages needed by future strategies (n = 0): <none>
  [21:25:27.755] {
  [21:25:27.755]     {
  [21:25:27.755]         ...future.startTime <- base::Sys.time()
  [21:25:27.755]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.755]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.755]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.755]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.755]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.755]         {
  [21:25:27.755]             {
  [21:25:27.755]                 base::local({
  [21:25:27.755]                   has_future <- base::requireNamespace("future", 
  [21:25:27.755]                     quietly = TRUE)
  [21:25:27.755]                   version <- if (has_future) 
  [21:25:27.755]                     utils::packageVersion("future")
  [21:25:27.755]                   else NULL
  [21:25:27.755]                   if (!has_future || version < "1.8.0") {
  [21:25:27.755]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.755]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.755]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.755]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.755]                         "release", "version")], collapse = " "), 
  [21:25:27.755]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.755]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.755]                       info)
  [21:25:27.755]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.755]                     if (!has_future) {
  [21:25:27.755]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.755]                         info)
  [21:25:27.755]                     }
  [21:25:27.755]                     else {
  [21:25:27.755]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.755]                         info, version)
  [21:25:27.755]                     }
  [21:25:27.755]                     base::stop(msg)
  [21:25:27.755]                   }
  [21:25:27.755]                 })
  [21:25:27.755]             }
  [21:25:27.755]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.755]         }
  [21:25:27.755]     }
  [21:25:27.755]     if (base::is.na(TRUE)) {
  [21:25:27.755]     }
  [21:25:27.755]     else {
  [21:25:27.755]         if (TRUE) {
  [21:25:27.755]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.755]                 open = "w")
  [21:25:27.755]         }
  [21:25:27.755]         else {
  [21:25:27.755]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.755]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.755]         }
  [21:25:27.755]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.755]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.755]             base::sink(type = "output", split = FALSE)
  [21:25:27.755]             base::close(...future.stdout)
  [21:25:27.755]         }, add = TRUE)
  [21:25:27.755]     }
  [21:25:27.755]     ...future.frame <- base::sys.nframe()
  [21:25:27.755]     ...future.conditions <- base::list()
  [21:25:27.755]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.755]     ...future.result <- base::tryCatch({
  [21:25:27.755]         base::withCallingHandlers({
  [21:25:27.755]             ...future.value <- base::withVisible(base::local({
  [21:25:27.755]                 4
  [21:25:27.755]             }))
  [21:25:27.755]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.755]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.755]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.755]                 version = "1.8")
  [21:25:27.755]         }, condition = base::local({
  [21:25:27.755]             c <- base::c
  [21:25:27.755]             inherits <- base::inherits
  [21:25:27.755]             invokeRestart <- base::invokeRestart
  [21:25:27.755]             length <- base::length
  [21:25:27.755]             list <- base::list
  [21:25:27.755]             seq.int <- base::seq.int
  [21:25:27.755]             signalCondition <- base::signalCondition
  [21:25:27.755]             sys.calls <- base::sys.calls
  [21:25:27.755]             Sys.time <- base::Sys.time
  [21:25:27.755]             `[[` <- base::`[[`
  [21:25:27.755]             `+` <- base::`+`
  [21:25:27.755]             `<<-` <- base::`<<-`
  [21:25:27.755]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.755]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.755]                   3L)]
  [21:25:27.755]             }
  [21:25:27.755]             function(cond) {
  [21:25:27.755]                 if (inherits(cond, "error")) {
  [21:25:27.755]                   sessionInformation <- function() {
  [21:25:27.755]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.755]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.755]                       search = base::search(), system = base::Sys.info())
  [21:25:27.755]                   }
  [21:25:27.755]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.755]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.755]                     cond$call), session = sessionInformation(), 
  [21:25:27.755]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.755]                   signalCondition(cond)
  [21:25:27.755]                 }
  [21:25:27.755]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.755]                 ))) {
  [21:25:27.755]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.755]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.755]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.755]                   if (!signal) {
  [21:25:27.755]                     muffleCondition <- function (cond) 
  [21:25:27.755]                     {
  [21:25:27.755]                       inherits <- base::inherits
  [21:25:27.755]                       invokeRestart <- base::invokeRestart
  [21:25:27.755]                       muffled <- FALSE
  [21:25:27.755]                       if (inherits(cond, "message")) {
  [21:25:27.755]                         invokeRestart("muffleMessage")
  [21:25:27.755]                         muffled <- TRUE
  [21:25:27.755]                       }
  [21:25:27.755]                       else if (inherits(cond, "warning")) {
  [21:25:27.755]                         invokeRestart("muffleWarning")
  [21:25:27.755]                         muffled <- TRUE
  [21:25:27.755]                       }
  [21:25:27.755]                       else if (inherits(cond, "condition")) {
  [21:25:27.755]                         computeRestarts <- base::computeRestarts
  [21:25:27.755]                         grepl <- base::grepl
  [21:25:27.755]                         is.null <- base::is.null
  [21:25:27.755]                         restarts <- computeRestarts(cond)
  [21:25:27.755]                         for (restart in restarts) {
  [21:25:27.755]                           name <- restart$name
  [21:25:27.755]                           if (is.null(name)) 
  [21:25:27.755]                             next
  [21:25:27.755]                           if (!grepl("^muffle", name)) 
  [21:25:27.755]                             next
  [21:25:27.755]                           invokeRestart(restart)
  [21:25:27.755]                           muffled <- TRUE
  [21:25:27.755]                           break
  [21:25:27.755]                         }
  [21:25:27.755]                       }
  [21:25:27.755]                       invisible(muffled)
  [21:25:27.755]                     }
  [21:25:27.755]                     muffleCondition(cond)
  [21:25:27.755]                   }
  [21:25:27.755]                 }
  [21:25:27.755]             }
  [21:25:27.755]         }))
  [21:25:27.755]     }, error = function(ex) {
  [21:25:27.755]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.755]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.755]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.755]     }, finally = {
  [21:25:27.755]         {
  [21:25:27.755]             NULL
  [21:25:27.755]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.755]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.755]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.755]                 label = NULL, ...) 
  [21:25:27.755]             {
  [21:25:27.755]                 if (substitute) 
  [21:25:27.755]                   expr <- substitute(expr)
  [21:25:27.755]                 local <- as.logical(local)
  [21:25:27.755]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.755]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.755]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.755]                   label = label, ...)
  [21:25:27.755]                 if (!future$lazy) 
  [21:25:27.755]                   future <- run(future)
  [21:25:27.755]                 invisible(future)
  [21:25:27.755]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.755]         }
  [21:25:27.755]         base::options(...future.oldOptions)
  [21:25:27.755]     })
  [21:25:27.755]     Sys.time
  [21:25:27.755]     if (base::is.na(TRUE)) {
  [21:25:27.755]     }
  [21:25:27.755]     else {
  [21:25:27.755]         base::sink(type = "output", split = FALSE)
  [21:25:27.755]         if (TRUE) {
  [21:25:27.755]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.755]         }
  [21:25:27.755]         else {
  [21:25:27.755]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.755]         }
  [21:25:27.755]         base::close(...future.stdout)
  [21:25:27.755]         ...future.stdout <- NULL
  [21:25:27.755]     }
  [21:25:27.755]     ...future.result$conditions <- ...future.conditions
  [21:25:27.755]     ...future.result
  [21:25:27.755] }
  [21:25:27.760] plan(): Setting new future strategy stack:
  [21:25:27.760] List of future strategies:
  [21:25:27.760] 1. sequential:
  [21:25:27.760]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.760]    - tweaked: FALSE
  [21:25:27.760]    - call: NULL
  [21:25:27.761] plan(): nbrOfWorkers() = 1
  [21:25:27.762] plan(): Setting new future strategy stack:
  [21:25:27.763] List of future strategies:
  [21:25:27.763] 1. sequential:
  [21:25:27.763]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.763]    - tweaked: FALSE
  [21:25:27.763]    - call: plan(strategy)
  [21:25:27.764] plan(): nbrOfWorkers() = 1
  [21:25:27.764] SequentialFuture started (and completed)
  <environment: 0x55ef225a2328> 
  <environment: 0x55ef20b31c20> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:27.770] resolve() on environment ...
  [21:25:27.770]  recursive: 0
  [21:25:27.771]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:27.772] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.772] - nx: 4
  [21:25:27.772] - relay: TRUE
  [21:25:27.772] - stdout: TRUE
  [21:25:27.773] - signal: TRUE
  [21:25:27.773] - resignal: FALSE
  [21:25:27.773] - force: TRUE
  [21:25:27.773] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.774] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.774]  - until=2
  [21:25:27.774]  - relaying element #2
  [21:25:27.775] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.775] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.775] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.775]  length: 3 (resolved future 1)
  [21:25:27.776] Future #2
  [21:25:27.776] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:27.776] - nx: 4
  [21:25:27.777] - relay: TRUE
  [21:25:27.777] - stdout: TRUE
  [21:25:27.777] - signal: TRUE
  [21:25:27.777] - resignal: FALSE
  [21:25:27.778] - force: TRUE
  [21:25:27.778] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.778] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.778]  - until=2
  [21:25:27.779]  - relaying element #2
  [21:25:27.779] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.779] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.780] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:27.780]  length: 2 (resolved future 2)
  [21:25:27.780] Future #3
  [21:25:27.781] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:27.781] - nx: 4
  [21:25:27.781] - relay: TRUE
  [21:25:27.782] - stdout: TRUE
  [21:25:27.782] - signal: TRUE
  [21:25:27.782] - resignal: FALSE
  [21:25:27.782] - force: TRUE
  [21:25:27.783] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.783] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.783]  - until=3
  [21:25:27.783]  - relaying element #3
  [21:25:27.784] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.784] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.784] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:27.785]  length: 1 (resolved future 3)
  [21:25:27.785] Future #4
  [21:25:27.785] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:27.786] - nx: 4
  [21:25:27.786] - relay: TRUE
  [21:25:27.786] - stdout: TRUE
  [21:25:27.786] - signal: TRUE
  [21:25:27.787] - resignal: FALSE
  [21:25:27.787] - force: TRUE
  [21:25:27.787] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.787] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.788]  - until=4
  [21:25:27.788]  - relaying element #4
  [21:25:27.789] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.789] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.789] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:27.789]  length: 0 (resolved future 4)
  [21:25:27.790] Relaying remaining futures
  [21:25:27.790] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.790] - nx: 4
  [21:25:27.791] - relay: TRUE
  [21:25:27.791] - stdout: TRUE
  [21:25:27.791] - signal: TRUE
  [21:25:27.791] - resignal: FALSE
  [21:25:27.792] - force: TRUE
  [21:25:27.792] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.792] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:27.793] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.793] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.793] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.793] resolve() on environment ... DONE
  <environment: 0x55ef21738730> 
  Dimensions: c(2, 3, 1)
  [21:25:27.795] getGlobalsAndPackages() ...
  [21:25:27.795] Searching for globals...
  [21:25:27.796] 
  [21:25:27.796] Searching for globals ... DONE
  [21:25:27.796] - globals: [0] <none>
  [21:25:27.797] getGlobalsAndPackages() ... DONE
  [21:25:27.798] Packages needed by the future expression (n = 0): <none>
  [21:25:27.799] Packages needed by future strategies (n = 0): <none>
  [21:25:27.803] {
  [21:25:27.803]     {
  [21:25:27.803]         ...future.startTime <- base::Sys.time()
  [21:25:27.803]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.803]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.803]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.803]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.803]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.803]         {
  [21:25:27.803]             {
  [21:25:27.803]                 base::local({
  [21:25:27.803]                   has_future <- base::requireNamespace("future", 
  [21:25:27.803]                     quietly = TRUE)
  [21:25:27.803]                   version <- if (has_future) 
  [21:25:27.803]                     utils::packageVersion("future")
  [21:25:27.803]                   else NULL
  [21:25:27.803]                   if (!has_future || version < "1.8.0") {
  [21:25:27.803]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.803]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.803]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.803]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.803]                         "release", "version")], collapse = " "), 
  [21:25:27.803]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.803]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.803]                       info)
  [21:25:27.803]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.803]                     if (!has_future) {
  [21:25:27.803]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.803]                         info)
  [21:25:27.803]                     }
  [21:25:27.803]                     else {
  [21:25:27.803]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.803]                         info, version)
  [21:25:27.803]                     }
  [21:25:27.803]                     base::stop(msg)
  [21:25:27.803]                   }
  [21:25:27.803]                 })
  [21:25:27.803]             }
  [21:25:27.803]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.803]         }
  [21:25:27.803]     }
  [21:25:27.803]     if (base::is.na(TRUE)) {
  [21:25:27.803]     }
  [21:25:27.803]     else {
  [21:25:27.803]         if (TRUE) {
  [21:25:27.803]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.803]                 open = "w")
  [21:25:27.803]         }
  [21:25:27.803]         else {
  [21:25:27.803]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.803]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.803]         }
  [21:25:27.803]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.803]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.803]             base::sink(type = "output", split = FALSE)
  [21:25:27.803]             base::close(...future.stdout)
  [21:25:27.803]         }, add = TRUE)
  [21:25:27.803]     }
  [21:25:27.803]     ...future.frame <- base::sys.nframe()
  [21:25:27.803]     ...future.conditions <- base::list()
  [21:25:27.803]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.803]     ...future.result <- base::tryCatch({
  [21:25:27.803]         base::withCallingHandlers({
  [21:25:27.803]             ...future.value <- base::withVisible(base::local(2))
  [21:25:27.803]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.803]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.803]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.803]                 version = "1.8")
  [21:25:27.803]         }, condition = base::local({
  [21:25:27.803]             c <- base::c
  [21:25:27.803]             inherits <- base::inherits
  [21:25:27.803]             invokeRestart <- base::invokeRestart
  [21:25:27.803]             length <- base::length
  [21:25:27.803]             list <- base::list
  [21:25:27.803]             seq.int <- base::seq.int
  [21:25:27.803]             signalCondition <- base::signalCondition
  [21:25:27.803]             sys.calls <- base::sys.calls
  [21:25:27.803]             Sys.time <- base::Sys.time
  [21:25:27.803]             `[[` <- base::`[[`
  [21:25:27.803]             `+` <- base::`+`
  [21:25:27.803]             `<<-` <- base::`<<-`
  [21:25:27.803]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.803]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.803]                   3L)]
  [21:25:27.803]             }
  [21:25:27.803]             function(cond) {
  [21:25:27.803]                 if (inherits(cond, "error")) {
  [21:25:27.803]                   sessionInformation <- function() {
  [21:25:27.803]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.803]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.803]                       search = base::search(), system = base::Sys.info())
  [21:25:27.803]                   }
  [21:25:27.803]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.803]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.803]                     cond$call), session = sessionInformation(), 
  [21:25:27.803]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.803]                   signalCondition(cond)
  [21:25:27.803]                 }
  [21:25:27.803]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.803]                 ))) {
  [21:25:27.803]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.803]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.803]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.803]                   if (!signal) {
  [21:25:27.803]                     muffleCondition <- function (cond) 
  [21:25:27.803]                     {
  [21:25:27.803]                       inherits <- base::inherits
  [21:25:27.803]                       invokeRestart <- base::invokeRestart
  [21:25:27.803]                       muffled <- FALSE
  [21:25:27.803]                       if (inherits(cond, "message")) {
  [21:25:27.803]                         invokeRestart("muffleMessage")
  [21:25:27.803]                         muffled <- TRUE
  [21:25:27.803]                       }
  [21:25:27.803]                       else if (inherits(cond, "warning")) {
  [21:25:27.803]                         invokeRestart("muffleWarning")
  [21:25:27.803]                         muffled <- TRUE
  [21:25:27.803]                       }
  [21:25:27.803]                       else if (inherits(cond, "condition")) {
  [21:25:27.803]                         computeRestarts <- base::computeRestarts
  [21:25:27.803]                         grepl <- base::grepl
  [21:25:27.803]                         is.null <- base::is.null
  [21:25:27.803]                         restarts <- computeRestarts(cond)
  [21:25:27.803]                         for (restart in restarts) {
  [21:25:27.803]                           name <- restart$name
  [21:25:27.803]                           if (is.null(name)) 
  [21:25:27.803]                             next
  [21:25:27.803]                           if (!grepl("^muffle", name)) 
  [21:25:27.803]                             next
  [21:25:27.803]                           invokeRestart(restart)
  [21:25:27.803]                           muffled <- TRUE
  [21:25:27.803]                           break
  [21:25:27.803]                         }
  [21:25:27.803]                       }
  [21:25:27.803]                       invisible(muffled)
  [21:25:27.803]                     }
  [21:25:27.803]                     muffleCondition(cond)
  [21:25:27.803]                   }
  [21:25:27.803]                 }
  [21:25:27.803]             }
  [21:25:27.803]         }))
  [21:25:27.803]     }, error = function(ex) {
  [21:25:27.803]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.803]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.803]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.803]     }, finally = {
  [21:25:27.803]         {
  [21:25:27.803]             NULL
  [21:25:27.803]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.803]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.803]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.803]                 label = NULL, ...) 
  [21:25:27.803]             {
  [21:25:27.803]                 if (substitute) 
  [21:25:27.803]                   expr <- substitute(expr)
  [21:25:27.803]                 local <- as.logical(local)
  [21:25:27.803]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.803]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.803]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.803]                   label = label, ...)
  [21:25:27.803]                 if (!future$lazy) 
  [21:25:27.803]                   future <- run(future)
  [21:25:27.803]                 invisible(future)
  [21:25:27.803]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.803]         }
  [21:25:27.803]         base::options(...future.oldOptions)
  [21:25:27.803]     })
  [21:25:27.803]     Sys.time
  [21:25:27.803]     if (base::is.na(TRUE)) {
  [21:25:27.803]     }
  [21:25:27.803]     else {
  [21:25:27.803]         base::sink(type = "output", split = FALSE)
  [21:25:27.803]         if (TRUE) {
  [21:25:27.803]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.803]         }
  [21:25:27.803]         else {
  [21:25:27.803]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.803]         }
  [21:25:27.803]         base::close(...future.stdout)
  [21:25:27.803]         ...future.stdout <- NULL
  [21:25:27.803]     }
  [21:25:27.803]     ...future.result$conditions <- ...future.conditions
  [21:25:27.803]     ...future.result
  [21:25:27.803] }
  [21:25:27.812] plan(): Setting new future strategy stack:
  [21:25:27.813] List of future strategies:
  [21:25:27.813] 1. sequential:
  [21:25:27.813]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.813]    - tweaked: FALSE
  [21:25:27.813]    - call: NULL
  [21:25:27.814] plan(): nbrOfWorkers() = 1
  [21:25:27.815] plan(): Setting new future strategy stack:
  [21:25:27.815] List of future strategies:
  [21:25:27.815] 1. sequential:
  [21:25:27.815]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.815]    - tweaked: FALSE
  [21:25:27.815]    - call: plan(strategy)
  [21:25:27.816] plan(): nbrOfWorkers() = 1
  [21:25:27.817] SequentialFuture started (and completed)
  [21:25:27.817] getGlobalsAndPackages() ...
  [21:25:27.817] Searching for globals...
  [21:25:27.818] 
  [21:25:27.818] Searching for globals ... DONE
  [21:25:27.819] - globals: [0] <none>
  [21:25:27.819] getGlobalsAndPackages() ... DONE
  [21:25:27.820] Packages needed by the future expression (n = 0): <none>
  [21:25:27.821] Packages needed by future strategies (n = 0): <none>
  [21:25:27.825] {
  [21:25:27.825]     {
  [21:25:27.825]         ...future.startTime <- base::Sys.time()
  [21:25:27.825]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.825]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.825]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.825]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.825]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.825]         {
  [21:25:27.825]             {
  [21:25:27.825]                 base::local({
  [21:25:27.825]                   has_future <- base::requireNamespace("future", 
  [21:25:27.825]                     quietly = TRUE)
  [21:25:27.825]                   version <- if (has_future) 
  [21:25:27.825]                     utils::packageVersion("future")
  [21:25:27.825]                   else NULL
  [21:25:27.825]                   if (!has_future || version < "1.8.0") {
  [21:25:27.825]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.825]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.825]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.825]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.825]                         "release", "version")], collapse = " "), 
  [21:25:27.825]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.825]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.825]                       info)
  [21:25:27.825]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.825]                     if (!has_future) {
  [21:25:27.825]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.825]                         info)
  [21:25:27.825]                     }
  [21:25:27.825]                     else {
  [21:25:27.825]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.825]                         info, version)
  [21:25:27.825]                     }
  [21:25:27.825]                     base::stop(msg)
  [21:25:27.825]                   }
  [21:25:27.825]                 })
  [21:25:27.825]             }
  [21:25:27.825]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.825]         }
  [21:25:27.825]     }
  [21:25:27.825]     if (base::is.na(TRUE)) {
  [21:25:27.825]     }
  [21:25:27.825]     else {
  [21:25:27.825]         if (TRUE) {
  [21:25:27.825]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.825]                 open = "w")
  [21:25:27.825]         }
  [21:25:27.825]         else {
  [21:25:27.825]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.825]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.825]         }
  [21:25:27.825]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.825]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.825]             base::sink(type = "output", split = FALSE)
  [21:25:27.825]             base::close(...future.stdout)
  [21:25:27.825]         }, add = TRUE)
  [21:25:27.825]     }
  [21:25:27.825]     ...future.frame <- base::sys.nframe()
  [21:25:27.825]     ...future.conditions <- base::list()
  [21:25:27.825]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.825]     ...future.result <- base::tryCatch({
  [21:25:27.825]         base::withCallingHandlers({
  [21:25:27.825]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:27.825]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.825]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.825]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.825]                 version = "1.8")
  [21:25:27.825]         }, condition = base::local({
  [21:25:27.825]             c <- base::c
  [21:25:27.825]             inherits <- base::inherits
  [21:25:27.825]             invokeRestart <- base::invokeRestart
  [21:25:27.825]             length <- base::length
  [21:25:27.825]             list <- base::list
  [21:25:27.825]             seq.int <- base::seq.int
  [21:25:27.825]             signalCondition <- base::signalCondition
  [21:25:27.825]             sys.calls <- base::sys.calls
  [21:25:27.825]             Sys.time <- base::Sys.time
  [21:25:27.825]             `[[` <- base::`[[`
  [21:25:27.825]             `+` <- base::`+`
  [21:25:27.825]             `<<-` <- base::`<<-`
  [21:25:27.825]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.825]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.825]                   3L)]
  [21:25:27.825]             }
  [21:25:27.825]             function(cond) {
  [21:25:27.825]                 if (inherits(cond, "error")) {
  [21:25:27.825]                   sessionInformation <- function() {
  [21:25:27.825]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.825]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.825]                       search = base::search(), system = base::Sys.info())
  [21:25:27.825]                   }
  [21:25:27.825]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.825]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.825]                     cond$call), session = sessionInformation(), 
  [21:25:27.825]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.825]                   signalCondition(cond)
  [21:25:27.825]                 }
  [21:25:27.825]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.825]                 ))) {
  [21:25:27.825]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.825]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.825]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.825]                   if (!signal) {
  [21:25:27.825]                     muffleCondition <- function (cond) 
  [21:25:27.825]                     {
  [21:25:27.825]                       inherits <- base::inherits
  [21:25:27.825]                       invokeRestart <- base::invokeRestart
  [21:25:27.825]                       muffled <- FALSE
  [21:25:27.825]                       if (inherits(cond, "message")) {
  [21:25:27.825]                         invokeRestart("muffleMessage")
  [21:25:27.825]                         muffled <- TRUE
  [21:25:27.825]                       }
  [21:25:27.825]                       else if (inherits(cond, "warning")) {
  [21:25:27.825]                         invokeRestart("muffleWarning")
  [21:25:27.825]                         muffled <- TRUE
  [21:25:27.825]                       }
  [21:25:27.825]                       else if (inherits(cond, "condition")) {
  [21:25:27.825]                         computeRestarts <- base::computeRestarts
  [21:25:27.825]                         grepl <- base::grepl
  [21:25:27.825]                         is.null <- base::is.null
  [21:25:27.825]                         restarts <- computeRestarts(cond)
  [21:25:27.825]                         for (restart in restarts) {
  [21:25:27.825]                           name <- restart$name
  [21:25:27.825]                           if (is.null(name)) 
  [21:25:27.825]                             next
  [21:25:27.825]                           if (!grepl("^muffle", name)) 
  [21:25:27.825]                             next
  [21:25:27.825]                           invokeRestart(restart)
  [21:25:27.825]                           muffled <- TRUE
  [21:25:27.825]                           break
  [21:25:27.825]                         }
  [21:25:27.825]                       }
  [21:25:27.825]                       invisible(muffled)
  [21:25:27.825]                     }
  [21:25:27.825]                     muffleCondition(cond)
  [21:25:27.825]                   }
  [21:25:27.825]                 }
  [21:25:27.825]             }
  [21:25:27.825]         }))
  [21:25:27.825]     }, error = function(ex) {
  [21:25:27.825]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.825]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.825]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.825]     }, finally = {
  [21:25:27.825]         {
  [21:25:27.825]             NULL
  [21:25:27.825]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.825]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.825]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.825]                 label = NULL, ...) 
  [21:25:27.825]             {
  [21:25:27.825]                 if (substitute) 
  [21:25:27.825]                   expr <- substitute(expr)
  [21:25:27.825]                 local <- as.logical(local)
  [21:25:27.825]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.825]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.825]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.825]                   label = label, ...)
  [21:25:27.825]                 if (!future$lazy) 
  [21:25:27.825]                   future <- run(future)
  [21:25:27.825]                 invisible(future)
  [21:25:27.825]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.825]         }
  [21:25:27.825]         base::options(...future.oldOptions)
  [21:25:27.825]     })
  [21:25:27.825]     Sys.time
  [21:25:27.825]     if (base::is.na(TRUE)) {
  [21:25:27.825]     }
  [21:25:27.825]     else {
  [21:25:27.825]         base::sink(type = "output", split = FALSE)
  [21:25:27.825]         if (TRUE) {
  [21:25:27.825]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.825]         }
  [21:25:27.825]         else {
  [21:25:27.825]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.825]         }
  [21:25:27.825]         base::close(...future.stdout)
  [21:25:27.825]         ...future.stdout <- NULL
  [21:25:27.825]     }
  [21:25:27.825]     ...future.result$conditions <- ...future.conditions
  [21:25:27.825]     ...future.result
  [21:25:27.825] }
  [21:25:27.830] plan(): Setting new future strategy stack:
  [21:25:27.830] List of future strategies:
  [21:25:27.830] 1. sequential:
  [21:25:27.830]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.830]    - tweaked: FALSE
  [21:25:27.830]    - call: NULL
  [21:25:27.831] plan(): nbrOfWorkers() = 1
  [21:25:27.832] plan(): Setting new future strategy stack:
  [21:25:27.832] List of future strategies:
  [21:25:27.832] 1. sequential:
  [21:25:27.832]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.832]    - tweaked: FALSE
  [21:25:27.832]    - call: plan(strategy)
  [21:25:27.833] plan(): nbrOfWorkers() = 1
  [21:25:27.834] SequentialFuture started (and completed)
  [21:25:27.835] getGlobalsAndPackages() ...
  [21:25:27.835] Searching for globals...
  [21:25:27.836] - globals found: [1] '{'
  [21:25:27.836] Searching for globals ... DONE
  [21:25:27.837] Resolving globals: FALSE
  [21:25:27.837] 
  [21:25:27.838] 
  [21:25:27.838] getGlobalsAndPackages() ... DONE
  [21:25:27.840] Packages needed by the future expression (n = 0): <none>
  [21:25:27.840] Packages needed by future strategies (n = 0): <none>
  [21:25:27.844] {
  [21:25:27.844]     {
  [21:25:27.844]         ...future.startTime <- base::Sys.time()
  [21:25:27.844]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.844]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.844]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.844]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.844]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.844]         {
  [21:25:27.844]             {
  [21:25:27.844]                 base::local({
  [21:25:27.844]                   has_future <- base::requireNamespace("future", 
  [21:25:27.844]                     quietly = TRUE)
  [21:25:27.844]                   version <- if (has_future) 
  [21:25:27.844]                     utils::packageVersion("future")
  [21:25:27.844]                   else NULL
  [21:25:27.844]                   if (!has_future || version < "1.8.0") {
  [21:25:27.844]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.844]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.844]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.844]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.844]                         "release", "version")], collapse = " "), 
  [21:25:27.844]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.844]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.844]                       info)
  [21:25:27.844]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.844]                     if (!has_future) {
  [21:25:27.844]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.844]                         info)
  [21:25:27.844]                     }
  [21:25:27.844]                     else {
  [21:25:27.844]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.844]                         info, version)
  [21:25:27.844]                     }
  [21:25:27.844]                     base::stop(msg)
  [21:25:27.844]                   }
  [21:25:27.844]                 })
  [21:25:27.844]             }
  [21:25:27.844]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.844]         }
  [21:25:27.844]     }
  [21:25:27.844]     if (base::is.na(TRUE)) {
  [21:25:27.844]     }
  [21:25:27.844]     else {
  [21:25:27.844]         if (TRUE) {
  [21:25:27.844]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.844]                 open = "w")
  [21:25:27.844]         }
  [21:25:27.844]         else {
  [21:25:27.844]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.844]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.844]         }
  [21:25:27.844]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.844]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.844]             base::sink(type = "output", split = FALSE)
  [21:25:27.844]             base::close(...future.stdout)
  [21:25:27.844]         }, add = TRUE)
  [21:25:27.844]     }
  [21:25:27.844]     ...future.frame <- base::sys.nframe()
  [21:25:27.844]     ...future.conditions <- base::list()
  [21:25:27.844]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.844]     ...future.result <- base::tryCatch({
  [21:25:27.844]         base::withCallingHandlers({
  [21:25:27.844]             ...future.value <- base::withVisible(base::local({
  [21:25:27.844]                 4
  [21:25:27.844]             }))
  [21:25:27.844]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.844]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.844]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.844]                 version = "1.8")
  [21:25:27.844]         }, condition = base::local({
  [21:25:27.844]             c <- base::c
  [21:25:27.844]             inherits <- base::inherits
  [21:25:27.844]             invokeRestart <- base::invokeRestart
  [21:25:27.844]             length <- base::length
  [21:25:27.844]             list <- base::list
  [21:25:27.844]             seq.int <- base::seq.int
  [21:25:27.844]             signalCondition <- base::signalCondition
  [21:25:27.844]             sys.calls <- base::sys.calls
  [21:25:27.844]             Sys.time <- base::Sys.time
  [21:25:27.844]             `[[` <- base::`[[`
  [21:25:27.844]             `+` <- base::`+`
  [21:25:27.844]             `<<-` <- base::`<<-`
  [21:25:27.844]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.844]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.844]                   3L)]
  [21:25:27.844]             }
  [21:25:27.844]             function(cond) {
  [21:25:27.844]                 if (inherits(cond, "error")) {
  [21:25:27.844]                   sessionInformation <- function() {
  [21:25:27.844]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.844]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.844]                       search = base::search(), system = base::Sys.info())
  [21:25:27.844]                   }
  [21:25:27.844]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.844]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.844]                     cond$call), session = sessionInformation(), 
  [21:25:27.844]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.844]                   signalCondition(cond)
  [21:25:27.844]                 }
  [21:25:27.844]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.844]                 ))) {
  [21:25:27.844]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.844]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.844]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.844]                   if (!signal) {
  [21:25:27.844]                     muffleCondition <- function (cond) 
  [21:25:27.844]                     {
  [21:25:27.844]                       inherits <- base::inherits
  [21:25:27.844]                       invokeRestart <- base::invokeRestart
  [21:25:27.844]                       muffled <- FALSE
  [21:25:27.844]                       if (inherits(cond, "message")) {
  [21:25:27.844]                         invokeRestart("muffleMessage")
  [21:25:27.844]                         muffled <- TRUE
  [21:25:27.844]                       }
  [21:25:27.844]                       else if (inherits(cond, "warning")) {
  [21:25:27.844]                         invokeRestart("muffleWarning")
  [21:25:27.844]                         muffled <- TRUE
  [21:25:27.844]                       }
  [21:25:27.844]                       else if (inherits(cond, "condition")) {
  [21:25:27.844]                         computeRestarts <- base::computeRestarts
  [21:25:27.844]                         grepl <- base::grepl
  [21:25:27.844]                         is.null <- base::is.null
  [21:25:27.844]                         restarts <- computeRestarts(cond)
  [21:25:27.844]                         for (restart in restarts) {
  [21:25:27.844]                           name <- restart$name
  [21:25:27.844]                           if (is.null(name)) 
  [21:25:27.844]                             next
  [21:25:27.844]                           if (!grepl("^muffle", name)) 
  [21:25:27.844]                             next
  [21:25:27.844]                           invokeRestart(restart)
  [21:25:27.844]                           muffled <- TRUE
  [21:25:27.844]                           break
  [21:25:27.844]                         }
  [21:25:27.844]                       }
  [21:25:27.844]                       invisible(muffled)
  [21:25:27.844]                     }
  [21:25:27.844]                     muffleCondition(cond)
  [21:25:27.844]                   }
  [21:25:27.844]                 }
  [21:25:27.844]             }
  [21:25:27.844]         }))
  [21:25:27.844]     }, error = function(ex) {
  [21:25:27.844]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.844]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.844]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.844]     }, finally = {
  [21:25:27.844]         {
  [21:25:27.844]             NULL
  [21:25:27.844]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.844]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.844]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.844]                 label = NULL, ...) 
  [21:25:27.844]             {
  [21:25:27.844]                 if (substitute) 
  [21:25:27.844]                   expr <- substitute(expr)
  [21:25:27.844]                 local <- as.logical(local)
  [21:25:27.844]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.844]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.844]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.844]                   label = label, ...)
  [21:25:27.844]                 if (!future$lazy) 
  [21:25:27.844]                   future <- run(future)
  [21:25:27.844]                 invisible(future)
  [21:25:27.844]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.844]         }
  [21:25:27.844]         base::options(...future.oldOptions)
  [21:25:27.844]     })
  [21:25:27.844]     Sys.time
  [21:25:27.844]     if (base::is.na(TRUE)) {
  [21:25:27.844]     }
  [21:25:27.844]     else {
  [21:25:27.844]         base::sink(type = "output", split = FALSE)
  [21:25:27.844]         if (TRUE) {
  [21:25:27.844]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.844]         }
  [21:25:27.844]         else {
  [21:25:27.844]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.844]         }
  [21:25:27.844]         base::close(...future.stdout)
  [21:25:27.844]         ...future.stdout <- NULL
  [21:25:27.844]     }
  [21:25:27.844]     ...future.result$conditions <- ...future.conditions
  [21:25:27.844]     ...future.result
  [21:25:27.844] }
  [21:25:27.849] plan(): Setting new future strategy stack:
  [21:25:27.849] List of future strategies:
  [21:25:27.849] 1. sequential:
  [21:25:27.849]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.849]    - tweaked: FALSE
  [21:25:27.849]    - call: NULL
  [21:25:27.850] plan(): nbrOfWorkers() = 1
  [21:25:27.851] plan(): Setting new future strategy stack:
  [21:25:27.851] List of future strategies:
  [21:25:27.851] 1. sequential:
  [21:25:27.851]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.851]    - tweaked: FALSE
  [21:25:27.851]    - call: plan(strategy)
  [21:25:27.852] plan(): nbrOfWorkers() = 1
  [21:25:27.853] SequentialFuture started (and completed)
  <environment: 0x55ef2293dd18> 
  <environment: 0x55ef227aad48> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:27.858] resolve() on environment ...
  [21:25:27.859]  recursive: 0
  [21:25:27.860]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:27.860] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.861] - nx: 4
  [21:25:27.861] - relay: TRUE
  [21:25:27.861] - stdout: TRUE
  [21:25:27.861] - signal: TRUE
  [21:25:27.862] - resignal: FALSE
  [21:25:27.862] - force: TRUE
  [21:25:27.862] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.862] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.863]  - until=2
  [21:25:27.863]  - relaying element #2
  [21:25:27.863] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.863] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.864] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.864]  length: 3 (resolved future 1)
  [21:25:27.864] Future #2
  [21:25:27.865] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:27.865] - nx: 4
  [21:25:27.865] - relay: TRUE
  [21:25:27.865] - stdout: TRUE
  [21:25:27.866] - signal: TRUE
  [21:25:27.866] - resignal: FALSE
  [21:25:27.866] - force: TRUE
  [21:25:27.866] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.867] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.867]  - until=2
  [21:25:27.867]  - relaying element #2
  [21:25:27.868] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.868] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.868] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:27.869]  length: 2 (resolved future 2)
  [21:25:27.869] Future #3
  [21:25:27.869] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:27.870] - nx: 4
  [21:25:27.870] - relay: TRUE
  [21:25:27.870] - stdout: TRUE
  [21:25:27.870] - signal: TRUE
  [21:25:27.871] - resignal: FALSE
  [21:25:27.871] - force: TRUE
  [21:25:27.871] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.871] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.872]  - until=3
  [21:25:27.872]  - relaying element #3
  [21:25:27.872] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.873] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.873] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:27.873]  length: 1 (resolved future 3)
  [21:25:27.874] Future #4
  [21:25:27.874] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:27.874] - nx: 4
  [21:25:27.874] - relay: TRUE
  [21:25:27.877] - stdout: TRUE
  [21:25:27.878] - signal: TRUE
  [21:25:27.878] - resignal: FALSE
  [21:25:27.878] - force: TRUE
  [21:25:27.879] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.879] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.879]  - until=4
  [21:25:27.879]  - relaying element #4
  [21:25:27.880] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.880] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.881] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:27.881]  length: 0 (resolved future 4)
  [21:25:27.881] Relaying remaining futures
  [21:25:27.881] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.882] - nx: 4
  [21:25:27.882] - relay: TRUE
  [21:25:27.882] - stdout: TRUE
  [21:25:27.882] - signal: TRUE
  [21:25:27.883] - resignal: FALSE
  [21:25:27.883] - force: TRUE
  [21:25:27.883] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.884] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:27.884] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.885] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.885] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.885] resolve() on environment ... DONE
  <environment: 0x55ef228819a0> 
  Dimensions: c(2, 1, 3, 1)
  [21:25:27.886] getGlobalsAndPackages() ...
  [21:25:27.887] Searching for globals...
  [21:25:27.887] 
  [21:25:27.888] Searching for globals ... DONE
  [21:25:27.888] - globals: [0] <none>
  [21:25:27.888] getGlobalsAndPackages() ... DONE
  [21:25:27.890] Packages needed by the future expression (n = 0): <none>
  [21:25:27.890] Packages needed by future strategies (n = 0): <none>
  [21:25:27.894] {
  [21:25:27.894]     {
  [21:25:27.894]         ...future.startTime <- base::Sys.time()
  [21:25:27.894]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.894]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.894]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.894]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.894]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.894]         {
  [21:25:27.894]             {
  [21:25:27.894]                 base::local({
  [21:25:27.894]                   has_future <- base::requireNamespace("future", 
  [21:25:27.894]                     quietly = TRUE)
  [21:25:27.894]                   version <- if (has_future) 
  [21:25:27.894]                     utils::packageVersion("future")
  [21:25:27.894]                   else NULL
  [21:25:27.894]                   if (!has_future || version < "1.8.0") {
  [21:25:27.894]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.894]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.894]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.894]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.894]                         "release", "version")], collapse = " "), 
  [21:25:27.894]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.894]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.894]                       info)
  [21:25:27.894]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.894]                     if (!has_future) {
  [21:25:27.894]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.894]                         info)
  [21:25:27.894]                     }
  [21:25:27.894]                     else {
  [21:25:27.894]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.894]                         info, version)
  [21:25:27.894]                     }
  [21:25:27.894]                     base::stop(msg)
  [21:25:27.894]                   }
  [21:25:27.894]                 })
  [21:25:27.894]             }
  [21:25:27.894]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.894]         }
  [21:25:27.894]     }
  [21:25:27.894]     if (base::is.na(TRUE)) {
  [21:25:27.894]     }
  [21:25:27.894]     else {
  [21:25:27.894]         if (TRUE) {
  [21:25:27.894]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.894]                 open = "w")
  [21:25:27.894]         }
  [21:25:27.894]         else {
  [21:25:27.894]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.894]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.894]         }
  [21:25:27.894]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.894]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.894]             base::sink(type = "output", split = FALSE)
  [21:25:27.894]             base::close(...future.stdout)
  [21:25:27.894]         }, add = TRUE)
  [21:25:27.894]     }
  [21:25:27.894]     ...future.frame <- base::sys.nframe()
  [21:25:27.894]     ...future.conditions <- base::list()
  [21:25:27.894]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.894]     ...future.result <- base::tryCatch({
  [21:25:27.894]         base::withCallingHandlers({
  [21:25:27.894]             ...future.value <- base::withVisible(base::local(2))
  [21:25:27.894]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.894]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.894]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.894]                 version = "1.8")
  [21:25:27.894]         }, condition = base::local({
  [21:25:27.894]             c <- base::c
  [21:25:27.894]             inherits <- base::inherits
  [21:25:27.894]             invokeRestart <- base::invokeRestart
  [21:25:27.894]             length <- base::length
  [21:25:27.894]             list <- base::list
  [21:25:27.894]             seq.int <- base::seq.int
  [21:25:27.894]             signalCondition <- base::signalCondition
  [21:25:27.894]             sys.calls <- base::sys.calls
  [21:25:27.894]             Sys.time <- base::Sys.time
  [21:25:27.894]             `[[` <- base::`[[`
  [21:25:27.894]             `+` <- base::`+`
  [21:25:27.894]             `<<-` <- base::`<<-`
  [21:25:27.894]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.894]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.894]                   3L)]
  [21:25:27.894]             }
  [21:25:27.894]             function(cond) {
  [21:25:27.894]                 if (inherits(cond, "error")) {
  [21:25:27.894]                   sessionInformation <- function() {
  [21:25:27.894]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.894]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.894]                       search = base::search(), system = base::Sys.info())
  [21:25:27.894]                   }
  [21:25:27.894]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.894]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.894]                     cond$call), session = sessionInformation(), 
  [21:25:27.894]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.894]                   signalCondition(cond)
  [21:25:27.894]                 }
  [21:25:27.894]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.894]                 ))) {
  [21:25:27.894]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.894]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.894]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.894]                   if (!signal) {
  [21:25:27.894]                     muffleCondition <- function (cond) 
  [21:25:27.894]                     {
  [21:25:27.894]                       inherits <- base::inherits
  [21:25:27.894]                       invokeRestart <- base::invokeRestart
  [21:25:27.894]                       muffled <- FALSE
  [21:25:27.894]                       if (inherits(cond, "message")) {
  [21:25:27.894]                         invokeRestart("muffleMessage")
  [21:25:27.894]                         muffled <- TRUE
  [21:25:27.894]                       }
  [21:25:27.894]                       else if (inherits(cond, "warning")) {
  [21:25:27.894]                         invokeRestart("muffleWarning")
  [21:25:27.894]                         muffled <- TRUE
  [21:25:27.894]                       }
  [21:25:27.894]                       else if (inherits(cond, "condition")) {
  [21:25:27.894]                         computeRestarts <- base::computeRestarts
  [21:25:27.894]                         grepl <- base::grepl
  [21:25:27.894]                         is.null <- base::is.null
  [21:25:27.894]                         restarts <- computeRestarts(cond)
  [21:25:27.894]                         for (restart in restarts) {
  [21:25:27.894]                           name <- restart$name
  [21:25:27.894]                           if (is.null(name)) 
  [21:25:27.894]                             next
  [21:25:27.894]                           if (!grepl("^muffle", name)) 
  [21:25:27.894]                             next
  [21:25:27.894]                           invokeRestart(restart)
  [21:25:27.894]                           muffled <- TRUE
  [21:25:27.894]                           break
  [21:25:27.894]                         }
  [21:25:27.894]                       }
  [21:25:27.894]                       invisible(muffled)
  [21:25:27.894]                     }
  [21:25:27.894]                     muffleCondition(cond)
  [21:25:27.894]                   }
  [21:25:27.894]                 }
  [21:25:27.894]             }
  [21:25:27.894]         }))
  [21:25:27.894]     }, error = function(ex) {
  [21:25:27.894]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.894]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.894]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.894]     }, finally = {
  [21:25:27.894]         {
  [21:25:27.894]             NULL
  [21:25:27.894]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.894]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.894]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.894]                 label = NULL, ...) 
  [21:25:27.894]             {
  [21:25:27.894]                 if (substitute) 
  [21:25:27.894]                   expr <- substitute(expr)
  [21:25:27.894]                 local <- as.logical(local)
  [21:25:27.894]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.894]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.894]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.894]                   label = label, ...)
  [21:25:27.894]                 if (!future$lazy) 
  [21:25:27.894]                   future <- run(future)
  [21:25:27.894]                 invisible(future)
  [21:25:27.894]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.894]         }
  [21:25:27.894]         base::options(...future.oldOptions)
  [21:25:27.894]     })
  [21:25:27.894]     Sys.time
  [21:25:27.894]     if (base::is.na(TRUE)) {
  [21:25:27.894]     }
  [21:25:27.894]     else {
  [21:25:27.894]         base::sink(type = "output", split = FALSE)
  [21:25:27.894]         if (TRUE) {
  [21:25:27.894]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.894]         }
  [21:25:27.894]         else {
  [21:25:27.894]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.894]         }
  [21:25:27.894]         base::close(...future.stdout)
  [21:25:27.894]         ...future.stdout <- NULL
  [21:25:27.894]     }
  [21:25:27.894]     ...future.result$conditions <- ...future.conditions
  [21:25:27.894]     ...future.result
  [21:25:27.894] }
  [21:25:27.899] plan(): Setting new future strategy stack:
  [21:25:27.899] List of future strategies:
  [21:25:27.899] 1. sequential:
  [21:25:27.899]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.899]    - tweaked: FALSE
  [21:25:27.899]    - call: NULL
  [21:25:27.900] plan(): nbrOfWorkers() = 1
  [21:25:27.901] plan(): Setting new future strategy stack:
  [21:25:27.901] List of future strategies:
  [21:25:27.901] 1. sequential:
  [21:25:27.901]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.901]    - tweaked: FALSE
  [21:25:27.901]    - call: plan(strategy)
  [21:25:27.902] plan(): nbrOfWorkers() = 1
  [21:25:27.903] SequentialFuture started (and completed)
  [21:25:27.903] getGlobalsAndPackages() ...
  [21:25:27.903] Searching for globals...
  [21:25:27.904] 
  [21:25:27.904] Searching for globals ... DONE
  [21:25:27.905] - globals: [0] <none>
  [21:25:27.905] getGlobalsAndPackages() ... DONE
  [21:25:27.907] Packages needed by the future expression (n = 0): <none>
  [21:25:27.907] Packages needed by future strategies (n = 0): <none>
  [21:25:27.911] {
  [21:25:27.911]     {
  [21:25:27.911]         ...future.startTime <- base::Sys.time()
  [21:25:27.911]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.911]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.911]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.911]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.911]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.911]         {
  [21:25:27.911]             {
  [21:25:27.911]                 base::local({
  [21:25:27.911]                   has_future <- base::requireNamespace("future", 
  [21:25:27.911]                     quietly = TRUE)
  [21:25:27.911]                   version <- if (has_future) 
  [21:25:27.911]                     utils::packageVersion("future")
  [21:25:27.911]                   else NULL
  [21:25:27.911]                   if (!has_future || version < "1.8.0") {
  [21:25:27.911]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.911]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.911]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.911]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.911]                         "release", "version")], collapse = " "), 
  [21:25:27.911]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.911]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.911]                       info)
  [21:25:27.911]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.911]                     if (!has_future) {
  [21:25:27.911]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.911]                         info)
  [21:25:27.911]                     }
  [21:25:27.911]                     else {
  [21:25:27.911]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.911]                         info, version)
  [21:25:27.911]                     }
  [21:25:27.911]                     base::stop(msg)
  [21:25:27.911]                   }
  [21:25:27.911]                 })
  [21:25:27.911]             }
  [21:25:27.911]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.911]         }
  [21:25:27.911]     }
  [21:25:27.911]     if (base::is.na(TRUE)) {
  [21:25:27.911]     }
  [21:25:27.911]     else {
  [21:25:27.911]         if (TRUE) {
  [21:25:27.911]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.911]                 open = "w")
  [21:25:27.911]         }
  [21:25:27.911]         else {
  [21:25:27.911]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.911]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.911]         }
  [21:25:27.911]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.911]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.911]             base::sink(type = "output", split = FALSE)
  [21:25:27.911]             base::close(...future.stdout)
  [21:25:27.911]         }, add = TRUE)
  [21:25:27.911]     }
  [21:25:27.911]     ...future.frame <- base::sys.nframe()
  [21:25:27.911]     ...future.conditions <- base::list()
  [21:25:27.911]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.911]     ...future.result <- base::tryCatch({
  [21:25:27.911]         base::withCallingHandlers({
  [21:25:27.911]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:27.911]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.911]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.911]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.911]                 version = "1.8")
  [21:25:27.911]         }, condition = base::local({
  [21:25:27.911]             c <- base::c
  [21:25:27.911]             inherits <- base::inherits
  [21:25:27.911]             invokeRestart <- base::invokeRestart
  [21:25:27.911]             length <- base::length
  [21:25:27.911]             list <- base::list
  [21:25:27.911]             seq.int <- base::seq.int
  [21:25:27.911]             signalCondition <- base::signalCondition
  [21:25:27.911]             sys.calls <- base::sys.calls
  [21:25:27.911]             Sys.time <- base::Sys.time
  [21:25:27.911]             `[[` <- base::`[[`
  [21:25:27.911]             `+` <- base::`+`
  [21:25:27.911]             `<<-` <- base::`<<-`
  [21:25:27.911]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.911]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.911]                   3L)]
  [21:25:27.911]             }
  [21:25:27.911]             function(cond) {
  [21:25:27.911]                 if (inherits(cond, "error")) {
  [21:25:27.911]                   sessionInformation <- function() {
  [21:25:27.911]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.911]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.911]                       search = base::search(), system = base::Sys.info())
  [21:25:27.911]                   }
  [21:25:27.911]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.911]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.911]                     cond$call), session = sessionInformation(), 
  [21:25:27.911]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.911]                   signalCondition(cond)
  [21:25:27.911]                 }
  [21:25:27.911]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.911]                 ))) {
  [21:25:27.911]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.911]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.911]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.911]                   if (!signal) {
  [21:25:27.911]                     muffleCondition <- function (cond) 
  [21:25:27.911]                     {
  [21:25:27.911]                       inherits <- base::inherits
  [21:25:27.911]                       invokeRestart <- base::invokeRestart
  [21:25:27.911]                       muffled <- FALSE
  [21:25:27.911]                       if (inherits(cond, "message")) {
  [21:25:27.911]                         invokeRestart("muffleMessage")
  [21:25:27.911]                         muffled <- TRUE
  [21:25:27.911]                       }
  [21:25:27.911]                       else if (inherits(cond, "warning")) {
  [21:25:27.911]                         invokeRestart("muffleWarning")
  [21:25:27.911]                         muffled <- TRUE
  [21:25:27.911]                       }
  [21:25:27.911]                       else if (inherits(cond, "condition")) {
  [21:25:27.911]                         computeRestarts <- base::computeRestarts
  [21:25:27.911]                         grepl <- base::grepl
  [21:25:27.911]                         is.null <- base::is.null
  [21:25:27.911]                         restarts <- computeRestarts(cond)
  [21:25:27.911]                         for (restart in restarts) {
  [21:25:27.911]                           name <- restart$name
  [21:25:27.911]                           if (is.null(name)) 
  [21:25:27.911]                             next
  [21:25:27.911]                           if (!grepl("^muffle", name)) 
  [21:25:27.911]                             next
  [21:25:27.911]                           invokeRestart(restart)
  [21:25:27.911]                           muffled <- TRUE
  [21:25:27.911]                           break
  [21:25:27.911]                         }
  [21:25:27.911]                       }
  [21:25:27.911]                       invisible(muffled)
  [21:25:27.911]                     }
  [21:25:27.911]                     muffleCondition(cond)
  [21:25:27.911]                   }
  [21:25:27.911]                 }
  [21:25:27.911]             }
  [21:25:27.911]         }))
  [21:25:27.911]     }, error = function(ex) {
  [21:25:27.911]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.911]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.911]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.911]     }, finally = {
  [21:25:27.911]         {
  [21:25:27.911]             NULL
  [21:25:27.911]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.911]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.911]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.911]                 label = NULL, ...) 
  [21:25:27.911]             {
  [21:25:27.911]                 if (substitute) 
  [21:25:27.911]                   expr <- substitute(expr)
  [21:25:27.911]                 local <- as.logical(local)
  [21:25:27.911]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.911]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.911]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.911]                   label = label, ...)
  [21:25:27.911]                 if (!future$lazy) 
  [21:25:27.911]                   future <- run(future)
  [21:25:27.911]                 invisible(future)
  [21:25:27.911]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.911]         }
  [21:25:27.911]         base::options(...future.oldOptions)
  [21:25:27.911]     })
  [21:25:27.911]     Sys.time
  [21:25:27.911]     if (base::is.na(TRUE)) {
  [21:25:27.911]     }
  [21:25:27.911]     else {
  [21:25:27.911]         base::sink(type = "output", split = FALSE)
  [21:25:27.911]         if (TRUE) {
  [21:25:27.911]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.911]         }
  [21:25:27.911]         else {
  [21:25:27.911]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.911]         }
  [21:25:27.911]         base::close(...future.stdout)
  [21:25:27.911]         ...future.stdout <- NULL
  [21:25:27.911]     }
  [21:25:27.911]     ...future.result$conditions <- ...future.conditions
  [21:25:27.911]     ...future.result
  [21:25:27.911] }
  [21:25:27.916] plan(): Setting new future strategy stack:
  [21:25:27.916] List of future strategies:
  [21:25:27.916] 1. sequential:
  [21:25:27.916]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.916]    - tweaked: FALSE
  [21:25:27.916]    - call: NULL
  [21:25:27.917] plan(): nbrOfWorkers() = 1
  [21:25:27.918] plan(): Setting new future strategy stack:
  [21:25:27.918] List of future strategies:
  [21:25:27.918] 1. sequential:
  [21:25:27.918]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.918]    - tweaked: FALSE
  [21:25:27.918]    - call: plan(strategy)
  [21:25:27.919] plan(): nbrOfWorkers() = 1
  [21:25:27.920] SequentialFuture started (and completed)
  [21:25:27.921] getGlobalsAndPackages() ...
  [21:25:27.921] Searching for globals...
  [21:25:27.922] - globals found: [1] '{'
  [21:25:27.923] Searching for globals ... DONE
  [21:25:27.923] Resolving globals: FALSE
  [21:25:27.924] 
  [21:25:27.924] 
  [21:25:27.924] getGlobalsAndPackages() ... DONE
  [21:25:27.926] Packages needed by the future expression (n = 0): <none>
  [21:25:27.926] Packages needed by future strategies (n = 0): <none>
  [21:25:27.931] {
  [21:25:27.931]     {
  [21:25:27.931]         ...future.startTime <- base::Sys.time()
  [21:25:27.931]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:27.931]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:27.931]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:27.931]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:27.931]             future.resolve.recursive = NULL, width = 80L)
  [21:25:27.931]         {
  [21:25:27.931]             {
  [21:25:27.931]                 base::local({
  [21:25:27.931]                   has_future <- base::requireNamespace("future", 
  [21:25:27.931]                     quietly = TRUE)
  [21:25:27.931]                   version <- if (has_future) 
  [21:25:27.931]                     utils::packageVersion("future")
  [21:25:27.931]                   else NULL
  [21:25:27.931]                   if (!has_future || version < "1.8.0") {
  [21:25:27.931]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:27.931]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:27.931]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:27.931]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:27.931]                         "release", "version")], collapse = " "), 
  [21:25:27.931]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:27.931]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:27.931]                       info)
  [21:25:27.931]                     info <- base::paste(info, collapse = "; ")
  [21:25:27.931]                     if (!has_future) {
  [21:25:27.931]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:27.931]                         info)
  [21:25:27.931]                     }
  [21:25:27.931]                     else {
  [21:25:27.931]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:27.931]                         info, version)
  [21:25:27.931]                     }
  [21:25:27.931]                     base::stop(msg)
  [21:25:27.931]                   }
  [21:25:27.931]                 })
  [21:25:27.931]             }
  [21:25:27.931]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:27.931]         }
  [21:25:27.931]     }
  [21:25:27.931]     if (base::is.na(TRUE)) {
  [21:25:27.931]     }
  [21:25:27.931]     else {
  [21:25:27.931]         if (TRUE) {
  [21:25:27.931]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:27.931]                 open = "w")
  [21:25:27.931]         }
  [21:25:27.931]         else {
  [21:25:27.931]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:27.931]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:27.931]         }
  [21:25:27.931]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:27.931]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:27.931]             base::sink(type = "output", split = FALSE)
  [21:25:27.931]             base::close(...future.stdout)
  [21:25:27.931]         }, add = TRUE)
  [21:25:27.931]     }
  [21:25:27.931]     ...future.frame <- base::sys.nframe()
  [21:25:27.931]     ...future.conditions <- base::list()
  [21:25:27.931]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:27.931]     ...future.result <- base::tryCatch({
  [21:25:27.931]         base::withCallingHandlers({
  [21:25:27.931]             ...future.value <- base::withVisible(base::local({
  [21:25:27.931]                 4
  [21:25:27.931]             }))
  [21:25:27.931]             future::FutureResult(value = ...future.value$value, 
  [21:25:27.931]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.931]                   ...future.rng), started = ...future.startTime, 
  [21:25:27.931]                 version = "1.8")
  [21:25:27.931]         }, condition = base::local({
  [21:25:27.931]             c <- base::c
  [21:25:27.931]             inherits <- base::inherits
  [21:25:27.931]             invokeRestart <- base::invokeRestart
  [21:25:27.931]             length <- base::length
  [21:25:27.931]             list <- base::list
  [21:25:27.931]             seq.int <- base::seq.int
  [21:25:27.931]             signalCondition <- base::signalCondition
  [21:25:27.931]             sys.calls <- base::sys.calls
  [21:25:27.931]             Sys.time <- base::Sys.time
  [21:25:27.931]             `[[` <- base::`[[`
  [21:25:27.931]             `+` <- base::`+`
  [21:25:27.931]             `<<-` <- base::`<<-`
  [21:25:27.931]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:27.931]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:27.931]                   3L)]
  [21:25:27.931]             }
  [21:25:27.931]             function(cond) {
  [21:25:27.931]                 if (inherits(cond, "error")) {
  [21:25:27.931]                   sessionInformation <- function() {
  [21:25:27.931]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:27.931]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:27.931]                       search = base::search(), system = base::Sys.info())
  [21:25:27.931]                   }
  [21:25:27.931]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.931]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:27.931]                     cond$call), session = sessionInformation(), 
  [21:25:27.931]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:27.931]                   signalCondition(cond)
  [21:25:27.931]                 }
  [21:25:27.931]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:27.931]                 ))) {
  [21:25:27.931]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:27.931]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:27.931]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:27.931]                   if (!signal) {
  [21:25:27.931]                     muffleCondition <- function (cond) 
  [21:25:27.931]                     {
  [21:25:27.931]                       inherits <- base::inherits
  [21:25:27.931]                       invokeRestart <- base::invokeRestart
  [21:25:27.931]                       muffled <- FALSE
  [21:25:27.931]                       if (inherits(cond, "message")) {
  [21:25:27.931]                         invokeRestart("muffleMessage")
  [21:25:27.931]                         muffled <- TRUE
  [21:25:27.931]                       }
  [21:25:27.931]                       else if (inherits(cond, "warning")) {
  [21:25:27.931]                         invokeRestart("muffleWarning")
  [21:25:27.931]                         muffled <- TRUE
  [21:25:27.931]                       }
  [21:25:27.931]                       else if (inherits(cond, "condition")) {
  [21:25:27.931]                         computeRestarts <- base::computeRestarts
  [21:25:27.931]                         grepl <- base::grepl
  [21:25:27.931]                         is.null <- base::is.null
  [21:25:27.931]                         restarts <- computeRestarts(cond)
  [21:25:27.931]                         for (restart in restarts) {
  [21:25:27.931]                           name <- restart$name
  [21:25:27.931]                           if (is.null(name)) 
  [21:25:27.931]                             next
  [21:25:27.931]                           if (!grepl("^muffle", name)) 
  [21:25:27.931]                             next
  [21:25:27.931]                           invokeRestart(restart)
  [21:25:27.931]                           muffled <- TRUE
  [21:25:27.931]                           break
  [21:25:27.931]                         }
  [21:25:27.931]                       }
  [21:25:27.931]                       invisible(muffled)
  [21:25:27.931]                     }
  [21:25:27.931]                     muffleCondition(cond)
  [21:25:27.931]                   }
  [21:25:27.931]                 }
  [21:25:27.931]             }
  [21:25:27.931]         }))
  [21:25:27.931]     }, error = function(ex) {
  [21:25:27.931]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:27.931]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:27.931]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:27.931]     }, finally = {
  [21:25:27.931]         {
  [21:25:27.931]             NULL
  [21:25:27.931]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:27.931]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:27.931]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:27.931]                 label = NULL, ...) 
  [21:25:27.931]             {
  [21:25:27.931]                 if (substitute) 
  [21:25:27.931]                   expr <- substitute(expr)
  [21:25:27.931]                 local <- as.logical(local)
  [21:25:27.931]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:27.931]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:27.931]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:27.931]                   label = label, ...)
  [21:25:27.931]                 if (!future$lazy) 
  [21:25:27.931]                   future <- run(future)
  [21:25:27.931]                 invisible(future)
  [21:25:27.931]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:27.931]         }
  [21:25:27.931]         base::options(...future.oldOptions)
  [21:25:27.931]     })
  [21:25:27.931]     Sys.time
  [21:25:27.931]     if (base::is.na(TRUE)) {
  [21:25:27.931]     }
  [21:25:27.931]     else {
  [21:25:27.931]         base::sink(type = "output", split = FALSE)
  [21:25:27.931]         if (TRUE) {
  [21:25:27.931]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:27.931]         }
  [21:25:27.931]         else {
  [21:25:27.931]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:27.931]         }
  [21:25:27.931]         base::close(...future.stdout)
  [21:25:27.931]         ...future.stdout <- NULL
  [21:25:27.931]     }
  [21:25:27.931]     ...future.result$conditions <- ...future.conditions
  [21:25:27.931]     ...future.result
  [21:25:27.931] }
  [21:25:27.935] plan(): Setting new future strategy stack:
  [21:25:27.936] List of future strategies:
  [21:25:27.936] 1. sequential:
  [21:25:27.936]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.936]    - tweaked: FALSE
  [21:25:27.936]    - call: NULL
  [21:25:27.937] plan(): nbrOfWorkers() = 1
  [21:25:27.938] plan(): Setting new future strategy stack:
  [21:25:27.938] List of future strategies:
  [21:25:27.938] 1. sequential:
  [21:25:27.938]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.938]    - tweaked: FALSE
  [21:25:27.938]    - call: plan(strategy)
  [21:25:27.939] plan(): nbrOfWorkers() = 1
  [21:25:27.939] SequentialFuture started (and completed)
  <environment: 0x55ef21620718> 
  <environment: 0x55ef22aee9a8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:27.949] resolve() on environment ...
  [21:25:27.949]  recursive: 0
  [21:25:27.950]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:27.950] signalConditionsASAP(numeric, pos=1) ...
  [21:25:27.951] - nx: 4
  [21:25:27.951] - relay: TRUE
  [21:25:27.951] - stdout: TRUE
  [21:25:27.951] - signal: TRUE
  [21:25:27.952] - resignal: FALSE
  [21:25:27.952] - force: TRUE
  [21:25:27.952] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.952] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.953]  - until=2
  [21:25:27.953]  - relaying element #2
  [21:25:27.953] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.953] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.954] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:27.954]  length: 3 (resolved future 1)
  [21:25:27.954] Future #2
  [21:25:27.955] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:27.955] - nx: 4
  [21:25:27.955] - relay: TRUE
  [21:25:27.955] - stdout: TRUE
  [21:25:27.956] - signal: TRUE
  [21:25:27.956] - resignal: FALSE
  [21:25:27.956] - force: TRUE
  [21:25:27.956] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:27.957] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:27.957]  - until=2
  [21:25:27.957]  - relaying element #2
  [21:25:27.958] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.958] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.958] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:27.959]  length: 2 (resolved future 2)
  [21:25:27.959] Future #3
  [21:25:27.959] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:27.960] - nx: 4
  [21:25:27.960] - relay: TRUE
  [21:25:27.960] - stdout: TRUE
  [21:25:27.960] - signal: TRUE
  [21:25:27.961] - resignal: FALSE
  [21:25:27.961] - force: TRUE
  [21:25:27.961] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:27.961] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:27.962]  - until=3
  [21:25:27.962]  - relaying element #3
  [21:25:27.962] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.963] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.963] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:27.963]  length: 1 (resolved future 3)
  [21:25:27.964] Future #4
  [21:25:27.964] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:27.964] - nx: 4
  [21:25:27.965] - relay: TRUE
  [21:25:27.965] - stdout: TRUE
  [21:25:27.965] - signal: TRUE
  [21:25:27.965] - resignal: FALSE
  [21:25:27.966] - force: TRUE
  [21:25:27.967] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:27.968] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:27.968]  - until=4
  [21:25:27.968]  - relaying element #4
  [21:25:27.969] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.969] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.969] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:27.970]  length: 0 (resolved future 4)
  [21:25:27.970] Relaying remaining futures
  [21:25:27.970] signalConditionsASAP(NULL, pos=0) ...
  [21:25:27.970] - nx: 4
  [21:25:27.971] - relay: TRUE
  [21:25:27.971] - stdout: TRUE
  [21:25:27.971] - signal: TRUE
  [21:25:27.971] - resignal: FALSE
  [21:25:27.972] - force: TRUE
  [21:25:27.972] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.972] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:27.973] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:27.973] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:27.973] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:27.974] resolve() on environment ... DONE
  <environment: 0x55ef21412880> 
  Type of future: cluster
  [21:25:27.975] plan(): Setting new future strategy stack:
  [21:25:27.975] List of future strategies:
  [21:25:27.975] 1. cluster:
  [21:25:27.975]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.975]    - tweaked: FALSE
  [21:25:27.975]    - call: plan(strategy)
  [21:25:27.976] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [21:25:27.976] cluster:
  [21:25:27.976] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:25:27.976] - tweaked: FALSE
  [21:25:27.976] - call: plan(strategy)
  [21:25:27.977] getGlobalsAndPackages() ...
  [21:25:27.978] Not searching for globals
  [21:25:27.978] - globals: [0] <none>
  [21:25:27.978] getGlobalsAndPackages() ... DONE
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 24112
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c36478850.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c36478850.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futures.R:gimli2:hornik:32556' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpjgX7MW/future.parent=32556.7f2c36478850.pid")), silent = TRUE)' -e 'workRSOCK <- tryCatch(parallel:::.slaveRSOCK, error=function(e) parallel:::.workRSOCK); workRSOCK()' MASTER=localhost PORT=24112 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 1 ... done
  [21:25:29.377] Packages needed by the future expression (n = 0): <none>
  [21:25:29.377] Packages needed by future strategies (n = 0): <none>
  [21:25:29.382] {
  [21:25:29.382]     {
  [21:25:29.382]         ...future.startTime <- base::Sys.time()
  [21:25:29.382]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.382]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.382]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.382]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.382]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.382]         {
  [21:25:29.382]             {
  [21:25:29.382]                 base::local({
  [21:25:29.382]                   has_future <- base::requireNamespace("future", 
  [21:25:29.382]                     quietly = TRUE)
  [21:25:29.382]                   version <- if (has_future) 
  [21:25:29.382]                     utils::packageVersion("future")
  [21:25:29.382]                   else NULL
  [21:25:29.382]                   if (!has_future || version < "1.8.0") {
  [21:25:29.382]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.382]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.382]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.382]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.382]                         "release", "version")], collapse = " "), 
  [21:25:29.382]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.382]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.382]                       info)
  [21:25:29.382]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.382]                     if (!has_future) {
  [21:25:29.382]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.382]                         info)
  [21:25:29.382]                     }
  [21:25:29.382]                     else {
  [21:25:29.382]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.382]                         info, version)
  [21:25:29.382]                     }
  [21:25:29.382]                     base::stop(msg)
  [21:25:29.382]                   }
  [21:25:29.382]                 })
  [21:25:29.382]             }
  [21:25:29.382]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.382]         }
  [21:25:29.382]     }
  [21:25:29.382]     if (base::is.na(TRUE)) {
  [21:25:29.382]     }
  [21:25:29.382]     else {
  [21:25:29.382]         if (TRUE) {
  [21:25:29.382]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.382]                 open = "w")
  [21:25:29.382]         }
  [21:25:29.382]         else {
  [21:25:29.382]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.382]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.382]         }
  [21:25:29.382]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.382]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.382]             base::sink(type = "output", split = FALSE)
  [21:25:29.382]             base::close(...future.stdout)
  [21:25:29.382]         }, add = TRUE)
  [21:25:29.382]     }
  [21:25:29.382]     ...future.frame <- base::sys.nframe()
  [21:25:29.382]     ...future.conditions <- base::list()
  [21:25:29.382]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.382]     ...future.result <- base::tryCatch({
  [21:25:29.382]         base::withCallingHandlers({
  [21:25:29.382]             ...future.value <- base::withVisible(base::local({
  [21:25:29.382]                 ...future.sendCondition <- local({
  [21:25:29.382]                   sendCondition <- NULL
  [21:25:29.382]                   function(frame = 1L) {
  [21:25:29.382]                     if (is.function(sendCondition)) 
  [21:25:29.382]                       return(sendCondition)
  [21:25:29.382]                     ns <- getNamespace("parallel")
  [21:25:29.382]                     if (exists("sendData", mode = "function", 
  [21:25:29.382]                       envir = ns)) {
  [21:25:29.382]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.382]                         envir = ns)
  [21:25:29.382]                       envir <- sys.frame(frame)
  [21:25:29.382]                       master <- NULL
  [21:25:29.382]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.382]                         !identical(envir, emptyenv())) {
  [21:25:29.382]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.382]                           inherits = FALSE)) {
  [21:25:29.382]                           master <- get("master", mode = "list", 
  [21:25:29.382]                             envir = envir, inherits = FALSE)
  [21:25:29.382]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.382]                             sendCondition <<- function(cond) {
  [21:25:29.382]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.382]                                 success = TRUE)
  [21:25:29.382]                               parallel_sendData(master, data)
  [21:25:29.382]                             }
  [21:25:29.382]                             return(sendCondition)
  [21:25:29.382]                           }
  [21:25:29.382]                         }
  [21:25:29.382]                         frame <- frame + 1L
  [21:25:29.382]                         envir <- sys.frame(frame)
  [21:25:29.382]                       }
  [21:25:29.382]                     }
  [21:25:29.382]                     sendCondition <<- function(cond) NULL
  [21:25:29.382]                   }
  [21:25:29.382]                 })
  [21:25:29.382]                 withCallingHandlers({
  [21:25:29.382]                   NA
  [21:25:29.382]                 }, immediateCondition = function(cond) {
  [21:25:29.382]                   sendCondition <- ...future.sendCondition()
  [21:25:29.382]                   sendCondition(cond)
  [21:25:29.382]                   muffleCondition <- function (cond) 
  [21:25:29.382]                   {
  [21:25:29.382]                     inherits <- base::inherits
  [21:25:29.382]                     invokeRestart <- base::invokeRestart
  [21:25:29.382]                     muffled <- FALSE
  [21:25:29.382]                     if (inherits(cond, "message")) {
  [21:25:29.382]                       invokeRestart("muffleMessage")
  [21:25:29.382]                       muffled <- TRUE
  [21:25:29.382]                     }
  [21:25:29.382]                     else if (inherits(cond, "warning")) {
  [21:25:29.382]                       invokeRestart("muffleWarning")
  [21:25:29.382]                       muffled <- TRUE
  [21:25:29.382]                     }
  [21:25:29.382]                     else if (inherits(cond, "condition")) {
  [21:25:29.382]                       computeRestarts <- base::computeRestarts
  [21:25:29.382]                       grepl <- base::grepl
  [21:25:29.382]                       is.null <- base::is.null
  [21:25:29.382]                       restarts <- computeRestarts(cond)
  [21:25:29.382]                       for (restart in restarts) {
  [21:25:29.382]                         name <- restart$name
  [21:25:29.382]                         if (is.null(name)) 
  [21:25:29.382]                           next
  [21:25:29.382]                         if (!grepl("^muffle", name)) 
  [21:25:29.382]                           next
  [21:25:29.382]                         invokeRestart(restart)
  [21:25:29.382]                         muffled <- TRUE
  [21:25:29.382]                         break
  [21:25:29.382]                       }
  [21:25:29.382]                     }
  [21:25:29.382]                     invisible(muffled)
  [21:25:29.382]                   }
  [21:25:29.382]                   muffleCondition(cond)
  [21:25:29.382]                 })
  [21:25:29.382]             }))
  [21:25:29.382]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.382]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.382]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.382]                 version = "1.8")
  [21:25:29.382]         }, condition = base::local({
  [21:25:29.382]             c <- base::c
  [21:25:29.382]             inherits <- base::inherits
  [21:25:29.382]             invokeRestart <- base::invokeRestart
  [21:25:29.382]             length <- base::length
  [21:25:29.382]             list <- base::list
  [21:25:29.382]             seq.int <- base::seq.int
  [21:25:29.382]             signalCondition <- base::signalCondition
  [21:25:29.382]             sys.calls <- base::sys.calls
  [21:25:29.382]             Sys.time <- base::Sys.time
  [21:25:29.382]             `[[` <- base::`[[`
  [21:25:29.382]             `+` <- base::`+`
  [21:25:29.382]             `<<-` <- base::`<<-`
  [21:25:29.382]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.382]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.382]                   3L)]
  [21:25:29.382]             }
  [21:25:29.382]             function(cond) {
  [21:25:29.382]                 if (inherits(cond, "error")) {
  [21:25:29.382]                   sessionInformation <- function() {
  [21:25:29.382]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.382]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.382]                       search = base::search(), system = base::Sys.info())
  [21:25:29.382]                   }
  [21:25:29.382]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.382]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.382]                     cond$call), session = sessionInformation(), 
  [21:25:29.382]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.382]                   signalCondition(cond)
  [21:25:29.382]                 }
  [21:25:29.382]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.382]                 ))) {
  [21:25:29.382]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.382]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.382]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.382]                   if (!signal) {
  [21:25:29.382]                     muffleCondition <- function (cond) 
  [21:25:29.382]                     {
  [21:25:29.382]                       inherits <- base::inherits
  [21:25:29.382]                       invokeRestart <- base::invokeRestart
  [21:25:29.382]                       muffled <- FALSE
  [21:25:29.382]                       if (inherits(cond, "message")) {
  [21:25:29.382]                         invokeRestart("muffleMessage")
  [21:25:29.382]                         muffled <- TRUE
  [21:25:29.382]                       }
  [21:25:29.382]                       else if (inherits(cond, "warning")) {
  [21:25:29.382]                         invokeRestart("muffleWarning")
  [21:25:29.382]                         muffled <- TRUE
  [21:25:29.382]                       }
  [21:25:29.382]                       else if (inherits(cond, "condition")) {
  [21:25:29.382]                         computeRestarts <- base::computeRestarts
  [21:25:29.382]                         grepl <- base::grepl
  [21:25:29.382]                         is.null <- base::is.null
  [21:25:29.382]                         restarts <- computeRestarts(cond)
  [21:25:29.382]                         for (restart in restarts) {
  [21:25:29.382]                           name <- restart$name
  [21:25:29.382]                           if (is.null(name)) 
  [21:25:29.382]                             next
  [21:25:29.382]                           if (!grepl("^muffle", name)) 
  [21:25:29.382]                             next
  [21:25:29.382]                           invokeRestart(restart)
  [21:25:29.382]                           muffled <- TRUE
  [21:25:29.382]                           break
  [21:25:29.382]                         }
  [21:25:29.382]                       }
  [21:25:29.382]                       invisible(muffled)
  [21:25:29.382]                     }
  [21:25:29.382]                     muffleCondition(cond)
  [21:25:29.382]                   }
  [21:25:29.382]                 }
  [21:25:29.382]             }
  [21:25:29.382]         }))
  [21:25:29.382]     }, error = function(ex) {
  [21:25:29.382]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.382]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.382]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.382]     }, finally = {
  [21:25:29.382]         {
  [21:25:29.382]             NULL
  [21:25:29.382]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.382]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.382]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.382]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.382]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.382]                 ...) 
  [21:25:29.382]             {
  [21:25:29.382]                 if (substitute) 
  [21:25:29.382]                   expr <- substitute(expr)
  [21:25:29.382]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.382]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.382]                   globals = globals, persistent = persistent, 
  [21:25:29.382]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.382]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.382]                   label = label, ...)
  [21:25:29.382]                 if (!future$lazy) 
  [21:25:29.382]                   future <- run(future)
  [21:25:29.382]                 invisible(future)
  [21:25:29.382]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.382]         }
  [21:25:29.382]         base::options(...future.oldOptions)
  [21:25:29.382]     })
  [21:25:29.382]     Sys.time
  [21:25:29.382]     if (base::is.na(TRUE)) {
  [21:25:29.382]     }
  [21:25:29.382]     else {
  [21:25:29.382]         base::sink(type = "output", split = FALSE)
  [21:25:29.382]         if (TRUE) {
  [21:25:29.382]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.382]         }
  [21:25:29.382]         else {
  [21:25:29.382]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.382]         }
  [21:25:29.382]         base::close(...future.stdout)
  [21:25:29.382]         ...future.stdout <- NULL
  [21:25:29.382]     }
  [21:25:29.382]     ...future.result$conditions <- ...future.conditions
  [21:25:29.382]     ...future.result
  [21:25:29.382] }
  [21:25:29.389] ClusterFuture started
  [21:25:29.389] result() for ClusterFuture ...
  [21:25:29.389] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:29.390] - Validating connection of ClusterFuture
  [21:25:29.559] - received message: FutureResult
  [21:25:29.560] - Received FutureResult
  [21:25:29.560] - Erased future from FutureRegistry
  [21:25:29.561] result() for ClusterFuture ...
  [21:25:29.561] - result already collected: FutureResult
  [21:25:29.561] result() for ClusterFuture ... done
  [21:25:29.562] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:29.562] result() for ClusterFuture ... done
  [21:25:29.562] result() for ClusterFuture ...
  [21:25:29.563] - result already collected: FutureResult
  [21:25:29.563] result() for ClusterFuture ... done
  [21:25:29.563] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [21:25:29.565] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [21:25:29.565] getGlobalsAndPackages() ...
  [21:25:29.565] Searching for globals...
  [21:25:29.566] 
  [21:25:29.567] Searching for globals ... DONE
  [21:25:29.567] - globals: [0] <none>
  [21:25:29.567] getGlobalsAndPackages() ... DONE
  [21:25:29.572] Packages needed by the future expression (n = 0): <none>
  [21:25:29.593] Packages needed by future strategies (n = 0): <none>
  [21:25:29.598] {
  [21:25:29.598]     {
  [21:25:29.598]         ...future.startTime <- base::Sys.time()
  [21:25:29.598]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.598]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.598]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.598]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.598]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.598]         {
  [21:25:29.598]             {
  [21:25:29.598]                 base::local({
  [21:25:29.598]                   has_future <- base::requireNamespace("future", 
  [21:25:29.598]                     quietly = TRUE)
  [21:25:29.598]                   version <- if (has_future) 
  [21:25:29.598]                     utils::packageVersion("future")
  [21:25:29.598]                   else NULL
  [21:25:29.598]                   if (!has_future || version < "1.8.0") {
  [21:25:29.598]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.598]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.598]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.598]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.598]                         "release", "version")], collapse = " "), 
  [21:25:29.598]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.598]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.598]                       info)
  [21:25:29.598]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.598]                     if (!has_future) {
  [21:25:29.598]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.598]                         info)
  [21:25:29.598]                     }
  [21:25:29.598]                     else {
  [21:25:29.598]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.598]                         info, version)
  [21:25:29.598]                     }
  [21:25:29.598]                     base::stop(msg)
  [21:25:29.598]                   }
  [21:25:29.598]                 })
  [21:25:29.598]             }
  [21:25:29.598]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.598]         }
  [21:25:29.598]     }
  [21:25:29.598]     if (base::is.na(TRUE)) {
  [21:25:29.598]     }
  [21:25:29.598]     else {
  [21:25:29.598]         if (TRUE) {
  [21:25:29.598]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.598]                 open = "w")
  [21:25:29.598]         }
  [21:25:29.598]         else {
  [21:25:29.598]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.598]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.598]         }
  [21:25:29.598]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.598]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.598]             base::sink(type = "output", split = FALSE)
  [21:25:29.598]             base::close(...future.stdout)
  [21:25:29.598]         }, add = TRUE)
  [21:25:29.598]     }
  [21:25:29.598]     ...future.frame <- base::sys.nframe()
  [21:25:29.598]     ...future.conditions <- base::list()
  [21:25:29.598]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.598]     ...future.result <- base::tryCatch({
  [21:25:29.598]         base::withCallingHandlers({
  [21:25:29.598]             ...future.value <- base::withVisible(base::local({
  [21:25:29.598]                 ...future.sendCondition <- local({
  [21:25:29.598]                   sendCondition <- NULL
  [21:25:29.598]                   function(frame = 1L) {
  [21:25:29.598]                     if (is.function(sendCondition)) 
  [21:25:29.598]                       return(sendCondition)
  [21:25:29.598]                     ns <- getNamespace("parallel")
  [21:25:29.598]                     if (exists("sendData", mode = "function", 
  [21:25:29.598]                       envir = ns)) {
  [21:25:29.598]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.598]                         envir = ns)
  [21:25:29.598]                       envir <- sys.frame(frame)
  [21:25:29.598]                       master <- NULL
  [21:25:29.598]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.598]                         !identical(envir, emptyenv())) {
  [21:25:29.598]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.598]                           inherits = FALSE)) {
  [21:25:29.598]                           master <- get("master", mode = "list", 
  [21:25:29.598]                             envir = envir, inherits = FALSE)
  [21:25:29.598]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.598]                             sendCondition <<- function(cond) {
  [21:25:29.598]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.598]                                 success = TRUE)
  [21:25:29.598]                               parallel_sendData(master, data)
  [21:25:29.598]                             }
  [21:25:29.598]                             return(sendCondition)
  [21:25:29.598]                           }
  [21:25:29.598]                         }
  [21:25:29.598]                         frame <- frame + 1L
  [21:25:29.598]                         envir <- sys.frame(frame)
  [21:25:29.598]                       }
  [21:25:29.598]                     }
  [21:25:29.598]                     sendCondition <<- function(cond) NULL
  [21:25:29.598]                   }
  [21:25:29.598]                 })
  [21:25:29.598]                 withCallingHandlers({
  [21:25:29.598]                   2
  [21:25:29.598]                 }, immediateCondition = function(cond) {
  [21:25:29.598]                   sendCondition <- ...future.sendCondition()
  [21:25:29.598]                   sendCondition(cond)
  [21:25:29.598]                   muffleCondition <- function (cond) 
  [21:25:29.598]                   {
  [21:25:29.598]                     inherits <- base::inherits
  [21:25:29.598]                     invokeRestart <- base::invokeRestart
  [21:25:29.598]                     muffled <- FALSE
  [21:25:29.598]                     if (inherits(cond, "message")) {
  [21:25:29.598]                       invokeRestart("muffleMessage")
  [21:25:29.598]                       muffled <- TRUE
  [21:25:29.598]                     }
  [21:25:29.598]                     else if (inherits(cond, "warning")) {
  [21:25:29.598]                       invokeRestart("muffleWarning")
  [21:25:29.598]                       muffled <- TRUE
  [21:25:29.598]                     }
  [21:25:29.598]                     else if (inherits(cond, "condition")) {
  [21:25:29.598]                       computeRestarts <- base::computeRestarts
  [21:25:29.598]                       grepl <- base::grepl
  [21:25:29.598]                       is.null <- base::is.null
  [21:25:29.598]                       restarts <- computeRestarts(cond)
  [21:25:29.598]                       for (restart in restarts) {
  [21:25:29.598]                         name <- restart$name
  [21:25:29.598]                         if (is.null(name)) 
  [21:25:29.598]                           next
  [21:25:29.598]                         if (!grepl("^muffle", name)) 
  [21:25:29.598]                           next
  [21:25:29.598]                         invokeRestart(restart)
  [21:25:29.598]                         muffled <- TRUE
  [21:25:29.598]                         break
  [21:25:29.598]                       }
  [21:25:29.598]                     }
  [21:25:29.598]                     invisible(muffled)
  [21:25:29.598]                   }
  [21:25:29.598]                   muffleCondition(cond)
  [21:25:29.598]                 })
  [21:25:29.598]             }))
  [21:25:29.598]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.598]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.598]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.598]                 version = "1.8")
  [21:25:29.598]         }, condition = base::local({
  [21:25:29.598]             c <- base::c
  [21:25:29.598]             inherits <- base::inherits
  [21:25:29.598]             invokeRestart <- base::invokeRestart
  [21:25:29.598]             length <- base::length
  [21:25:29.598]             list <- base::list
  [21:25:29.598]             seq.int <- base::seq.int
  [21:25:29.598]             signalCondition <- base::signalCondition
  [21:25:29.598]             sys.calls <- base::sys.calls
  [21:25:29.598]             Sys.time <- base::Sys.time
  [21:25:29.598]             `[[` <- base::`[[`
  [21:25:29.598]             `+` <- base::`+`
  [21:25:29.598]             `<<-` <- base::`<<-`
  [21:25:29.598]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.598]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.598]                   3L)]
  [21:25:29.598]             }
  [21:25:29.598]             function(cond) {
  [21:25:29.598]                 if (inherits(cond, "error")) {
  [21:25:29.598]                   sessionInformation <- function() {
  [21:25:29.598]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.598]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.598]                       search = base::search(), system = base::Sys.info())
  [21:25:29.598]                   }
  [21:25:29.598]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.598]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.598]                     cond$call), session = sessionInformation(), 
  [21:25:29.598]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.598]                   signalCondition(cond)
  [21:25:29.598]                 }
  [21:25:29.598]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.598]                 ))) {
  [21:25:29.598]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.598]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.598]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.598]                   if (!signal) {
  [21:25:29.598]                     muffleCondition <- function (cond) 
  [21:25:29.598]                     {
  [21:25:29.598]                       inherits <- base::inherits
  [21:25:29.598]                       invokeRestart <- base::invokeRestart
  [21:25:29.598]                       muffled <- FALSE
  [21:25:29.598]                       if (inherits(cond, "message")) {
  [21:25:29.598]                         invokeRestart("muffleMessage")
  [21:25:29.598]                         muffled <- TRUE
  [21:25:29.598]                       }
  [21:25:29.598]                       else if (inherits(cond, "warning")) {
  [21:25:29.598]                         invokeRestart("muffleWarning")
  [21:25:29.598]                         muffled <- TRUE
  [21:25:29.598]                       }
  [21:25:29.598]                       else if (inherits(cond, "condition")) {
  [21:25:29.598]                         computeRestarts <- base::computeRestarts
  [21:25:29.598]                         grepl <- base::grepl
  [21:25:29.598]                         is.null <- base::is.null
  [21:25:29.598]                         restarts <- computeRestarts(cond)
  [21:25:29.598]                         for (restart in restarts) {
  [21:25:29.598]                           name <- restart$name
  [21:25:29.598]                           if (is.null(name)) 
  [21:25:29.598]                             next
  [21:25:29.598]                           if (!grepl("^muffle", name)) 
  [21:25:29.598]                             next
  [21:25:29.598]                           invokeRestart(restart)
  [21:25:29.598]                           muffled <- TRUE
  [21:25:29.598]                           break
  [21:25:29.598]                         }
  [21:25:29.598]                       }
  [21:25:29.598]                       invisible(muffled)
  [21:25:29.598]                     }
  [21:25:29.598]                     muffleCondition(cond)
  [21:25:29.598]                   }
  [21:25:29.598]                 }
  [21:25:29.598]             }
  [21:25:29.598]         }))
  [21:25:29.598]     }, error = function(ex) {
  [21:25:29.598]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.598]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.598]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.598]     }, finally = {
  [21:25:29.598]         {
  [21:25:29.598]             NULL
  [21:25:29.598]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.598]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.598]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.598]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.598]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.598]                 ...) 
  [21:25:29.598]             {
  [21:25:29.598]                 if (substitute) 
  [21:25:29.598]                   expr <- substitute(expr)
  [21:25:29.598]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.598]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.598]                   globals = globals, persistent = persistent, 
  [21:25:29.598]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.598]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.598]                   label = label, ...)
  [21:25:29.598]                 if (!future$lazy) 
  [21:25:29.598]                   future <- run(future)
  [21:25:29.598]                 invisible(future)
  [21:25:29.598]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.598]         }
  [21:25:29.598]         base::options(...future.oldOptions)
  [21:25:29.598]     })
  [21:25:29.598]     Sys.time
  [21:25:29.598]     if (base::is.na(TRUE)) {
  [21:25:29.598]     }
  [21:25:29.598]     else {
  [21:25:29.598]         base::sink(type = "output", split = FALSE)
  [21:25:29.598]         if (TRUE) {
  [21:25:29.598]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.598]         }
  [21:25:29.598]         else {
  [21:25:29.598]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.598]         }
  [21:25:29.598]         base::close(...future.stdout)
  [21:25:29.598]         ...future.stdout <- NULL
  [21:25:29.598]     }
  [21:25:29.598]     ...future.result$conditions <- ...future.conditions
  [21:25:29.598]     ...future.result
  [21:25:29.598] }
  [21:25:29.618] ClusterFuture started
  [21:25:29.619] getGlobalsAndPackages() ...
  [21:25:29.619] Searching for globals...
  [21:25:29.620] 
  [21:25:29.620] Searching for globals ... DONE
  [21:25:29.621] - globals: [0] <none>
  [21:25:29.621] getGlobalsAndPackages() ... DONE
  [21:25:29.626] Packages needed by the future expression (n = 0): <none>
  [21:25:29.626] Packages needed by future strategies (n = 0): <none>
  [21:25:29.631] {
  [21:25:29.631]     {
  [21:25:29.631]         ...future.startTime <- base::Sys.time()
  [21:25:29.631]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.631]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.631]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.631]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.631]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.631]         {
  [21:25:29.631]             {
  [21:25:29.631]                 base::local({
  [21:25:29.631]                   has_future <- base::requireNamespace("future", 
  [21:25:29.631]                     quietly = TRUE)
  [21:25:29.631]                   version <- if (has_future) 
  [21:25:29.631]                     utils::packageVersion("future")
  [21:25:29.631]                   else NULL
  [21:25:29.631]                   if (!has_future || version < "1.8.0") {
  [21:25:29.631]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.631]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.631]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.631]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.631]                         "release", "version")], collapse = " "), 
  [21:25:29.631]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.631]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.631]                       info)
  [21:25:29.631]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.631]                     if (!has_future) {
  [21:25:29.631]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.631]                         info)
  [21:25:29.631]                     }
  [21:25:29.631]                     else {
  [21:25:29.631]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.631]                         info, version)
  [21:25:29.631]                     }
  [21:25:29.631]                     base::stop(msg)
  [21:25:29.631]                   }
  [21:25:29.631]                 })
  [21:25:29.631]             }
  [21:25:29.631]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.631]         }
  [21:25:29.631]     }
  [21:25:29.631]     if (base::is.na(TRUE)) {
  [21:25:29.631]     }
  [21:25:29.631]     else {
  [21:25:29.631]         if (TRUE) {
  [21:25:29.631]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.631]                 open = "w")
  [21:25:29.631]         }
  [21:25:29.631]         else {
  [21:25:29.631]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.631]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.631]         }
  [21:25:29.631]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.631]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.631]             base::sink(type = "output", split = FALSE)
  [21:25:29.631]             base::close(...future.stdout)
  [21:25:29.631]         }, add = TRUE)
  [21:25:29.631]     }
  [21:25:29.631]     ...future.frame <- base::sys.nframe()
  [21:25:29.631]     ...future.conditions <- base::list()
  [21:25:29.631]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.631]     ...future.result <- base::tryCatch({
  [21:25:29.631]         base::withCallingHandlers({
  [21:25:29.631]             ...future.value <- base::withVisible(base::local({
  [21:25:29.631]                 ...future.sendCondition <- local({
  [21:25:29.631]                   sendCondition <- NULL
  [21:25:29.631]                   function(frame = 1L) {
  [21:25:29.631]                     if (is.function(sendCondition)) 
  [21:25:29.631]                       return(sendCondition)
  [21:25:29.631]                     ns <- getNamespace("parallel")
  [21:25:29.631]                     if (exists("sendData", mode = "function", 
  [21:25:29.631]                       envir = ns)) {
  [21:25:29.631]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.631]                         envir = ns)
  [21:25:29.631]                       envir <- sys.frame(frame)
  [21:25:29.631]                       master <- NULL
  [21:25:29.631]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.631]                         !identical(envir, emptyenv())) {
  [21:25:29.631]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.631]                           inherits = FALSE)) {
  [21:25:29.631]                           master <- get("master", mode = "list", 
  [21:25:29.631]                             envir = envir, inherits = FALSE)
  [21:25:29.631]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.631]                             sendCondition <<- function(cond) {
  [21:25:29.631]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.631]                                 success = TRUE)
  [21:25:29.631]                               parallel_sendData(master, data)
  [21:25:29.631]                             }
  [21:25:29.631]                             return(sendCondition)
  [21:25:29.631]                           }
  [21:25:29.631]                         }
  [21:25:29.631]                         frame <- frame + 1L
  [21:25:29.631]                         envir <- sys.frame(frame)
  [21:25:29.631]                       }
  [21:25:29.631]                     }
  [21:25:29.631]                     sendCondition <<- function(cond) NULL
  [21:25:29.631]                   }
  [21:25:29.631]                 })
  [21:25:29.631]                 withCallingHandlers({
  [21:25:29.631]                   NULL
  [21:25:29.631]                 }, immediateCondition = function(cond) {
  [21:25:29.631]                   sendCondition <- ...future.sendCondition()
  [21:25:29.631]                   sendCondition(cond)
  [21:25:29.631]                   muffleCondition <- function (cond) 
  [21:25:29.631]                   {
  [21:25:29.631]                     inherits <- base::inherits
  [21:25:29.631]                     invokeRestart <- base::invokeRestart
  [21:25:29.631]                     muffled <- FALSE
  [21:25:29.631]                     if (inherits(cond, "message")) {
  [21:25:29.631]                       invokeRestart("muffleMessage")
  [21:25:29.631]                       muffled <- TRUE
  [21:25:29.631]                     }
  [21:25:29.631]                     else if (inherits(cond, "warning")) {
  [21:25:29.631]                       invokeRestart("muffleWarning")
  [21:25:29.631]                       muffled <- TRUE
  [21:25:29.631]                     }
  [21:25:29.631]                     else if (inherits(cond, "condition")) {
  [21:25:29.631]                       computeRestarts <- base::computeRestarts
  [21:25:29.631]                       grepl <- base::grepl
  [21:25:29.631]                       is.null <- base::is.null
  [21:25:29.631]                       restarts <- computeRestarts(cond)
  [21:25:29.631]                       for (restart in restarts) {
  [21:25:29.631]                         name <- restart$name
  [21:25:29.631]                         if (is.null(name)) 
  [21:25:29.631]                           next
  [21:25:29.631]                         if (!grepl("^muffle", name)) 
  [21:25:29.631]                           next
  [21:25:29.631]                         invokeRestart(restart)
  [21:25:29.631]                         muffled <- TRUE
  [21:25:29.631]                         break
  [21:25:29.631]                       }
  [21:25:29.631]                     }
  [21:25:29.631]                     invisible(muffled)
  [21:25:29.631]                   }
  [21:25:29.631]                   muffleCondition(cond)
  [21:25:29.631]                 })
  [21:25:29.631]             }))
  [21:25:29.631]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.631]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.631]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.631]                 version = "1.8")
  [21:25:29.631]         }, condition = base::local({
  [21:25:29.631]             c <- base::c
  [21:25:29.631]             inherits <- base::inherits
  [21:25:29.631]             invokeRestart <- base::invokeRestart
  [21:25:29.631]             length <- base::length
  [21:25:29.631]             list <- base::list
  [21:25:29.631]             seq.int <- base::seq.int
  [21:25:29.631]             signalCondition <- base::signalCondition
  [21:25:29.631]             sys.calls <- base::sys.calls
  [21:25:29.631]             Sys.time <- base::Sys.time
  [21:25:29.631]             `[[` <- base::`[[`
  [21:25:29.631]             `+` <- base::`+`
  [21:25:29.631]             `<<-` <- base::`<<-`
  [21:25:29.631]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.631]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.631]                   3L)]
  [21:25:29.631]             }
  [21:25:29.631]             function(cond) {
  [21:25:29.631]                 if (inherits(cond, "error")) {
  [21:25:29.631]                   sessionInformation <- function() {
  [21:25:29.631]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.631]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.631]                       search = base::search(), system = base::Sys.info())
  [21:25:29.631]                   }
  [21:25:29.631]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.631]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.631]                     cond$call), session = sessionInformation(), 
  [21:25:29.631]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.631]                   signalCondition(cond)
  [21:25:29.631]                 }
  [21:25:29.631]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.631]                 ))) {
  [21:25:29.631]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.631]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.631]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.631]                   if (!signal) {
  [21:25:29.631]                     muffleCondition <- function (cond) 
  [21:25:29.631]                     {
  [21:25:29.631]                       inherits <- base::inherits
  [21:25:29.631]                       invokeRestart <- base::invokeRestart
  [21:25:29.631]                       muffled <- FALSE
  [21:25:29.631]                       if (inherits(cond, "message")) {
  [21:25:29.631]                         invokeRestart("muffleMessage")
  [21:25:29.631]                         muffled <- TRUE
  [21:25:29.631]                       }
  [21:25:29.631]                       else if (inherits(cond, "warning")) {
  [21:25:29.631]                         invokeRestart("muffleWarning")
  [21:25:29.631]                         muffled <- TRUE
  [21:25:29.631]                       }
  [21:25:29.631]                       else if (inherits(cond, "condition")) {
  [21:25:29.631]                         computeRestarts <- base::computeRestarts
  [21:25:29.631]                         grepl <- base::grepl
  [21:25:29.631]                         is.null <- base::is.null
  [21:25:29.631]                         restarts <- computeRestarts(cond)
  [21:25:29.631]                         for (restart in restarts) {
  [21:25:29.631]                           name <- restart$name
  [21:25:29.631]                           if (is.null(name)) 
  [21:25:29.631]                             next
  [21:25:29.631]                           if (!grepl("^muffle", name)) 
  [21:25:29.631]                             next
  [21:25:29.631]                           invokeRestart(restart)
  [21:25:29.631]                           muffled <- TRUE
  [21:25:29.631]                           break
  [21:25:29.631]                         }
  [21:25:29.631]                       }
  [21:25:29.631]                       invisible(muffled)
  [21:25:29.631]                     }
  [21:25:29.631]                     muffleCondition(cond)
  [21:25:29.631]                   }
  [21:25:29.631]                 }
  [21:25:29.631]             }
  [21:25:29.631]         }))
  [21:25:29.631]     }, error = function(ex) {
  [21:25:29.631]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.631]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.631]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.631]     }, finally = {
  [21:25:29.631]         {
  [21:25:29.631]             NULL
  [21:25:29.631]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.631]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.631]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.631]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.631]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.631]                 ...) 
  [21:25:29.631]             {
  [21:25:29.631]                 if (substitute) 
  [21:25:29.631]                   expr <- substitute(expr)
  [21:25:29.631]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.631]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.631]                   globals = globals, persistent = persistent, 
  [21:25:29.631]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.631]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.631]                   label = label, ...)
  [21:25:29.631]                 if (!future$lazy) 
  [21:25:29.631]                   future <- run(future)
  [21:25:29.631]                 invisible(future)
  [21:25:29.631]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.631]         }
  [21:25:29.631]         base::options(...future.oldOptions)
  [21:25:29.631]     })
  [21:25:29.631]     Sys.time
  [21:25:29.631]     if (base::is.na(TRUE)) {
  [21:25:29.631]     }
  [21:25:29.631]     else {
  [21:25:29.631]         base::sink(type = "output", split = FALSE)
  [21:25:29.631]         if (TRUE) {
  [21:25:29.631]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.631]         }
  [21:25:29.631]         else {
  [21:25:29.631]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.631]         }
  [21:25:29.631]         base::close(...future.stdout)
  [21:25:29.631]         ...future.stdout <- NULL
  [21:25:29.631]     }
  [21:25:29.631]     ...future.result$conditions <- ...future.conditions
  [21:25:29.631]     ...future.result
  [21:25:29.631] }
  [21:25:29.652] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:29.664] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:29.664] - Validating connection of ClusterFuture
  [21:25:29.665] - received message: FutureResult
  [21:25:29.665] - Received FutureResult
  [21:25:29.666] - Erased future from FutureRegistry
  [21:25:29.666] result() for ClusterFuture ...
  [21:25:29.666] - result already collected: FutureResult
  [21:25:29.666] result() for ClusterFuture ... done
  [21:25:29.667] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:29.667] result() for ClusterFuture ...
  [21:25:29.668] - result already collected: FutureResult
  [21:25:29.668] result() for ClusterFuture ... done
  [21:25:29.668] result() for ClusterFuture ...
  [21:25:29.669] - result already collected: FutureResult
  [21:25:29.669] result() for ClusterFuture ... done
  [21:25:29.671] ClusterFuture started
  [21:25:29.672] getGlobalsAndPackages() ...
  [21:25:29.673] Searching for globals...
  [21:25:29.674] - globals found: [1] '{'
  [21:25:29.674] Searching for globals ... DONE
  [21:25:29.675] Resolving globals: FALSE
  [21:25:29.675] 
  [21:25:29.676] 
  [21:25:29.676] getGlobalsAndPackages() ... DONE
  [21:25:29.681] Packages needed by the future expression (n = 0): <none>
  [21:25:29.681] Packages needed by future strategies (n = 0): <none>
  [21:25:29.701] {
  [21:25:29.701]     {
  [21:25:29.701]         ...future.startTime <- base::Sys.time()
  [21:25:29.701]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.701]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.701]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.701]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.701]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.701]         {
  [21:25:29.701]             {
  [21:25:29.701]                 base::local({
  [21:25:29.701]                   has_future <- base::requireNamespace("future", 
  [21:25:29.701]                     quietly = TRUE)
  [21:25:29.701]                   version <- if (has_future) 
  [21:25:29.701]                     utils::packageVersion("future")
  [21:25:29.701]                   else NULL
  [21:25:29.701]                   if (!has_future || version < "1.8.0") {
  [21:25:29.701]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.701]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.701]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.701]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.701]                         "release", "version")], collapse = " "), 
  [21:25:29.701]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.701]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.701]                       info)
  [21:25:29.701]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.701]                     if (!has_future) {
  [21:25:29.701]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.701]                         info)
  [21:25:29.701]                     }
  [21:25:29.701]                     else {
  [21:25:29.701]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.701]                         info, version)
  [21:25:29.701]                     }
  [21:25:29.701]                     base::stop(msg)
  [21:25:29.701]                   }
  [21:25:29.701]                 })
  [21:25:29.701]             }
  [21:25:29.701]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.701]         }
  [21:25:29.701]     }
  [21:25:29.701]     if (base::is.na(TRUE)) {
  [21:25:29.701]     }
  [21:25:29.701]     else {
  [21:25:29.701]         if (TRUE) {
  [21:25:29.701]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.701]                 open = "w")
  [21:25:29.701]         }
  [21:25:29.701]         else {
  [21:25:29.701]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.701]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.701]         }
  [21:25:29.701]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.701]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.701]             base::sink(type = "output", split = FALSE)
  [21:25:29.701]             base::close(...future.stdout)
  [21:25:29.701]         }, add = TRUE)
  [21:25:29.701]     }
  [21:25:29.701]     ...future.frame <- base::sys.nframe()
  [21:25:29.701]     ...future.conditions <- base::list()
  [21:25:29.701]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.701]     ...future.result <- base::tryCatch({
  [21:25:29.701]         base::withCallingHandlers({
  [21:25:29.701]             ...future.value <- base::withVisible(base::local({
  [21:25:29.701]                 ...future.sendCondition <- local({
  [21:25:29.701]                   sendCondition <- NULL
  [21:25:29.701]                   function(frame = 1L) {
  [21:25:29.701]                     if (is.function(sendCondition)) 
  [21:25:29.701]                       return(sendCondition)
  [21:25:29.701]                     ns <- getNamespace("parallel")
  [21:25:29.701]                     if (exists("sendData", mode = "function", 
  [21:25:29.701]                       envir = ns)) {
  [21:25:29.701]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.701]                         envir = ns)
  [21:25:29.701]                       envir <- sys.frame(frame)
  [21:25:29.701]                       master <- NULL
  [21:25:29.701]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.701]                         !identical(envir, emptyenv())) {
  [21:25:29.701]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.701]                           inherits = FALSE)) {
  [21:25:29.701]                           master <- get("master", mode = "list", 
  [21:25:29.701]                             envir = envir, inherits = FALSE)
  [21:25:29.701]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.701]                             sendCondition <<- function(cond) {
  [21:25:29.701]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.701]                                 success = TRUE)
  [21:25:29.701]                               parallel_sendData(master, data)
  [21:25:29.701]                             }
  [21:25:29.701]                             return(sendCondition)
  [21:25:29.701]                           }
  [21:25:29.701]                         }
  [21:25:29.701]                         frame <- frame + 1L
  [21:25:29.701]                         envir <- sys.frame(frame)
  [21:25:29.701]                       }
  [21:25:29.701]                     }
  [21:25:29.701]                     sendCondition <<- function(cond) NULL
  [21:25:29.701]                   }
  [21:25:29.701]                 })
  [21:25:29.701]                 withCallingHandlers({
  [21:25:29.701]                   {
  [21:25:29.701]                     4
  [21:25:29.701]                   }
  [21:25:29.701]                 }, immediateCondition = function(cond) {
  [21:25:29.701]                   sendCondition <- ...future.sendCondition()
  [21:25:29.701]                   sendCondition(cond)
  [21:25:29.701]                   muffleCondition <- function (cond) 
  [21:25:29.701]                   {
  [21:25:29.701]                     inherits <- base::inherits
  [21:25:29.701]                     invokeRestart <- base::invokeRestart
  [21:25:29.701]                     muffled <- FALSE
  [21:25:29.701]                     if (inherits(cond, "message")) {
  [21:25:29.701]                       invokeRestart("muffleMessage")
  [21:25:29.701]                       muffled <- TRUE
  [21:25:29.701]                     }
  [21:25:29.701]                     else if (inherits(cond, "warning")) {
  [21:25:29.701]                       invokeRestart("muffleWarning")
  [21:25:29.701]                       muffled <- TRUE
  [21:25:29.701]                     }
  [21:25:29.701]                     else if (inherits(cond, "condition")) {
  [21:25:29.701]                       computeRestarts <- base::computeRestarts
  [21:25:29.701]                       grepl <- base::grepl
  [21:25:29.701]                       is.null <- base::is.null
  [21:25:29.701]                       restarts <- computeRestarts(cond)
  [21:25:29.701]                       for (restart in restarts) {
  [21:25:29.701]                         name <- restart$name
  [21:25:29.701]                         if (is.null(name)) 
  [21:25:29.701]                           next
  [21:25:29.701]                         if (!grepl("^muffle", name)) 
  [21:25:29.701]                           next
  [21:25:29.701]                         invokeRestart(restart)
  [21:25:29.701]                         muffled <- TRUE
  [21:25:29.701]                         break
  [21:25:29.701]                       }
  [21:25:29.701]                     }
  [21:25:29.701]                     invisible(muffled)
  [21:25:29.701]                   }
  [21:25:29.701]                   muffleCondition(cond)
  [21:25:29.701]                 })
  [21:25:29.701]             }))
  [21:25:29.701]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.701]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.701]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.701]                 version = "1.8")
  [21:25:29.701]         }, condition = base::local({
  [21:25:29.701]             c <- base::c
  [21:25:29.701]             inherits <- base::inherits
  [21:25:29.701]             invokeRestart <- base::invokeRestart
  [21:25:29.701]             length <- base::length
  [21:25:29.701]             list <- base::list
  [21:25:29.701]             seq.int <- base::seq.int
  [21:25:29.701]             signalCondition <- base::signalCondition
  [21:25:29.701]             sys.calls <- base::sys.calls
  [21:25:29.701]             Sys.time <- base::Sys.time
  [21:25:29.701]             `[[` <- base::`[[`
  [21:25:29.701]             `+` <- base::`+`
  [21:25:29.701]             `<<-` <- base::`<<-`
  [21:25:29.701]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.701]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.701]                   3L)]
  [21:25:29.701]             }
  [21:25:29.701]             function(cond) {
  [21:25:29.701]                 if (inherits(cond, "error")) {
  [21:25:29.701]                   sessionInformation <- function() {
  [21:25:29.701]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.701]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.701]                       search = base::search(), system = base::Sys.info())
  [21:25:29.701]                   }
  [21:25:29.701]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.701]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.701]                     cond$call), session = sessionInformation(), 
  [21:25:29.701]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.701]                   signalCondition(cond)
  [21:25:29.701]                 }
  [21:25:29.701]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.701]                 ))) {
  [21:25:29.701]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.701]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.701]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.701]                   if (!signal) {
  [21:25:29.701]                     muffleCondition <- function (cond) 
  [21:25:29.701]                     {
  [21:25:29.701]                       inherits <- base::inherits
  [21:25:29.701]                       invokeRestart <- base::invokeRestart
  [21:25:29.701]                       muffled <- FALSE
  [21:25:29.701]                       if (inherits(cond, "message")) {
  [21:25:29.701]                         invokeRestart("muffleMessage")
  [21:25:29.701]                         muffled <- TRUE
  [21:25:29.701]                       }
  [21:25:29.701]                       else if (inherits(cond, "warning")) {
  [21:25:29.701]                         invokeRestart("muffleWarning")
  [21:25:29.701]                         muffled <- TRUE
  [21:25:29.701]                       }
  [21:25:29.701]                       else if (inherits(cond, "condition")) {
  [21:25:29.701]                         computeRestarts <- base::computeRestarts
  [21:25:29.701]                         grepl <- base::grepl
  [21:25:29.701]                         is.null <- base::is.null
  [21:25:29.701]                         restarts <- computeRestarts(cond)
  [21:25:29.701]                         for (restart in restarts) {
  [21:25:29.701]                           name <- restart$name
  [21:25:29.701]                           if (is.null(name)) 
  [21:25:29.701]                             next
  [21:25:29.701]                           if (!grepl("^muffle", name)) 
  [21:25:29.701]                             next
  [21:25:29.701]                           invokeRestart(restart)
  [21:25:29.701]                           muffled <- TRUE
  [21:25:29.701]                           break
  [21:25:29.701]                         }
  [21:25:29.701]                       }
  [21:25:29.701]                       invisible(muffled)
  [21:25:29.701]                     }
  [21:25:29.701]                     muffleCondition(cond)
  [21:25:29.701]                   }
  [21:25:29.701]                 }
  [21:25:29.701]             }
  [21:25:29.701]         }))
  [21:25:29.701]     }, error = function(ex) {
  [21:25:29.701]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.701]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.701]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.701]     }, finally = {
  [21:25:29.701]         {
  [21:25:29.701]             NULL
  [21:25:29.701]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.701]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.701]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.701]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.701]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.701]                 ...) 
  [21:25:29.701]             {
  [21:25:29.701]                 if (substitute) 
  [21:25:29.701]                   expr <- substitute(expr)
  [21:25:29.701]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.701]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.701]                   globals = globals, persistent = persistent, 
  [21:25:29.701]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.701]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.701]                   label = label, ...)
  [21:25:29.701]                 if (!future$lazy) 
  [21:25:29.701]                   future <- run(future)
  [21:25:29.701]                 invisible(future)
  [21:25:29.701]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.701]         }
  [21:25:29.701]         base::options(...future.oldOptions)
  [21:25:29.701]     })
  [21:25:29.701]     Sys.time
  [21:25:29.701]     if (base::is.na(TRUE)) {
  [21:25:29.701]     }
  [21:25:29.701]     else {
  [21:25:29.701]         base::sink(type = "output", split = FALSE)
  [21:25:29.701]         if (TRUE) {
  [21:25:29.701]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.701]         }
  [21:25:29.701]         else {
  [21:25:29.701]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.701]         }
  [21:25:29.701]         base::close(...future.stdout)
  [21:25:29.701]         ...future.stdout <- NULL
  [21:25:29.701]     }
  [21:25:29.701]     ...future.result$conditions <- ...future.conditions
  [21:25:29.701]     ...future.result
  [21:25:29.701] }
  [21:25:29.742] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:29.754] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:29.754] - Validating connection of ClusterFuture
  [21:25:29.755] - received message: FutureResult
  [21:25:29.755] - Received FutureResult
  [21:25:29.756] - Erased future from FutureRegistry
  [21:25:29.756] result() for ClusterFuture ...
  [21:25:29.756] - result already collected: FutureResult
  [21:25:29.757] result() for ClusterFuture ... done
  [21:25:29.757] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:29.758] result() for ClusterFuture ...
  [21:25:29.758] - result already collected: FutureResult
  [21:25:29.758] result() for ClusterFuture ... done
  [21:25:29.759] result() for ClusterFuture ...
  [21:25:29.759] - result already collected: FutureResult
  [21:25:29.759] result() for ClusterFuture ... done
  [21:25:29.762] ClusterFuture started
  <environment: 0x55ef229e5b80> 
  <environment: 0x55ef229fd2c0> 
  [21:25:29.806] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:29.806] - Validating connection of ClusterFuture
  [21:25:29.807] - received message: FutureResult
  [21:25:29.807] - Received FutureResult
  [21:25:29.808] - Erased future from FutureRegistry
  [21:25:29.808] result() for ClusterFuture ...
  [21:25:29.808] - result already collected: FutureResult
  [21:25:29.808] result() for ClusterFuture ... done
  [21:25:29.809] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:29.817] resolve() on environment ...
  [21:25:29.818]  recursive: 0
  [21:25:29.819]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:29.820] signalConditionsASAP(numeric, pos=1) ...
  [21:25:29.820] - nx: 4
  [21:25:29.820] - relay: TRUE
  [21:25:29.821] - stdout: TRUE
  [21:25:29.821] - signal: TRUE
  [21:25:29.821] - resignal: FALSE
  [21:25:29.822] - force: TRUE
  [21:25:29.822] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:29.822] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:29.822]  - until=2
  [21:25:29.823]  - relaying element #2
  [21:25:29.823] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:29.823] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:29.823] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:29.824]  length: 3 (resolved future 1)
  [21:25:29.824] Future #2
  [21:25:29.824] result() for ClusterFuture ...
  [21:25:29.825] - result already collected: FutureResult
  [21:25:29.825] result() for ClusterFuture ... done
  [21:25:29.825] result() for ClusterFuture ...
  [21:25:29.825] - result already collected: FutureResult
  [21:25:29.850] result() for ClusterFuture ... done
  [21:25:29.850] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:29.851] - nx: 4
  [21:25:29.851] - relay: TRUE
  [21:25:29.851] - stdout: TRUE
  [21:25:29.851] - signal: TRUE
  [21:25:29.852] - resignal: FALSE
  [21:25:29.852] - force: TRUE
  [21:25:29.852] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:29.852] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:29.853]  - until=2
  [21:25:29.853]  - relaying element #2
  [21:25:29.853] result() for ClusterFuture ...
  [21:25:29.853] - result already collected: FutureResult
  [21:25:29.854] result() for ClusterFuture ... done
  [21:25:29.854] result() for ClusterFuture ...
  [21:25:29.854] - result already collected: FutureResult
  [21:25:29.855] result() for ClusterFuture ... done
  [21:25:29.855] result() for ClusterFuture ...
  [21:25:29.855] - result already collected: FutureResult
  [21:25:29.855] result() for ClusterFuture ... done
  [21:25:29.856] result() for ClusterFuture ...
  [21:25:29.856] - result already collected: FutureResult
  [21:25:29.856] result() for ClusterFuture ... done
  [21:25:29.857] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:29.857] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:29.857] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:29.857]  length: 2 (resolved future 2)
  [21:25:29.858] Future #3
  [21:25:29.858] result() for ClusterFuture ...
  [21:25:29.858] - result already collected: FutureResult
  [21:25:29.858] result() for ClusterFuture ... done
  [21:25:29.859] result() for ClusterFuture ...
  [21:25:29.859] - result already collected: FutureResult
  [21:25:29.859] result() for ClusterFuture ... done
  [21:25:29.860] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:29.860] - nx: 4
  [21:25:29.860] - relay: TRUE
  [21:25:29.860] - stdout: TRUE
  [21:25:29.860] - signal: TRUE
  [21:25:29.861] - resignal: FALSE
  [21:25:29.861] - force: TRUE
  [21:25:29.861] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:29.861] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:29.862]  - until=3
  [21:25:29.862]  - relaying element #3
  [21:25:29.862] result() for ClusterFuture ...
  [21:25:29.862] - result already collected: FutureResult
  [21:25:29.863] result() for ClusterFuture ... done
  [21:25:29.863] result() for ClusterFuture ...
  [21:25:29.863] - result already collected: FutureResult
  [21:25:29.864] result() for ClusterFuture ... done
  [21:25:29.864] result() for ClusterFuture ...
  [21:25:29.864] - result already collected: FutureResult
  [21:25:29.864] result() for ClusterFuture ... done
  [21:25:29.865] result() for ClusterFuture ...
  [21:25:29.865] - result already collected: FutureResult
  [21:25:29.865] result() for ClusterFuture ... done
  [21:25:29.865] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:29.882] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:29.882] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:29.883]  length: 1 (resolved future 3)
  [21:25:29.883] Future #4
  [21:25:29.883] result() for ClusterFuture ...
  [21:25:29.884] - result already collected: FutureResult
  [21:25:29.884] result() for ClusterFuture ... done
  [21:25:29.884] result() for ClusterFuture ...
  [21:25:29.885] - result already collected: FutureResult
  [21:25:29.885] result() for ClusterFuture ... done
  [21:25:29.885] signalConditionsASAP(ClusterFuture, pos=4) ...
  [21:25:29.885] - nx: 4
  [21:25:29.886] - relay: TRUE
  [21:25:29.886] - stdout: TRUE
  [21:25:29.886] - signal: TRUE
  [21:25:29.887] - resignal: FALSE
  [21:25:29.887] - force: TRUE
  [21:25:29.887] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:29.887] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:29.888]  - until=4
  [21:25:29.888]  - relaying element #4
  [21:25:29.888] result() for ClusterFuture ...
  [21:25:29.889] - result already collected: FutureResult
  [21:25:29.889] result() for ClusterFuture ... done
  [21:25:29.889] result() for ClusterFuture ...
  [21:25:29.890] - result already collected: FutureResult
  [21:25:29.890] result() for ClusterFuture ... done
  [21:25:29.890] result() for ClusterFuture ...
  [21:25:29.891] - result already collected: FutureResult
  [21:25:29.891] result() for ClusterFuture ... done
  [21:25:29.891] result() for ClusterFuture ...
  [21:25:29.891] - result already collected: FutureResult
  [21:25:29.892] result() for ClusterFuture ... done
  [21:25:29.892] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:29.892] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:29.893] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [21:25:29.893]  length: 0 (resolved future 4)
  [21:25:29.893] Relaying remaining futures
  [21:25:29.894] signalConditionsASAP(NULL, pos=0) ...
  [21:25:29.894] - nx: 4
  [21:25:29.894] - relay: TRUE
  [21:25:29.894] - stdout: TRUE
  [21:25:29.895] - signal: TRUE
  [21:25:29.895] - resignal: FALSE
  [21:25:29.895] - force: TRUE
  [21:25:29.895] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:29.896] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:29.896] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:29.896] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:29.897] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:29.897] resolve() on environment ... DONE
  [21:25:29.897] result() for ClusterFuture ...
  [21:25:29.914] - result already collected: FutureResult
  [21:25:29.914] result() for ClusterFuture ... done
  [21:25:29.915] result() for ClusterFuture ...
  [21:25:29.915] - result already collected: FutureResult
  [21:25:29.915] result() for ClusterFuture ... done
  [21:25:29.915] result() for ClusterFuture ...
  [21:25:29.916] - result already collected: FutureResult
  [21:25:29.916] result() for ClusterFuture ... done
  [21:25:29.916] result() for ClusterFuture ...
  [21:25:29.917] - result already collected: FutureResult
  [21:25:29.917] result() for ClusterFuture ... done
  [21:25:29.917] result() for ClusterFuture ...
  [21:25:29.917] - result already collected: FutureResult
  [21:25:29.918] result() for ClusterFuture ... done
  [21:25:29.918] result() for ClusterFuture ...
  [21:25:29.918] - result already collected: FutureResult
  [21:25:29.919] result() for ClusterFuture ... done
  <environment: 0x55ef23088a98> 
  Dimensions: c(1, 6)
  [21:25:29.920] getGlobalsAndPackages() ...
  [21:25:29.920] Searching for globals...
  [21:25:29.921] 
  [21:25:29.921] Searching for globals ... DONE
  [21:25:29.922] - globals: [0] <none>
  [21:25:29.922] getGlobalsAndPackages() ... DONE
  [21:25:29.927] Packages needed by the future expression (n = 0): <none>
  [21:25:29.927] Packages needed by future strategies (n = 0): <none>
  [21:25:29.953] {
  [21:25:29.953]     {
  [21:25:29.953]         ...future.startTime <- base::Sys.time()
  [21:25:29.953]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.953]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.953]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.953]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.953]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.953]         {
  [21:25:29.953]             {
  [21:25:29.953]                 base::local({
  [21:25:29.953]                   has_future <- base::requireNamespace("future", 
  [21:25:29.953]                     quietly = TRUE)
  [21:25:29.953]                   version <- if (has_future) 
  [21:25:29.953]                     utils::packageVersion("future")
  [21:25:29.953]                   else NULL
  [21:25:29.953]                   if (!has_future || version < "1.8.0") {
  [21:25:29.953]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.953]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.953]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.953]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.953]                         "release", "version")], collapse = " "), 
  [21:25:29.953]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.953]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.953]                       info)
  [21:25:29.953]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.953]                     if (!has_future) {
  [21:25:29.953]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.953]                         info)
  [21:25:29.953]                     }
  [21:25:29.953]                     else {
  [21:25:29.953]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.953]                         info, version)
  [21:25:29.953]                     }
  [21:25:29.953]                     base::stop(msg)
  [21:25:29.953]                   }
  [21:25:29.953]                 })
  [21:25:29.953]             }
  [21:25:29.953]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.953]         }
  [21:25:29.953]     }
  [21:25:29.953]     if (base::is.na(TRUE)) {
  [21:25:29.953]     }
  [21:25:29.953]     else {
  [21:25:29.953]         if (TRUE) {
  [21:25:29.953]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.953]                 open = "w")
  [21:25:29.953]         }
  [21:25:29.953]         else {
  [21:25:29.953]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.953]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.953]         }
  [21:25:29.953]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.953]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.953]             base::sink(type = "output", split = FALSE)
  [21:25:29.953]             base::close(...future.stdout)
  [21:25:29.953]         }, add = TRUE)
  [21:25:29.953]     }
  [21:25:29.953]     ...future.frame <- base::sys.nframe()
  [21:25:29.953]     ...future.conditions <- base::list()
  [21:25:29.953]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.953]     ...future.result <- base::tryCatch({
  [21:25:29.953]         base::withCallingHandlers({
  [21:25:29.953]             ...future.value <- base::withVisible(base::local({
  [21:25:29.953]                 ...future.sendCondition <- local({
  [21:25:29.953]                   sendCondition <- NULL
  [21:25:29.953]                   function(frame = 1L) {
  [21:25:29.953]                     if (is.function(sendCondition)) 
  [21:25:29.953]                       return(sendCondition)
  [21:25:29.953]                     ns <- getNamespace("parallel")
  [21:25:29.953]                     if (exists("sendData", mode = "function", 
  [21:25:29.953]                       envir = ns)) {
  [21:25:29.953]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.953]                         envir = ns)
  [21:25:29.953]                       envir <- sys.frame(frame)
  [21:25:29.953]                       master <- NULL
  [21:25:29.953]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.953]                         !identical(envir, emptyenv())) {
  [21:25:29.953]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.953]                           inherits = FALSE)) {
  [21:25:29.953]                           master <- get("master", mode = "list", 
  [21:25:29.953]                             envir = envir, inherits = FALSE)
  [21:25:29.953]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.953]                             sendCondition <<- function(cond) {
  [21:25:29.953]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.953]                                 success = TRUE)
  [21:25:29.953]                               parallel_sendData(master, data)
  [21:25:29.953]                             }
  [21:25:29.953]                             return(sendCondition)
  [21:25:29.953]                           }
  [21:25:29.953]                         }
  [21:25:29.953]                         frame <- frame + 1L
  [21:25:29.953]                         envir <- sys.frame(frame)
  [21:25:29.953]                       }
  [21:25:29.953]                     }
  [21:25:29.953]                     sendCondition <<- function(cond) NULL
  [21:25:29.953]                   }
  [21:25:29.953]                 })
  [21:25:29.953]                 withCallingHandlers({
  [21:25:29.953]                   2
  [21:25:29.953]                 }, immediateCondition = function(cond) {
  [21:25:29.953]                   sendCondition <- ...future.sendCondition()
  [21:25:29.953]                   sendCondition(cond)
  [21:25:29.953]                   muffleCondition <- function (cond) 
  [21:25:29.953]                   {
  [21:25:29.953]                     inherits <- base::inherits
  [21:25:29.953]                     invokeRestart <- base::invokeRestart
  [21:25:29.953]                     muffled <- FALSE
  [21:25:29.953]                     if (inherits(cond, "message")) {
  [21:25:29.953]                       invokeRestart("muffleMessage")
  [21:25:29.953]                       muffled <- TRUE
  [21:25:29.953]                     }
  [21:25:29.953]                     else if (inherits(cond, "warning")) {
  [21:25:29.953]                       invokeRestart("muffleWarning")
  [21:25:29.953]                       muffled <- TRUE
  [21:25:29.953]                     }
  [21:25:29.953]                     else if (inherits(cond, "condition")) {
  [21:25:29.953]                       computeRestarts <- base::computeRestarts
  [21:25:29.953]                       grepl <- base::grepl
  [21:25:29.953]                       is.null <- base::is.null
  [21:25:29.953]                       restarts <- computeRestarts(cond)
  [21:25:29.953]                       for (restart in restarts) {
  [21:25:29.953]                         name <- restart$name
  [21:25:29.953]                         if (is.null(name)) 
  [21:25:29.953]                           next
  [21:25:29.953]                         if (!grepl("^muffle", name)) 
  [21:25:29.953]                           next
  [21:25:29.953]                         invokeRestart(restart)
  [21:25:29.953]                         muffled <- TRUE
  [21:25:29.953]                         break
  [21:25:29.953]                       }
  [21:25:29.953]                     }
  [21:25:29.953]                     invisible(muffled)
  [21:25:29.953]                   }
  [21:25:29.953]                   muffleCondition(cond)
  [21:25:29.953]                 })
  [21:25:29.953]             }))
  [21:25:29.953]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.953]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.953]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.953]                 version = "1.8")
  [21:25:29.953]         }, condition = base::local({
  [21:25:29.953]             c <- base::c
  [21:25:29.953]             inherits <- base::inherits
  [21:25:29.953]             invokeRestart <- base::invokeRestart
  [21:25:29.953]             length <- base::length
  [21:25:29.953]             list <- base::list
  [21:25:29.953]             seq.int <- base::seq.int
  [21:25:29.953]             signalCondition <- base::signalCondition
  [21:25:29.953]             sys.calls <- base::sys.calls
  [21:25:29.953]             Sys.time <- base::Sys.time
  [21:25:29.953]             `[[` <- base::`[[`
  [21:25:29.953]             `+` <- base::`+`
  [21:25:29.953]             `<<-` <- base::`<<-`
  [21:25:29.953]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.953]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.953]                   3L)]
  [21:25:29.953]             }
  [21:25:29.953]             function(cond) {
  [21:25:29.953]                 if (inherits(cond, "error")) {
  [21:25:29.953]                   sessionInformation <- function() {
  [21:25:29.953]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.953]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.953]                       search = base::search(), system = base::Sys.info())
  [21:25:29.953]                   }
  [21:25:29.953]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.953]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.953]                     cond$call), session = sessionInformation(), 
  [21:25:29.953]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.953]                   signalCondition(cond)
  [21:25:29.953]                 }
  [21:25:29.953]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.953]                 ))) {
  [21:25:29.953]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.953]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.953]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.953]                   if (!signal) {
  [21:25:29.953]                     muffleCondition <- function (cond) 
  [21:25:29.953]                     {
  [21:25:29.953]                       inherits <- base::inherits
  [21:25:29.953]                       invokeRestart <- base::invokeRestart
  [21:25:29.953]                       muffled <- FALSE
  [21:25:29.953]                       if (inherits(cond, "message")) {
  [21:25:29.953]                         invokeRestart("muffleMessage")
  [21:25:29.953]                         muffled <- TRUE
  [21:25:29.953]                       }
  [21:25:29.953]                       else if (inherits(cond, "warning")) {
  [21:25:29.953]                         invokeRestart("muffleWarning")
  [21:25:29.953]                         muffled <- TRUE
  [21:25:29.953]                       }
  [21:25:29.953]                       else if (inherits(cond, "condition")) {
  [21:25:29.953]                         computeRestarts <- base::computeRestarts
  [21:25:29.953]                         grepl <- base::grepl
  [21:25:29.953]                         is.null <- base::is.null
  [21:25:29.953]                         restarts <- computeRestarts(cond)
  [21:25:29.953]                         for (restart in restarts) {
  [21:25:29.953]                           name <- restart$name
  [21:25:29.953]                           if (is.null(name)) 
  [21:25:29.953]                             next
  [21:25:29.953]                           if (!grepl("^muffle", name)) 
  [21:25:29.953]                             next
  [21:25:29.953]                           invokeRestart(restart)
  [21:25:29.953]                           muffled <- TRUE
  [21:25:29.953]                           break
  [21:25:29.953]                         }
  [21:25:29.953]                       }
  [21:25:29.953]                       invisible(muffled)
  [21:25:29.953]                     }
  [21:25:29.953]                     muffleCondition(cond)
  [21:25:29.953]                   }
  [21:25:29.953]                 }
  [21:25:29.953]             }
  [21:25:29.953]         }))
  [21:25:29.953]     }, error = function(ex) {
  [21:25:29.953]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.953]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.953]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.953]     }, finally = {
  [21:25:29.953]         {
  [21:25:29.953]             NULL
  [21:25:29.953]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.953]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.953]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.953]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.953]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.953]                 ...) 
  [21:25:29.953]             {
  [21:25:29.953]                 if (substitute) 
  [21:25:29.953]                   expr <- substitute(expr)
  [21:25:29.953]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.953]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.953]                   globals = globals, persistent = persistent, 
  [21:25:29.953]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.953]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.953]                   label = label, ...)
  [21:25:29.953]                 if (!future$lazy) 
  [21:25:29.953]                   future <- run(future)
  [21:25:29.953]                 invisible(future)
  [21:25:29.953]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.953]         }
  [21:25:29.953]         base::options(...future.oldOptions)
  [21:25:29.953]     })
  [21:25:29.953]     Sys.time
  [21:25:29.953]     if (base::is.na(TRUE)) {
  [21:25:29.953]     }
  [21:25:29.953]     else {
  [21:25:29.953]         base::sink(type = "output", split = FALSE)
  [21:25:29.953]         if (TRUE) {
  [21:25:29.953]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.953]         }
  [21:25:29.953]         else {
  [21:25:29.953]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.953]         }
  [21:25:29.953]         base::close(...future.stdout)
  [21:25:29.953]         ...future.stdout <- NULL
  [21:25:29.953]     }
  [21:25:29.953]     ...future.result$conditions <- ...future.conditions
  [21:25:29.953]     ...future.result
  [21:25:29.953] }
  [21:25:29.960] ClusterFuture started
  [21:25:29.960] getGlobalsAndPackages() ...
  [21:25:29.960] Searching for globals...
  [21:25:29.961] 
  [21:25:29.961] Searching for globals ... DONE
  [21:25:29.962] - globals: [0] <none>
  [21:25:29.962] getGlobalsAndPackages() ... DONE
  [21:25:29.972] Packages needed by the future expression (n = 0): <none>
  [21:25:29.972] Packages needed by future strategies (n = 0): <none>
  [21:25:29.993] {
  [21:25:29.993]     {
  [21:25:29.993]         ...future.startTime <- base::Sys.time()
  [21:25:29.993]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:29.993]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:29.993]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:29.993]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:29.993]             future.resolve.recursive = NULL, width = 80L)
  [21:25:29.993]         {
  [21:25:29.993]             {
  [21:25:29.993]                 base::local({
  [21:25:29.993]                   has_future <- base::requireNamespace("future", 
  [21:25:29.993]                     quietly = TRUE)
  [21:25:29.993]                   version <- if (has_future) 
  [21:25:29.993]                     utils::packageVersion("future")
  [21:25:29.993]                   else NULL
  [21:25:29.993]                   if (!has_future || version < "1.8.0") {
  [21:25:29.993]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:29.993]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:29.993]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:29.993]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:29.993]                         "release", "version")], collapse = " "), 
  [21:25:29.993]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:29.993]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:29.993]                       info)
  [21:25:29.993]                     info <- base::paste(info, collapse = "; ")
  [21:25:29.993]                     if (!has_future) {
  [21:25:29.993]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:29.993]                         info)
  [21:25:29.993]                     }
  [21:25:29.993]                     else {
  [21:25:29.993]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:29.993]                         info, version)
  [21:25:29.993]                     }
  [21:25:29.993]                     base::stop(msg)
  [21:25:29.993]                   }
  [21:25:29.993]                 })
  [21:25:29.993]             }
  [21:25:29.993]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:29.993]         }
  [21:25:29.993]     }
  [21:25:29.993]     if (base::is.na(TRUE)) {
  [21:25:29.993]     }
  [21:25:29.993]     else {
  [21:25:29.993]         if (TRUE) {
  [21:25:29.993]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:29.993]                 open = "w")
  [21:25:29.993]         }
  [21:25:29.993]         else {
  [21:25:29.993]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:29.993]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:29.993]         }
  [21:25:29.993]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:29.993]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:29.993]             base::sink(type = "output", split = FALSE)
  [21:25:29.993]             base::close(...future.stdout)
  [21:25:29.993]         }, add = TRUE)
  [21:25:29.993]     }
  [21:25:29.993]     ...future.frame <- base::sys.nframe()
  [21:25:29.993]     ...future.conditions <- base::list()
  [21:25:29.993]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:29.993]     ...future.result <- base::tryCatch({
  [21:25:29.993]         base::withCallingHandlers({
  [21:25:29.993]             ...future.value <- base::withVisible(base::local({
  [21:25:29.993]                 ...future.sendCondition <- local({
  [21:25:29.993]                   sendCondition <- NULL
  [21:25:29.993]                   function(frame = 1L) {
  [21:25:29.993]                     if (is.function(sendCondition)) 
  [21:25:29.993]                       return(sendCondition)
  [21:25:29.993]                     ns <- getNamespace("parallel")
  [21:25:29.993]                     if (exists("sendData", mode = "function", 
  [21:25:29.993]                       envir = ns)) {
  [21:25:29.993]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:29.993]                         envir = ns)
  [21:25:29.993]                       envir <- sys.frame(frame)
  [21:25:29.993]                       master <- NULL
  [21:25:29.993]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:29.993]                         !identical(envir, emptyenv())) {
  [21:25:29.993]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:29.993]                           inherits = FALSE)) {
  [21:25:29.993]                           master <- get("master", mode = "list", 
  [21:25:29.993]                             envir = envir, inherits = FALSE)
  [21:25:29.993]                           if (inherits(master, "SOCKnode")) {
  [21:25:29.993]                             sendCondition <<- function(cond) {
  [21:25:29.993]                               data <- list(type = "VALUE", value = cond, 
  [21:25:29.993]                                 success = TRUE)
  [21:25:29.993]                               parallel_sendData(master, data)
  [21:25:29.993]                             }
  [21:25:29.993]                             return(sendCondition)
  [21:25:29.993]                           }
  [21:25:29.993]                         }
  [21:25:29.993]                         frame <- frame + 1L
  [21:25:29.993]                         envir <- sys.frame(frame)
  [21:25:29.993]                       }
  [21:25:29.993]                     }
  [21:25:29.993]                     sendCondition <<- function(cond) NULL
  [21:25:29.993]                   }
  [21:25:29.993]                 })
  [21:25:29.993]                 withCallingHandlers({
  [21:25:29.993]                   NULL
  [21:25:29.993]                 }, immediateCondition = function(cond) {
  [21:25:29.993]                   sendCondition <- ...future.sendCondition()
  [21:25:29.993]                   sendCondition(cond)
  [21:25:29.993]                   muffleCondition <- function (cond) 
  [21:25:29.993]                   {
  [21:25:29.993]                     inherits <- base::inherits
  [21:25:29.993]                     invokeRestart <- base::invokeRestart
  [21:25:29.993]                     muffled <- FALSE
  [21:25:29.993]                     if (inherits(cond, "message")) {
  [21:25:29.993]                       invokeRestart("muffleMessage")
  [21:25:29.993]                       muffled <- TRUE
  [21:25:29.993]                     }
  [21:25:29.993]                     else if (inherits(cond, "warning")) {
  [21:25:29.993]                       invokeRestart("muffleWarning")
  [21:25:29.993]                       muffled <- TRUE
  [21:25:29.993]                     }
  [21:25:29.993]                     else if (inherits(cond, "condition")) {
  [21:25:29.993]                       computeRestarts <- base::computeRestarts
  [21:25:29.993]                       grepl <- base::grepl
  [21:25:29.993]                       is.null <- base::is.null
  [21:25:29.993]                       restarts <- computeRestarts(cond)
  [21:25:29.993]                       for (restart in restarts) {
  [21:25:29.993]                         name <- restart$name
  [21:25:29.993]                         if (is.null(name)) 
  [21:25:29.993]                           next
  [21:25:29.993]                         if (!grepl("^muffle", name)) 
  [21:25:29.993]                           next
  [21:25:29.993]                         invokeRestart(restart)
  [21:25:29.993]                         muffled <- TRUE
  [21:25:29.993]                         break
  [21:25:29.993]                       }
  [21:25:29.993]                     }
  [21:25:29.993]                     invisible(muffled)
  [21:25:29.993]                   }
  [21:25:29.993]                   muffleCondition(cond)
  [21:25:29.993]                 })
  [21:25:29.993]             }))
  [21:25:29.993]             future::FutureResult(value = ...future.value$value, 
  [21:25:29.993]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.993]                   ...future.rng), started = ...future.startTime, 
  [21:25:29.993]                 version = "1.8")
  [21:25:29.993]         }, condition = base::local({
  [21:25:29.993]             c <- base::c
  [21:25:29.993]             inherits <- base::inherits
  [21:25:29.993]             invokeRestart <- base::invokeRestart
  [21:25:29.993]             length <- base::length
  [21:25:29.993]             list <- base::list
  [21:25:29.993]             seq.int <- base::seq.int
  [21:25:29.993]             signalCondition <- base::signalCondition
  [21:25:29.993]             sys.calls <- base::sys.calls
  [21:25:29.993]             Sys.time <- base::Sys.time
  [21:25:29.993]             `[[` <- base::`[[`
  [21:25:29.993]             `+` <- base::`+`
  [21:25:29.993]             `<<-` <- base::`<<-`
  [21:25:29.993]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:29.993]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:29.993]                   3L)]
  [21:25:29.993]             }
  [21:25:29.993]             function(cond) {
  [21:25:29.993]                 if (inherits(cond, "error")) {
  [21:25:29.993]                   sessionInformation <- function() {
  [21:25:29.993]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:29.993]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:29.993]                       search = base::search(), system = base::Sys.info())
  [21:25:29.993]                   }
  [21:25:29.993]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.993]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:29.993]                     cond$call), session = sessionInformation(), 
  [21:25:29.993]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:29.993]                   signalCondition(cond)
  [21:25:29.993]                 }
  [21:25:29.993]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:29.993]                 ))) {
  [21:25:29.993]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:29.993]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:29.993]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:29.993]                   if (!signal) {
  [21:25:29.993]                     muffleCondition <- function (cond) 
  [21:25:29.993]                     {
  [21:25:29.993]                       inherits <- base::inherits
  [21:25:29.993]                       invokeRestart <- base::invokeRestart
  [21:25:29.993]                       muffled <- FALSE
  [21:25:29.993]                       if (inherits(cond, "message")) {
  [21:25:29.993]                         invokeRestart("muffleMessage")
  [21:25:29.993]                         muffled <- TRUE
  [21:25:29.993]                       }
  [21:25:29.993]                       else if (inherits(cond, "warning")) {
  [21:25:29.993]                         invokeRestart("muffleWarning")
  [21:25:29.993]                         muffled <- TRUE
  [21:25:29.993]                       }
  [21:25:29.993]                       else if (inherits(cond, "condition")) {
  [21:25:29.993]                         computeRestarts <- base::computeRestarts
  [21:25:29.993]                         grepl <- base::grepl
  [21:25:29.993]                         is.null <- base::is.null
  [21:25:29.993]                         restarts <- computeRestarts(cond)
  [21:25:29.993]                         for (restart in restarts) {
  [21:25:29.993]                           name <- restart$name
  [21:25:29.993]                           if (is.null(name)) 
  [21:25:29.993]                             next
  [21:25:29.993]                           if (!grepl("^muffle", name)) 
  [21:25:29.993]                             next
  [21:25:29.993]                           invokeRestart(restart)
  [21:25:29.993]                           muffled <- TRUE
  [21:25:29.993]                           break
  [21:25:29.993]                         }
  [21:25:29.993]                       }
  [21:25:29.993]                       invisible(muffled)
  [21:25:29.993]                     }
  [21:25:29.993]                     muffleCondition(cond)
  [21:25:29.993]                   }
  [21:25:29.993]                 }
  [21:25:29.993]             }
  [21:25:29.993]         }))
  [21:25:29.993]     }, error = function(ex) {
  [21:25:29.993]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:29.993]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:29.993]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:29.993]     }, finally = {
  [21:25:29.993]         {
  [21:25:29.993]             NULL
  [21:25:29.993]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:29.993]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:29.993]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:29.993]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:29.993]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:29.993]                 ...) 
  [21:25:29.993]             {
  [21:25:29.993]                 if (substitute) 
  [21:25:29.993]                   expr <- substitute(expr)
  [21:25:29.993]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:29.993]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:29.993]                   globals = globals, persistent = persistent, 
  [21:25:29.993]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:29.993]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:29.993]                   label = label, ...)
  [21:25:29.993]                 if (!future$lazy) 
  [21:25:29.993]                   future <- run(future)
  [21:25:29.993]                 invisible(future)
  [21:25:29.993]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:29.993]         }
  [21:25:29.993]         base::options(...future.oldOptions)
  [21:25:29.993]     })
  [21:25:29.993]     Sys.time
  [21:25:29.993]     if (base::is.na(TRUE)) {
  [21:25:29.993]     }
  [21:25:29.993]     else {
  [21:25:29.993]         base::sink(type = "output", split = FALSE)
  [21:25:29.993]         if (TRUE) {
  [21:25:29.993]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:29.993]         }
  [21:25:29.993]         else {
  [21:25:29.993]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:29.993]         }
  [21:25:29.993]         base::close(...future.stdout)
  [21:25:29.993]         ...future.stdout <- NULL
  [21:25:29.993]     }
  [21:25:29.993]     ...future.result$conditions <- ...future.conditions
  [21:25:29.993]     ...future.result
  [21:25:29.993] }
  [21:25:29.998] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.011] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.011] - Validating connection of ClusterFuture
  [21:25:30.012] - received message: FutureResult
  [21:25:30.012] - Received FutureResult
  [21:25:30.013] - Erased future from FutureRegistry
  [21:25:30.013] result() for ClusterFuture ...
  [21:25:30.013] - result already collected: FutureResult
  [21:25:30.013] result() for ClusterFuture ... done
  [21:25:30.014] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.014] result() for ClusterFuture ...
  [21:25:30.015] - result already collected: FutureResult
  [21:25:30.015] result() for ClusterFuture ... done
  [21:25:30.015] result() for ClusterFuture ...
  [21:25:30.016] - result already collected: FutureResult
  [21:25:30.016] result() for ClusterFuture ... done
  [21:25:30.031] ClusterFuture started
  [21:25:30.032] getGlobalsAndPackages() ...
  [21:25:30.032] Searching for globals...
  [21:25:30.034] - globals found: [1] '{'
  [21:25:30.034] Searching for globals ... DONE
  [21:25:30.034] Resolving globals: FALSE
  [21:25:30.035] 
  [21:25:30.035] 
  [21:25:30.036] getGlobalsAndPackages() ... DONE
  [21:25:30.040] Packages needed by the future expression (n = 0): <none>
  [21:25:30.041] Packages needed by future strategies (n = 0): <none>
  [21:25:30.045] {
  [21:25:30.045]     {
  [21:25:30.045]         ...future.startTime <- base::Sys.time()
  [21:25:30.045]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.045]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.045]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.045]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.045]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.045]         {
  [21:25:30.045]             {
  [21:25:30.045]                 base::local({
  [21:25:30.045]                   has_future <- base::requireNamespace("future", 
  [21:25:30.045]                     quietly = TRUE)
  [21:25:30.045]                   version <- if (has_future) 
  [21:25:30.045]                     utils::packageVersion("future")
  [21:25:30.045]                   else NULL
  [21:25:30.045]                   if (!has_future || version < "1.8.0") {
  [21:25:30.045]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.045]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.045]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.045]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.045]                         "release", "version")], collapse = " "), 
  [21:25:30.045]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.045]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.045]                       info)
  [21:25:30.045]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.045]                     if (!has_future) {
  [21:25:30.045]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.045]                         info)
  [21:25:30.045]                     }
  [21:25:30.045]                     else {
  [21:25:30.045]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.045]                         info, version)
  [21:25:30.045]                     }
  [21:25:30.045]                     base::stop(msg)
  [21:25:30.045]                   }
  [21:25:30.045]                 })
  [21:25:30.045]             }
  [21:25:30.045]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.045]         }
  [21:25:30.045]     }
  [21:25:30.045]     if (base::is.na(TRUE)) {
  [21:25:30.045]     }
  [21:25:30.045]     else {
  [21:25:30.045]         if (TRUE) {
  [21:25:30.045]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.045]                 open = "w")
  [21:25:30.045]         }
  [21:25:30.045]         else {
  [21:25:30.045]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.045]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.045]         }
  [21:25:30.045]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.045]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.045]             base::sink(type = "output", split = FALSE)
  [21:25:30.045]             base::close(...future.stdout)
  [21:25:30.045]         }, add = TRUE)
  [21:25:30.045]     }
  [21:25:30.045]     ...future.frame <- base::sys.nframe()
  [21:25:30.045]     ...future.conditions <- base::list()
  [21:25:30.045]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.045]     ...future.result <- base::tryCatch({
  [21:25:30.045]         base::withCallingHandlers({
  [21:25:30.045]             ...future.value <- base::withVisible(base::local({
  [21:25:30.045]                 ...future.sendCondition <- local({
  [21:25:30.045]                   sendCondition <- NULL
  [21:25:30.045]                   function(frame = 1L) {
  [21:25:30.045]                     if (is.function(sendCondition)) 
  [21:25:30.045]                       return(sendCondition)
  [21:25:30.045]                     ns <- getNamespace("parallel")
  [21:25:30.045]                     if (exists("sendData", mode = "function", 
  [21:25:30.045]                       envir = ns)) {
  [21:25:30.045]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.045]                         envir = ns)
  [21:25:30.045]                       envir <- sys.frame(frame)
  [21:25:30.045]                       master <- NULL
  [21:25:30.045]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.045]                         !identical(envir, emptyenv())) {
  [21:25:30.045]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.045]                           inherits = FALSE)) {
  [21:25:30.045]                           master <- get("master", mode = "list", 
  [21:25:30.045]                             envir = envir, inherits = FALSE)
  [21:25:30.045]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.045]                             sendCondition <<- function(cond) {
  [21:25:30.045]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.045]                                 success = TRUE)
  [21:25:30.045]                               parallel_sendData(master, data)
  [21:25:30.045]                             }
  [21:25:30.045]                             return(sendCondition)
  [21:25:30.045]                           }
  [21:25:30.045]                         }
  [21:25:30.045]                         frame <- frame + 1L
  [21:25:30.045]                         envir <- sys.frame(frame)
  [21:25:30.045]                       }
  [21:25:30.045]                     }
  [21:25:30.045]                     sendCondition <<- function(cond) NULL
  [21:25:30.045]                   }
  [21:25:30.045]                 })
  [21:25:30.045]                 withCallingHandlers({
  [21:25:30.045]                   {
  [21:25:30.045]                     4
  [21:25:30.045]                   }
  [21:25:30.045]                 }, immediateCondition = function(cond) {
  [21:25:30.045]                   sendCondition <- ...future.sendCondition()
  [21:25:30.045]                   sendCondition(cond)
  [21:25:30.045]                   muffleCondition <- function (cond) 
  [21:25:30.045]                   {
  [21:25:30.045]                     inherits <- base::inherits
  [21:25:30.045]                     invokeRestart <- base::invokeRestart
  [21:25:30.045]                     muffled <- FALSE
  [21:25:30.045]                     if (inherits(cond, "message")) {
  [21:25:30.045]                       invokeRestart("muffleMessage")
  [21:25:30.045]                       muffled <- TRUE
  [21:25:30.045]                     }
  [21:25:30.045]                     else if (inherits(cond, "warning")) {
  [21:25:30.045]                       invokeRestart("muffleWarning")
  [21:25:30.045]                       muffled <- TRUE
  [21:25:30.045]                     }
  [21:25:30.045]                     else if (inherits(cond, "condition")) {
  [21:25:30.045]                       computeRestarts <- base::computeRestarts
  [21:25:30.045]                       grepl <- base::grepl
  [21:25:30.045]                       is.null <- base::is.null
  [21:25:30.045]                       restarts <- computeRestarts(cond)
  [21:25:30.045]                       for (restart in restarts) {
  [21:25:30.045]                         name <- restart$name
  [21:25:30.045]                         if (is.null(name)) 
  [21:25:30.045]                           next
  [21:25:30.045]                         if (!grepl("^muffle", name)) 
  [21:25:30.045]                           next
  [21:25:30.045]                         invokeRestart(restart)
  [21:25:30.045]                         muffled <- TRUE
  [21:25:30.045]                         break
  [21:25:30.045]                       }
  [21:25:30.045]                     }
  [21:25:30.045]                     invisible(muffled)
  [21:25:30.045]                   }
  [21:25:30.045]                   muffleCondition(cond)
  [21:25:30.045]                 })
  [21:25:30.045]             }))
  [21:25:30.045]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.045]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.045]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.045]                 version = "1.8")
  [21:25:30.045]         }, condition = base::local({
  [21:25:30.045]             c <- base::c
  [21:25:30.045]             inherits <- base::inherits
  [21:25:30.045]             invokeRestart <- base::invokeRestart
  [21:25:30.045]             length <- base::length
  [21:25:30.045]             list <- base::list
  [21:25:30.045]             seq.int <- base::seq.int
  [21:25:30.045]             signalCondition <- base::signalCondition
  [21:25:30.045]             sys.calls <- base::sys.calls
  [21:25:30.045]             Sys.time <- base::Sys.time
  [21:25:30.045]             `[[` <- base::`[[`
  [21:25:30.045]             `+` <- base::`+`
  [21:25:30.045]             `<<-` <- base::`<<-`
  [21:25:30.045]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.045]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.045]                   3L)]
  [21:25:30.045]             }
  [21:25:30.045]             function(cond) {
  [21:25:30.045]                 if (inherits(cond, "error")) {
  [21:25:30.045]                   sessionInformation <- function() {
  [21:25:30.045]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.045]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.045]                       search = base::search(), system = base::Sys.info())
  [21:25:30.045]                   }
  [21:25:30.045]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.045]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.045]                     cond$call), session = sessionInformation(), 
  [21:25:30.045]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.045]                   signalCondition(cond)
  [21:25:30.045]                 }
  [21:25:30.045]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.045]                 ))) {
  [21:25:30.045]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.045]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.045]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.045]                   if (!signal) {
  [21:25:30.045]                     muffleCondition <- function (cond) 
  [21:25:30.045]                     {
  [21:25:30.045]                       inherits <- base::inherits
  [21:25:30.045]                       invokeRestart <- base::invokeRestart
  [21:25:30.045]                       muffled <- FALSE
  [21:25:30.045]                       if (inherits(cond, "message")) {
  [21:25:30.045]                         invokeRestart("muffleMessage")
  [21:25:30.045]                         muffled <- TRUE
  [21:25:30.045]                       }
  [21:25:30.045]                       else if (inherits(cond, "warning")) {
  [21:25:30.045]                         invokeRestart("muffleWarning")
  [21:25:30.045]                         muffled <- TRUE
  [21:25:30.045]                       }
  [21:25:30.045]                       else if (inherits(cond, "condition")) {
  [21:25:30.045]                         computeRestarts <- base::computeRestarts
  [21:25:30.045]                         grepl <- base::grepl
  [21:25:30.045]                         is.null <- base::is.null
  [21:25:30.045]                         restarts <- computeRestarts(cond)
  [21:25:30.045]                         for (restart in restarts) {
  [21:25:30.045]                           name <- restart$name
  [21:25:30.045]                           if (is.null(name)) 
  [21:25:30.045]                             next
  [21:25:30.045]                           if (!grepl("^muffle", name)) 
  [21:25:30.045]                             next
  [21:25:30.045]                           invokeRestart(restart)
  [21:25:30.045]                           muffled <- TRUE
  [21:25:30.045]                           break
  [21:25:30.045]                         }
  [21:25:30.045]                       }
  [21:25:30.045]                       invisible(muffled)
  [21:25:30.045]                     }
  [21:25:30.045]                     muffleCondition(cond)
  [21:25:30.045]                   }
  [21:25:30.045]                 }
  [21:25:30.045]             }
  [21:25:30.045]         }))
  [21:25:30.045]     }, error = function(ex) {
  [21:25:30.045]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.045]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.045]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.045]     }, finally = {
  [21:25:30.045]         {
  [21:25:30.045]             NULL
  [21:25:30.045]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.045]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.045]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.045]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.045]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.045]                 ...) 
  [21:25:30.045]             {
  [21:25:30.045]                 if (substitute) 
  [21:25:30.045]                   expr <- substitute(expr)
  [21:25:30.045]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.045]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.045]                   globals = globals, persistent = persistent, 
  [21:25:30.045]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.045]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.045]                   label = label, ...)
  [21:25:30.045]                 if (!future$lazy) 
  [21:25:30.045]                   future <- run(future)
  [21:25:30.045]                 invisible(future)
  [21:25:30.045]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.045]         }
  [21:25:30.045]         base::options(...future.oldOptions)
  [21:25:30.045]     })
  [21:25:30.045]     Sys.time
  [21:25:30.045]     if (base::is.na(TRUE)) {
  [21:25:30.045]     }
  [21:25:30.045]     else {
  [21:25:30.045]         base::sink(type = "output", split = FALSE)
  [21:25:30.045]         if (TRUE) {
  [21:25:30.045]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.045]         }
  [21:25:30.045]         else {
  [21:25:30.045]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.045]         }
  [21:25:30.045]         base::close(...future.stdout)
  [21:25:30.045]         ...future.stdout <- NULL
  [21:25:30.045]     }
  [21:25:30.045]     ...future.result$conditions <- ...future.conditions
  [21:25:30.045]     ...future.result
  [21:25:30.045] }
  [21:25:30.066] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.079] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.079] - Validating connection of ClusterFuture
  [21:25:30.080] - received message: FutureResult
  [21:25:30.080] - Received FutureResult
  [21:25:30.080] - Erased future from FutureRegistry
  [21:25:30.081] result() for ClusterFuture ...
  [21:25:30.081] - result already collected: FutureResult
  [21:25:30.081] result() for ClusterFuture ... done
  [21:25:30.082] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.082] result() for ClusterFuture ...
  [21:25:30.083] - result already collected: FutureResult
  [21:25:30.083] result() for ClusterFuture ... done
  [21:25:30.083] result() for ClusterFuture ...
  [21:25:30.084] - result already collected: FutureResult
  [21:25:30.084] result() for ClusterFuture ... done
  [21:25:30.087] ClusterFuture started
  <environment: 0x55ef22766050> 
  <environment: 0x55ef227ab2f8> 
  [21:25:30.134] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.134] - Validating connection of ClusterFuture
  [21:25:30.135] - received message: FutureResult
  [21:25:30.135] - Received FutureResult
  [21:25:30.135] - Erased future from FutureRegistry
  [21:25:30.136] result() for ClusterFuture ...
  [21:25:30.136] - result already collected: FutureResult
  [21:25:30.136] result() for ClusterFuture ... done
  [21:25:30.137] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:30.140] resolve() on environment ...
  [21:25:30.140]  recursive: 0
  [21:25:30.141]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:30.142] signalConditionsASAP(numeric, pos=1) ...
  [21:25:30.142] - nx: 4
  [21:25:30.142] - relay: TRUE
  [21:25:30.143] - stdout: TRUE
  [21:25:30.143] - signal: TRUE
  [21:25:30.143] - resignal: FALSE
  [21:25:30.143] - force: TRUE
  [21:25:30.144] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.144] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.144]  - until=2
  [21:25:30.144]  - relaying element #2
  [21:25:30.145] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.145] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.145] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:30.147]  length: 3 (resolved future 1)
  [21:25:30.148] Future #2
  [21:25:30.148] result() for ClusterFuture ...
  [21:25:30.148] - result already collected: FutureResult
  [21:25:30.148] result() for ClusterFuture ... done
  [21:25:30.149] result() for ClusterFuture ...
  [21:25:30.149] - result already collected: FutureResult
  [21:25:30.149] result() for ClusterFuture ... done
  [21:25:30.150] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:30.150] - nx: 4
  [21:25:30.150] - relay: TRUE
  [21:25:30.151] - stdout: TRUE
  [21:25:30.151] - signal: TRUE
  [21:25:30.151] - resignal: FALSE
  [21:25:30.151] - force: TRUE
  [21:25:30.152] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.152] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.152]  - until=2
  [21:25:30.157]  - relaying element #2
  [21:25:30.158] result() for ClusterFuture ...
  [21:25:30.158] - result already collected: FutureResult
  [21:25:30.158] result() for ClusterFuture ... done
  [21:25:30.159] result() for ClusterFuture ...
  [21:25:30.159] - result already collected: FutureResult
  [21:25:30.159] result() for ClusterFuture ... done
  [21:25:30.160] result() for ClusterFuture ...
  [21:25:30.160] - result already collected: FutureResult
  [21:25:30.160] result() for ClusterFuture ... done
  [21:25:30.161] result() for ClusterFuture ...
  [21:25:30.161] - result already collected: FutureResult
  [21:25:30.161] result() for ClusterFuture ... done
  [21:25:30.178] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.178] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.179] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:30.179]  length: 2 (resolved future 2)
  [21:25:30.179] Future #3
  [21:25:30.180] result() for ClusterFuture ...
  [21:25:30.180] - result already collected: FutureResult
  [21:25:30.180] result() for ClusterFuture ... done
  [21:25:30.181] result() for ClusterFuture ...
  [21:25:30.181] - result already collected: FutureResult
  [21:25:30.181] result() for ClusterFuture ... done
  [21:25:30.181] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:30.182] - nx: 4
  [21:25:30.182] - relay: TRUE
  [21:25:30.182] - stdout: TRUE
  [21:25:30.182] - signal: TRUE
  [21:25:30.183] - resignal: FALSE
  [21:25:30.183] - force: TRUE
  [21:25:30.183] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.184] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.184]  - until=3
  [21:25:30.184]  - relaying element #3
  [21:25:30.184] result() for ClusterFuture ...
  [21:25:30.185] - result already collected: FutureResult
  [21:25:30.185] result() for ClusterFuture ... done
  [21:25:30.185] result() for ClusterFuture ...
  [21:25:30.186] - result already collected: FutureResult
  [21:25:30.186] result() for ClusterFuture ... done
  [21:25:30.186] result() for ClusterFuture ...
  [21:25:30.187] - result already collected: FutureResult
  [21:25:30.187] result() for ClusterFuture ... done
  [21:25:30.187] result() for ClusterFuture ...
  [21:25:30.188] - result already collected: FutureResult
  [21:25:30.188] result() for ClusterFuture ... done
  [21:25:30.188] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.188] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.189] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:30.189]  length: 1 (resolved future 3)
  [21:25:30.189] Future #4
  [21:25:30.190] result() for ClusterFuture ...
  [21:25:30.190] - result already collected: FutureResult
  [21:25:30.190] result() for ClusterFuture ... done
  [21:25:30.191] result() for ClusterFuture ...
  [21:25:30.191] - result already collected: FutureResult
  [21:25:30.191] result() for ClusterFuture ... done
  [21:25:30.192] signalConditionsASAP(ClusterFuture, pos=4) ...
  [21:25:30.192] - nx: 4
  [21:25:30.192] - relay: TRUE
  [21:25:30.193] - stdout: TRUE
  [21:25:30.193] - signal: TRUE
  [21:25:30.193] - resignal: FALSE
  [21:25:30.193] - force: TRUE
  [21:25:30.210] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.210] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.211]  - until=4
  [21:25:30.211]  - relaying element #4
  [21:25:30.211] result() for ClusterFuture ...
  [21:25:30.211] - result already collected: FutureResult
  [21:25:30.212] result() for ClusterFuture ... done
  [21:25:30.212] result() for ClusterFuture ...
  [21:25:30.212] - result already collected: FutureResult
  [21:25:30.213] result() for ClusterFuture ... done
  [21:25:30.213] result() for ClusterFuture ...
  [21:25:30.213] - result already collected: FutureResult
  [21:25:30.214] result() for ClusterFuture ... done
  [21:25:30.214] result() for ClusterFuture ...
  [21:25:30.214] - result already collected: FutureResult
  [21:25:30.215] result() for ClusterFuture ... done
  [21:25:30.215] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.215] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.215] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [21:25:30.216]  length: 0 (resolved future 4)
  [21:25:30.216] Relaying remaining futures
  [21:25:30.216] signalConditionsASAP(NULL, pos=0) ...
  [21:25:30.217] - nx: 4
  [21:25:30.217] - relay: TRUE
  [21:25:30.217] - stdout: TRUE
  [21:25:30.217] - signal: TRUE
  [21:25:30.218] - resignal: FALSE
  [21:25:30.218] - force: TRUE
  [21:25:30.218] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.219] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:30.219] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.219] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.220] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:30.220] resolve() on environment ... DONE
  [21:25:30.220] result() for ClusterFuture ...
  [21:25:30.221] - result already collected: FutureResult
  [21:25:30.221] result() for ClusterFuture ... done
  [21:25:30.221] result() for ClusterFuture ...
  [21:25:30.221] - result already collected: FutureResult
  [21:25:30.222] result() for ClusterFuture ... done
  [21:25:30.222] result() for ClusterFuture ...
  [21:25:30.222] - result already collected: FutureResult
  [21:25:30.223] result() for ClusterFuture ... done
  [21:25:30.223] result() for ClusterFuture ...
  [21:25:30.223] - result already collected: FutureResult
  [21:25:30.224] result() for ClusterFuture ... done
  [21:25:30.224] result() for ClusterFuture ...
  [21:25:30.224] - result already collected: FutureResult
  [21:25:30.225] result() for ClusterFuture ... done
  [21:25:30.225] result() for ClusterFuture ...
  [21:25:30.225] - result already collected: FutureResult
  [21:25:30.226] result() for ClusterFuture ... done
  <environment: 0x55ef22919918> 
  Dimensions: c(2, 3)
  [21:25:30.243] getGlobalsAndPackages() ...
  [21:25:30.243] Searching for globals...
  [21:25:30.244] 
  [21:25:30.245] Searching for globals ... DONE
  [21:25:30.245] - globals: [0] <none>
  [21:25:30.245] getGlobalsAndPackages() ... DONE
  [21:25:30.250] Packages needed by the future expression (n = 0): <none>
  [21:25:30.250] Packages needed by future strategies (n = 0): <none>
  [21:25:30.255] {
  [21:25:30.255]     {
  [21:25:30.255]         ...future.startTime <- base::Sys.time()
  [21:25:30.255]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.255]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.255]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.255]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.255]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.255]         {
  [21:25:30.255]             {
  [21:25:30.255]                 base::local({
  [21:25:30.255]                   has_future <- base::requireNamespace("future", 
  [21:25:30.255]                     quietly = TRUE)
  [21:25:30.255]                   version <- if (has_future) 
  [21:25:30.255]                     utils::packageVersion("future")
  [21:25:30.255]                   else NULL
  [21:25:30.255]                   if (!has_future || version < "1.8.0") {
  [21:25:30.255]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.255]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.255]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.255]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.255]                         "release", "version")], collapse = " "), 
  [21:25:30.255]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.255]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.255]                       info)
  [21:25:30.255]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.255]                     if (!has_future) {
  [21:25:30.255]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.255]                         info)
  [21:25:30.255]                     }
  [21:25:30.255]                     else {
  [21:25:30.255]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.255]                         info, version)
  [21:25:30.255]                     }
  [21:25:30.255]                     base::stop(msg)
  [21:25:30.255]                   }
  [21:25:30.255]                 })
  [21:25:30.255]             }
  [21:25:30.255]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.255]         }
  [21:25:30.255]     }
  [21:25:30.255]     if (base::is.na(TRUE)) {
  [21:25:30.255]     }
  [21:25:30.255]     else {
  [21:25:30.255]         if (TRUE) {
  [21:25:30.255]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.255]                 open = "w")
  [21:25:30.255]         }
  [21:25:30.255]         else {
  [21:25:30.255]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.255]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.255]         }
  [21:25:30.255]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.255]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.255]             base::sink(type = "output", split = FALSE)
  [21:25:30.255]             base::close(...future.stdout)
  [21:25:30.255]         }, add = TRUE)
  [21:25:30.255]     }
  [21:25:30.255]     ...future.frame <- base::sys.nframe()
  [21:25:30.255]     ...future.conditions <- base::list()
  [21:25:30.255]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.255]     ...future.result <- base::tryCatch({
  [21:25:30.255]         base::withCallingHandlers({
  [21:25:30.255]             ...future.value <- base::withVisible(base::local({
  [21:25:30.255]                 ...future.sendCondition <- local({
  [21:25:30.255]                   sendCondition <- NULL
  [21:25:30.255]                   function(frame = 1L) {
  [21:25:30.255]                     if (is.function(sendCondition)) 
  [21:25:30.255]                       return(sendCondition)
  [21:25:30.255]                     ns <- getNamespace("parallel")
  [21:25:30.255]                     if (exists("sendData", mode = "function", 
  [21:25:30.255]                       envir = ns)) {
  [21:25:30.255]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.255]                         envir = ns)
  [21:25:30.255]                       envir <- sys.frame(frame)
  [21:25:30.255]                       master <- NULL
  [21:25:30.255]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.255]                         !identical(envir, emptyenv())) {
  [21:25:30.255]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.255]                           inherits = FALSE)) {
  [21:25:30.255]                           master <- get("master", mode = "list", 
  [21:25:30.255]                             envir = envir, inherits = FALSE)
  [21:25:30.255]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.255]                             sendCondition <<- function(cond) {
  [21:25:30.255]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.255]                                 success = TRUE)
  [21:25:30.255]                               parallel_sendData(master, data)
  [21:25:30.255]                             }
  [21:25:30.255]                             return(sendCondition)
  [21:25:30.255]                           }
  [21:25:30.255]                         }
  [21:25:30.255]                         frame <- frame + 1L
  [21:25:30.255]                         envir <- sys.frame(frame)
  [21:25:30.255]                       }
  [21:25:30.255]                     }
  [21:25:30.255]                     sendCondition <<- function(cond) NULL
  [21:25:30.255]                   }
  [21:25:30.255]                 })
  [21:25:30.255]                 withCallingHandlers({
  [21:25:30.255]                   2
  [21:25:30.255]                 }, immediateCondition = function(cond) {
  [21:25:30.255]                   sendCondition <- ...future.sendCondition()
  [21:25:30.255]                   sendCondition(cond)
  [21:25:30.255]                   muffleCondition <- function (cond) 
  [21:25:30.255]                   {
  [21:25:30.255]                     inherits <- base::inherits
  [21:25:30.255]                     invokeRestart <- base::invokeRestart
  [21:25:30.255]                     muffled <- FALSE
  [21:25:30.255]                     if (inherits(cond, "message")) {
  [21:25:30.255]                       invokeRestart("muffleMessage")
  [21:25:30.255]                       muffled <- TRUE
  [21:25:30.255]                     }
  [21:25:30.255]                     else if (inherits(cond, "warning")) {
  [21:25:30.255]                       invokeRestart("muffleWarning")
  [21:25:30.255]                       muffled <- TRUE
  [21:25:30.255]                     }
  [21:25:30.255]                     else if (inherits(cond, "condition")) {
  [21:25:30.255]                       computeRestarts <- base::computeRestarts
  [21:25:30.255]                       grepl <- base::grepl
  [21:25:30.255]                       is.null <- base::is.null
  [21:25:30.255]                       restarts <- computeRestarts(cond)
  [21:25:30.255]                       for (restart in restarts) {
  [21:25:30.255]                         name <- restart$name
  [21:25:30.255]                         if (is.null(name)) 
  [21:25:30.255]                           next
  [21:25:30.255]                         if (!grepl("^muffle", name)) 
  [21:25:30.255]                           next
  [21:25:30.255]                         invokeRestart(restart)
  [21:25:30.255]                         muffled <- TRUE
  [21:25:30.255]                         break
  [21:25:30.255]                       }
  [21:25:30.255]                     }
  [21:25:30.255]                     invisible(muffled)
  [21:25:30.255]                   }
  [21:25:30.255]                   muffleCondition(cond)
  [21:25:30.255]                 })
  [21:25:30.255]             }))
  [21:25:30.255]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.255]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.255]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.255]                 version = "1.8")
  [21:25:30.255]         }, condition = base::local({
  [21:25:30.255]             c <- base::c
  [21:25:30.255]             inherits <- base::inherits
  [21:25:30.255]             invokeRestart <- base::invokeRestart
  [21:25:30.255]             length <- base::length
  [21:25:30.255]             list <- base::list
  [21:25:30.255]             seq.int <- base::seq.int
  [21:25:30.255]             signalCondition <- base::signalCondition
  [21:25:30.255]             sys.calls <- base::sys.calls
  [21:25:30.255]             Sys.time <- base::Sys.time
  [21:25:30.255]             `[[` <- base::`[[`
  [21:25:30.255]             `+` <- base::`+`
  [21:25:30.255]             `<<-` <- base::`<<-`
  [21:25:30.255]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.255]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.255]                   3L)]
  [21:25:30.255]             }
  [21:25:30.255]             function(cond) {
  [21:25:30.255]                 if (inherits(cond, "error")) {
  [21:25:30.255]                   sessionInformation <- function() {
  [21:25:30.255]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.255]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.255]                       search = base::search(), system = base::Sys.info())
  [21:25:30.255]                   }
  [21:25:30.255]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.255]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.255]                     cond$call), session = sessionInformation(), 
  [21:25:30.255]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.255]                   signalCondition(cond)
  [21:25:30.255]                 }
  [21:25:30.255]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.255]                 ))) {
  [21:25:30.255]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.255]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.255]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.255]                   if (!signal) {
  [21:25:30.255]                     muffleCondition <- function (cond) 
  [21:25:30.255]                     {
  [21:25:30.255]                       inherits <- base::inherits
  [21:25:30.255]                       invokeRestart <- base::invokeRestart
  [21:25:30.255]                       muffled <- FALSE
  [21:25:30.255]                       if (inherits(cond, "message")) {
  [21:25:30.255]                         invokeRestart("muffleMessage")
  [21:25:30.255]                         muffled <- TRUE
  [21:25:30.255]                       }
  [21:25:30.255]                       else if (inherits(cond, "warning")) {
  [21:25:30.255]                         invokeRestart("muffleWarning")
  [21:25:30.255]                         muffled <- TRUE
  [21:25:30.255]                       }
  [21:25:30.255]                       else if (inherits(cond, "condition")) {
  [21:25:30.255]                         computeRestarts <- base::computeRestarts
  [21:25:30.255]                         grepl <- base::grepl
  [21:25:30.255]                         is.null <- base::is.null
  [21:25:30.255]                         restarts <- computeRestarts(cond)
  [21:25:30.255]                         for (restart in restarts) {
  [21:25:30.255]                           name <- restart$name
  [21:25:30.255]                           if (is.null(name)) 
  [21:25:30.255]                             next
  [21:25:30.255]                           if (!grepl("^muffle", name)) 
  [21:25:30.255]                             next
  [21:25:30.255]                           invokeRestart(restart)
  [21:25:30.255]                           muffled <- TRUE
  [21:25:30.255]                           break
  [21:25:30.255]                         }
  [21:25:30.255]                       }
  [21:25:30.255]                       invisible(muffled)
  [21:25:30.255]                     }
  [21:25:30.255]                     muffleCondition(cond)
  [21:25:30.255]                   }
  [21:25:30.255]                 }
  [21:25:30.255]             }
  [21:25:30.255]         }))
  [21:25:30.255]     }, error = function(ex) {
  [21:25:30.255]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.255]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.255]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.255]     }, finally = {
  [21:25:30.255]         {
  [21:25:30.255]             NULL
  [21:25:30.255]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.255]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.255]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.255]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.255]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.255]                 ...) 
  [21:25:30.255]             {
  [21:25:30.255]                 if (substitute) 
  [21:25:30.255]                   expr <- substitute(expr)
  [21:25:30.255]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.255]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.255]                   globals = globals, persistent = persistent, 
  [21:25:30.255]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.255]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.255]                   label = label, ...)
  [21:25:30.255]                 if (!future$lazy) 
  [21:25:30.255]                   future <- run(future)
  [21:25:30.255]                 invisible(future)
  [21:25:30.255]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.255]         }
  [21:25:30.255]         base::options(...future.oldOptions)
  [21:25:30.255]     })
  [21:25:30.255]     Sys.time
  [21:25:30.255]     if (base::is.na(TRUE)) {
  [21:25:30.255]     }
  [21:25:30.255]     else {
  [21:25:30.255]         base::sink(type = "output", split = FALSE)
  [21:25:30.255]         if (TRUE) {
  [21:25:30.255]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.255]         }
  [21:25:30.255]         else {
  [21:25:30.255]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.255]         }
  [21:25:30.255]         base::close(...future.stdout)
  [21:25:30.255]         ...future.stdout <- NULL
  [21:25:30.255]     }
  [21:25:30.255]     ...future.result$conditions <- ...future.conditions
  [21:25:30.255]     ...future.result
  [21:25:30.255] }
  [21:25:30.279] ClusterFuture started
  [21:25:30.279] getGlobalsAndPackages() ...
  [21:25:30.279] Searching for globals...
  [21:25:30.280] 
  [21:25:30.280] Searching for globals ... DONE
  [21:25:30.281] - globals: [0] <none>
  [21:25:30.281] getGlobalsAndPackages() ... DONE
  [21:25:30.286] Packages needed by the future expression (n = 0): <none>
  [21:25:30.287] Packages needed by future strategies (n = 0): <none>
  [21:25:30.313] {
  [21:25:30.313]     {
  [21:25:30.313]         ...future.startTime <- base::Sys.time()
  [21:25:30.313]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.313]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.313]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.313]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.313]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.313]         {
  [21:25:30.313]             {
  [21:25:30.313]                 base::local({
  [21:25:30.313]                   has_future <- base::requireNamespace("future", 
  [21:25:30.313]                     quietly = TRUE)
  [21:25:30.313]                   version <- if (has_future) 
  [21:25:30.313]                     utils::packageVersion("future")
  [21:25:30.313]                   else NULL
  [21:25:30.313]                   if (!has_future || version < "1.8.0") {
  [21:25:30.313]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.313]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.313]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.313]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.313]                         "release", "version")], collapse = " "), 
  [21:25:30.313]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.313]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.313]                       info)
  [21:25:30.313]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.313]                     if (!has_future) {
  [21:25:30.313]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.313]                         info)
  [21:25:30.313]                     }
  [21:25:30.313]                     else {
  [21:25:30.313]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.313]                         info, version)
  [21:25:30.313]                     }
  [21:25:30.313]                     base::stop(msg)
  [21:25:30.313]                   }
  [21:25:30.313]                 })
  [21:25:30.313]             }
  [21:25:30.313]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.313]         }
  [21:25:30.313]     }
  [21:25:30.313]     if (base::is.na(TRUE)) {
  [21:25:30.313]     }
  [21:25:30.313]     else {
  [21:25:30.313]         if (TRUE) {
  [21:25:30.313]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.313]                 open = "w")
  [21:25:30.313]         }
  [21:25:30.313]         else {
  [21:25:30.313]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.313]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.313]         }
  [21:25:30.313]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.313]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.313]             base::sink(type = "output", split = FALSE)
  [21:25:30.313]             base::close(...future.stdout)
  [21:25:30.313]         }, add = TRUE)
  [21:25:30.313]     }
  [21:25:30.313]     ...future.frame <- base::sys.nframe()
  [21:25:30.313]     ...future.conditions <- base::list()
  [21:25:30.313]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.313]     ...future.result <- base::tryCatch({
  [21:25:30.313]         base::withCallingHandlers({
  [21:25:30.313]             ...future.value <- base::withVisible(base::local({
  [21:25:30.313]                 ...future.sendCondition <- local({
  [21:25:30.313]                   sendCondition <- NULL
  [21:25:30.313]                   function(frame = 1L) {
  [21:25:30.313]                     if (is.function(sendCondition)) 
  [21:25:30.313]                       return(sendCondition)
  [21:25:30.313]                     ns <- getNamespace("parallel")
  [21:25:30.313]                     if (exists("sendData", mode = "function", 
  [21:25:30.313]                       envir = ns)) {
  [21:25:30.313]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.313]                         envir = ns)
  [21:25:30.313]                       envir <- sys.frame(frame)
  [21:25:30.313]                       master <- NULL
  [21:25:30.313]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.313]                         !identical(envir, emptyenv())) {
  [21:25:30.313]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.313]                           inherits = FALSE)) {
  [21:25:30.313]                           master <- get("master", mode = "list", 
  [21:25:30.313]                             envir = envir, inherits = FALSE)
  [21:25:30.313]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.313]                             sendCondition <<- function(cond) {
  [21:25:30.313]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.313]                                 success = TRUE)
  [21:25:30.313]                               parallel_sendData(master, data)
  [21:25:30.313]                             }
  [21:25:30.313]                             return(sendCondition)
  [21:25:30.313]                           }
  [21:25:30.313]                         }
  [21:25:30.313]                         frame <- frame + 1L
  [21:25:30.313]                         envir <- sys.frame(frame)
  [21:25:30.313]                       }
  [21:25:30.313]                     }
  [21:25:30.313]                     sendCondition <<- function(cond) NULL
  [21:25:30.313]                   }
  [21:25:30.313]                 })
  [21:25:30.313]                 withCallingHandlers({
  [21:25:30.313]                   NULL
  [21:25:30.313]                 }, immediateCondition = function(cond) {
  [21:25:30.313]                   sendCondition <- ...future.sendCondition()
  [21:25:30.313]                   sendCondition(cond)
  [21:25:30.313]                   muffleCondition <- function (cond) 
  [21:25:30.313]                   {
  [21:25:30.313]                     inherits <- base::inherits
  [21:25:30.313]                     invokeRestart <- base::invokeRestart
  [21:25:30.313]                     muffled <- FALSE
  [21:25:30.313]                     if (inherits(cond, "message")) {
  [21:25:30.313]                       invokeRestart("muffleMessage")
  [21:25:30.313]                       muffled <- TRUE
  [21:25:30.313]                     }
  [21:25:30.313]                     else if (inherits(cond, "warning")) {
  [21:25:30.313]                       invokeRestart("muffleWarning")
  [21:25:30.313]                       muffled <- TRUE
  [21:25:30.313]                     }
  [21:25:30.313]                     else if (inherits(cond, "condition")) {
  [21:25:30.313]                       computeRestarts <- base::computeRestarts
  [21:25:30.313]                       grepl <- base::grepl
  [21:25:30.313]                       is.null <- base::is.null
  [21:25:30.313]                       restarts <- computeRestarts(cond)
  [21:25:30.313]                       for (restart in restarts) {
  [21:25:30.313]                         name <- restart$name
  [21:25:30.313]                         if (is.null(name)) 
  [21:25:30.313]                           next
  [21:25:30.313]                         if (!grepl("^muffle", name)) 
  [21:25:30.313]                           next
  [21:25:30.313]                         invokeRestart(restart)
  [21:25:30.313]                         muffled <- TRUE
  [21:25:30.313]                         break
  [21:25:30.313]                       }
  [21:25:30.313]                     }
  [21:25:30.313]                     invisible(muffled)
  [21:25:30.313]                   }
  [21:25:30.313]                   muffleCondition(cond)
  [21:25:30.313]                 })
  [21:25:30.313]             }))
  [21:25:30.313]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.313]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.313]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.313]                 version = "1.8")
  [21:25:30.313]         }, condition = base::local({
  [21:25:30.313]             c <- base::c
  [21:25:30.313]             inherits <- base::inherits
  [21:25:30.313]             invokeRestart <- base::invokeRestart
  [21:25:30.313]             length <- base::length
  [21:25:30.313]             list <- base::list
  [21:25:30.313]             seq.int <- base::seq.int
  [21:25:30.313]             signalCondition <- base::signalCondition
  [21:25:30.313]             sys.calls <- base::sys.calls
  [21:25:30.313]             Sys.time <- base::Sys.time
  [21:25:30.313]             `[[` <- base::`[[`
  [21:25:30.313]             `+` <- base::`+`
  [21:25:30.313]             `<<-` <- base::`<<-`
  [21:25:30.313]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.313]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.313]                   3L)]
  [21:25:30.313]             }
  [21:25:30.313]             function(cond) {
  [21:25:30.313]                 if (inherits(cond, "error")) {
  [21:25:30.313]                   sessionInformation <- function() {
  [21:25:30.313]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.313]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.313]                       search = base::search(), system = base::Sys.info())
  [21:25:30.313]                   }
  [21:25:30.313]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.313]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.313]                     cond$call), session = sessionInformation(), 
  [21:25:30.313]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.313]                   signalCondition(cond)
  [21:25:30.313]                 }
  [21:25:30.313]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.313]                 ))) {
  [21:25:30.313]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.313]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.313]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.313]                   if (!signal) {
  [21:25:30.313]                     muffleCondition <- function (cond) 
  [21:25:30.313]                     {
  [21:25:30.313]                       inherits <- base::inherits
  [21:25:30.313]                       invokeRestart <- base::invokeRestart
  [21:25:30.313]                       muffled <- FALSE
  [21:25:30.313]                       if (inherits(cond, "message")) {
  [21:25:30.313]                         invokeRestart("muffleMessage")
  [21:25:30.313]                         muffled <- TRUE
  [21:25:30.313]                       }
  [21:25:30.313]                       else if (inherits(cond, "warning")) {
  [21:25:30.313]                         invokeRestart("muffleWarning")
  [21:25:30.313]                         muffled <- TRUE
  [21:25:30.313]                       }
  [21:25:30.313]                       else if (inherits(cond, "condition")) {
  [21:25:30.313]                         computeRestarts <- base::computeRestarts
  [21:25:30.313]                         grepl <- base::grepl
  [21:25:30.313]                         is.null <- base::is.null
  [21:25:30.313]                         restarts <- computeRestarts(cond)
  [21:25:30.313]                         for (restart in restarts) {
  [21:25:30.313]                           name <- restart$name
  [21:25:30.313]                           if (is.null(name)) 
  [21:25:30.313]                             next
  [21:25:30.313]                           if (!grepl("^muffle", name)) 
  [21:25:30.313]                             next
  [21:25:30.313]                           invokeRestart(restart)
  [21:25:30.313]                           muffled <- TRUE
  [21:25:30.313]                           break
  [21:25:30.313]                         }
  [21:25:30.313]                       }
  [21:25:30.313]                       invisible(muffled)
  [21:25:30.313]                     }
  [21:25:30.313]                     muffleCondition(cond)
  [21:25:30.313]                   }
  [21:25:30.313]                 }
  [21:25:30.313]             }
  [21:25:30.313]         }))
  [21:25:30.313]     }, error = function(ex) {
  [21:25:30.313]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.313]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.313]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.313]     }, finally = {
  [21:25:30.313]         {
  [21:25:30.313]             NULL
  [21:25:30.313]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.313]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.313]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.313]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.313]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.313]                 ...) 
  [21:25:30.313]             {
  [21:25:30.313]                 if (substitute) 
  [21:25:30.313]                   expr <- substitute(expr)
  [21:25:30.313]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.313]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.313]                   globals = globals, persistent = persistent, 
  [21:25:30.313]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.313]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.313]                   label = label, ...)
  [21:25:30.313]                 if (!future$lazy) 
  [21:25:30.313]                   future <- run(future)
  [21:25:30.313]                 invisible(future)
  [21:25:30.313]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.313]         }
  [21:25:30.313]         base::options(...future.oldOptions)
  [21:25:30.313]     })
  [21:25:30.313]     Sys.time
  [21:25:30.313]     if (base::is.na(TRUE)) {
  [21:25:30.313]     }
  [21:25:30.313]     else {
  [21:25:30.313]         base::sink(type = "output", split = FALSE)
  [21:25:30.313]         if (TRUE) {
  [21:25:30.313]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.313]         }
  [21:25:30.313]         else {
  [21:25:30.313]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.313]         }
  [21:25:30.313]         base::close(...future.stdout)
  [21:25:30.313]         ...future.stdout <- NULL
  [21:25:30.313]     }
  [21:25:30.313]     ...future.result$conditions <- ...future.conditions
  [21:25:30.313]     ...future.result
  [21:25:30.313] }
  [21:25:30.318] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.343] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.344] - Validating connection of ClusterFuture
  [21:25:30.344] - received message: FutureResult
  [21:25:30.345] - Received FutureResult
  [21:25:30.345] - Erased future from FutureRegistry
  [21:25:30.345] result() for ClusterFuture ...
  [21:25:30.346] - result already collected: FutureResult
  [21:25:30.346] result() for ClusterFuture ... done
  [21:25:30.347] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.347] result() for ClusterFuture ...
  [21:25:30.347] - result already collected: FutureResult
  [21:25:30.348] result() for ClusterFuture ... done
  [21:25:30.348] result() for ClusterFuture ...
  [21:25:30.348] - result already collected: FutureResult
  [21:25:30.349] result() for ClusterFuture ... done
  [21:25:30.351] ClusterFuture started
  [21:25:30.352] getGlobalsAndPackages() ...
  [21:25:30.353] Searching for globals...
  [21:25:30.354] - globals found: [1] '{'
  [21:25:30.354] Searching for globals ... DONE
  [21:25:30.355] Resolving globals: FALSE
  [21:25:30.355] 
  [21:25:30.356] 
  [21:25:30.356] getGlobalsAndPackages() ... DONE
  [21:25:30.361] Packages needed by the future expression (n = 0): <none>
  [21:25:30.361] Packages needed by future strategies (n = 0): <none>
  [21:25:30.382] {
  [21:25:30.382]     {
  [21:25:30.382]         ...future.startTime <- base::Sys.time()
  [21:25:30.382]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.382]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.382]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.382]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.382]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.382]         {
  [21:25:30.382]             {
  [21:25:30.382]                 base::local({
  [21:25:30.382]                   has_future <- base::requireNamespace("future", 
  [21:25:30.382]                     quietly = TRUE)
  [21:25:30.382]                   version <- if (has_future) 
  [21:25:30.382]                     utils::packageVersion("future")
  [21:25:30.382]                   else NULL
  [21:25:30.382]                   if (!has_future || version < "1.8.0") {
  [21:25:30.382]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.382]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.382]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.382]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.382]                         "release", "version")], collapse = " "), 
  [21:25:30.382]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.382]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.382]                       info)
  [21:25:30.382]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.382]                     if (!has_future) {
  [21:25:30.382]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.382]                         info)
  [21:25:30.382]                     }
  [21:25:30.382]                     else {
  [21:25:30.382]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.382]                         info, version)
  [21:25:30.382]                     }
  [21:25:30.382]                     base::stop(msg)
  [21:25:30.382]                   }
  [21:25:30.382]                 })
  [21:25:30.382]             }
  [21:25:30.382]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.382]         }
  [21:25:30.382]     }
  [21:25:30.382]     if (base::is.na(TRUE)) {
  [21:25:30.382]     }
  [21:25:30.382]     else {
  [21:25:30.382]         if (TRUE) {
  [21:25:30.382]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.382]                 open = "w")
  [21:25:30.382]         }
  [21:25:30.382]         else {
  [21:25:30.382]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.382]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.382]         }
  [21:25:30.382]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.382]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.382]             base::sink(type = "output", split = FALSE)
  [21:25:30.382]             base::close(...future.stdout)
  [21:25:30.382]         }, add = TRUE)
  [21:25:30.382]     }
  [21:25:30.382]     ...future.frame <- base::sys.nframe()
  [21:25:30.382]     ...future.conditions <- base::list()
  [21:25:30.382]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.382]     ...future.result <- base::tryCatch({
  [21:25:30.382]         base::withCallingHandlers({
  [21:25:30.382]             ...future.value <- base::withVisible(base::local({
  [21:25:30.382]                 ...future.sendCondition <- local({
  [21:25:30.382]                   sendCondition <- NULL
  [21:25:30.382]                   function(frame = 1L) {
  [21:25:30.382]                     if (is.function(sendCondition)) 
  [21:25:30.382]                       return(sendCondition)
  [21:25:30.382]                     ns <- getNamespace("parallel")
  [21:25:30.382]                     if (exists("sendData", mode = "function", 
  [21:25:30.382]                       envir = ns)) {
  [21:25:30.382]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.382]                         envir = ns)
  [21:25:30.382]                       envir <- sys.frame(frame)
  [21:25:30.382]                       master <- NULL
  [21:25:30.382]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.382]                         !identical(envir, emptyenv())) {
  [21:25:30.382]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.382]                           inherits = FALSE)) {
  [21:25:30.382]                           master <- get("master", mode = "list", 
  [21:25:30.382]                             envir = envir, inherits = FALSE)
  [21:25:30.382]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.382]                             sendCondition <<- function(cond) {
  [21:25:30.382]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.382]                                 success = TRUE)
  [21:25:30.382]                               parallel_sendData(master, data)
  [21:25:30.382]                             }
  [21:25:30.382]                             return(sendCondition)
  [21:25:30.382]                           }
  [21:25:30.382]                         }
  [21:25:30.382]                         frame <- frame + 1L
  [21:25:30.382]                         envir <- sys.frame(frame)
  [21:25:30.382]                       }
  [21:25:30.382]                     }
  [21:25:30.382]                     sendCondition <<- function(cond) NULL
  [21:25:30.382]                   }
  [21:25:30.382]                 })
  [21:25:30.382]                 withCallingHandlers({
  [21:25:30.382]                   {
  [21:25:30.382]                     4
  [21:25:30.382]                   }
  [21:25:30.382]                 }, immediateCondition = function(cond) {
  [21:25:30.382]                   sendCondition <- ...future.sendCondition()
  [21:25:30.382]                   sendCondition(cond)
  [21:25:30.382]                   muffleCondition <- function (cond) 
  [21:25:30.382]                   {
  [21:25:30.382]                     inherits <- base::inherits
  [21:25:30.382]                     invokeRestart <- base::invokeRestart
  [21:25:30.382]                     muffled <- FALSE
  [21:25:30.382]                     if (inherits(cond, "message")) {
  [21:25:30.382]                       invokeRestart("muffleMessage")
  [21:25:30.382]                       muffled <- TRUE
  [21:25:30.382]                     }
  [21:25:30.382]                     else if (inherits(cond, "warning")) {
  [21:25:30.382]                       invokeRestart("muffleWarning")
  [21:25:30.382]                       muffled <- TRUE
  [21:25:30.382]                     }
  [21:25:30.382]                     else if (inherits(cond, "condition")) {
  [21:25:30.382]                       computeRestarts <- base::computeRestarts
  [21:25:30.382]                       grepl <- base::grepl
  [21:25:30.382]                       is.null <- base::is.null
  [21:25:30.382]                       restarts <- computeRestarts(cond)
  [21:25:30.382]                       for (restart in restarts) {
  [21:25:30.382]                         name <- restart$name
  [21:25:30.382]                         if (is.null(name)) 
  [21:25:30.382]                           next
  [21:25:30.382]                         if (!grepl("^muffle", name)) 
  [21:25:30.382]                           next
  [21:25:30.382]                         invokeRestart(restart)
  [21:25:30.382]                         muffled <- TRUE
  [21:25:30.382]                         break
  [21:25:30.382]                       }
  [21:25:30.382]                     }
  [21:25:30.382]                     invisible(muffled)
  [21:25:30.382]                   }
  [21:25:30.382]                   muffleCondition(cond)
  [21:25:30.382]                 })
  [21:25:30.382]             }))
  [21:25:30.382]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.382]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.382]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.382]                 version = "1.8")
  [21:25:30.382]         }, condition = base::local({
  [21:25:30.382]             c <- base::c
  [21:25:30.382]             inherits <- base::inherits
  [21:25:30.382]             invokeRestart <- base::invokeRestart
  [21:25:30.382]             length <- base::length
  [21:25:30.382]             list <- base::list
  [21:25:30.382]             seq.int <- base::seq.int
  [21:25:30.382]             signalCondition <- base::signalCondition
  [21:25:30.382]             sys.calls <- base::sys.calls
  [21:25:30.382]             Sys.time <- base::Sys.time
  [21:25:30.382]             `[[` <- base::`[[`
  [21:25:30.382]             `+` <- base::`+`
  [21:25:30.382]             `<<-` <- base::`<<-`
  [21:25:30.382]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.382]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.382]                   3L)]
  [21:25:30.382]             }
  [21:25:30.382]             function(cond) {
  [21:25:30.382]                 if (inherits(cond, "error")) {
  [21:25:30.382]                   sessionInformation <- function() {
  [21:25:30.382]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.382]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.382]                       search = base::search(), system = base::Sys.info())
  [21:25:30.382]                   }
  [21:25:30.382]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.382]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.382]                     cond$call), session = sessionInformation(), 
  [21:25:30.382]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.382]                   signalCondition(cond)
  [21:25:30.382]                 }
  [21:25:30.382]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.382]                 ))) {
  [21:25:30.382]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.382]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.382]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.382]                   if (!signal) {
  [21:25:30.382]                     muffleCondition <- function (cond) 
  [21:25:30.382]                     {
  [21:25:30.382]                       inherits <- base::inherits
  [21:25:30.382]                       invokeRestart <- base::invokeRestart
  [21:25:30.382]                       muffled <- FALSE
  [21:25:30.382]                       if (inherits(cond, "message")) {
  [21:25:30.382]                         invokeRestart("muffleMessage")
  [21:25:30.382]                         muffled <- TRUE
  [21:25:30.382]                       }
  [21:25:30.382]                       else if (inherits(cond, "warning")) {
  [21:25:30.382]                         invokeRestart("muffleWarning")
  [21:25:30.382]                         muffled <- TRUE
  [21:25:30.382]                       }
  [21:25:30.382]                       else if (inherits(cond, "condition")) {
  [21:25:30.382]                         computeRestarts <- base::computeRestarts
  [21:25:30.382]                         grepl <- base::grepl
  [21:25:30.382]                         is.null <- base::is.null
  [21:25:30.382]                         restarts <- computeRestarts(cond)
  [21:25:30.382]                         for (restart in restarts) {
  [21:25:30.382]                           name <- restart$name
  [21:25:30.382]                           if (is.null(name)) 
  [21:25:30.382]                             next
  [21:25:30.382]                           if (!grepl("^muffle", name)) 
  [21:25:30.382]                             next
  [21:25:30.382]                           invokeRestart(restart)
  [21:25:30.382]                           muffled <- TRUE
  [21:25:30.382]                           break
  [21:25:30.382]                         }
  [21:25:30.382]                       }
  [21:25:30.382]                       invisible(muffled)
  [21:25:30.382]                     }
  [21:25:30.382]                     muffleCondition(cond)
  [21:25:30.382]                   }
  [21:25:30.382]                 }
  [21:25:30.382]             }
  [21:25:30.382]         }))
  [21:25:30.382]     }, error = function(ex) {
  [21:25:30.382]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.382]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.382]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.382]     }, finally = {
  [21:25:30.382]         {
  [21:25:30.382]             NULL
  [21:25:30.382]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.382]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.382]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.382]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.382]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.382]                 ...) 
  [21:25:30.382]             {
  [21:25:30.382]                 if (substitute) 
  [21:25:30.382]                   expr <- substitute(expr)
  [21:25:30.382]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.382]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.382]                   globals = globals, persistent = persistent, 
  [21:25:30.382]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.382]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.382]                   label = label, ...)
  [21:25:30.382]                 if (!future$lazy) 
  [21:25:30.382]                   future <- run(future)
  [21:25:30.382]                 invisible(future)
  [21:25:30.382]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.382]         }
  [21:25:30.382]         base::options(...future.oldOptions)
  [21:25:30.382]     })
  [21:25:30.382]     Sys.time
  [21:25:30.382]     if (base::is.na(TRUE)) {
  [21:25:30.382]     }
  [21:25:30.382]     else {
  [21:25:30.382]         base::sink(type = "output", split = FALSE)
  [21:25:30.382]         if (TRUE) {
  [21:25:30.382]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.382]         }
  [21:25:30.382]         else {
  [21:25:30.382]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.382]         }
  [21:25:30.382]         base::close(...future.stdout)
  [21:25:30.382]         ...future.stdout <- NULL
  [21:25:30.382]     }
  [21:25:30.382]     ...future.result$conditions <- ...future.conditions
  [21:25:30.382]     ...future.result
  [21:25:30.382] }
  [21:25:30.400] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.411] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.412] - Validating connection of ClusterFuture
  [21:25:30.412] - received message: FutureResult
  [21:25:30.413] - Received FutureResult
  [21:25:30.413] - Erased future from FutureRegistry
  [21:25:30.413] result() for ClusterFuture ...
  [21:25:30.414] - result already collected: FutureResult
  [21:25:30.414] result() for ClusterFuture ... done
  [21:25:30.414] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.415] result() for ClusterFuture ...
  [21:25:30.415] - result already collected: FutureResult
  [21:25:30.415] result() for ClusterFuture ... done
  [21:25:30.416] result() for ClusterFuture ...
  [21:25:30.416] - result already collected: FutureResult
  [21:25:30.417] result() for ClusterFuture ... done
  [21:25:30.419] ClusterFuture started
  <environment: 0x55ef22427120> 
  <environment: 0x55ef225abd40> 
  [21:25:30.466] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.467] - Validating connection of ClusterFuture
  [21:25:30.467] - received message: FutureResult
  [21:25:30.468] - Received FutureResult
  [21:25:30.468] - Erased future from FutureRegistry
  [21:25:30.468] result() for ClusterFuture ...
  [21:25:30.468] - result already collected: FutureResult
  [21:25:30.469] result() for ClusterFuture ... done
  [21:25:30.469] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:30.472] resolve() on environment ...
  [21:25:30.472]  recursive: 0
  [21:25:30.474]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:30.474] signalConditionsASAP(numeric, pos=1) ...
  [21:25:30.474] - nx: 4
  [21:25:30.474] - relay: TRUE
  [21:25:30.475] - stdout: TRUE
  [21:25:30.475] - signal: TRUE
  [21:25:30.475] - resignal: FALSE
  [21:25:30.475] - force: TRUE
  [21:25:30.476] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.476] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.476]  - until=2
  [21:25:30.477]  - relaying element #2
  [21:25:30.477] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.477] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.477] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:30.478]  length: 3 (resolved future 1)
  [21:25:30.478] Future #2
  [21:25:30.478] result() for ClusterFuture ...
  [21:25:30.479] - result already collected: FutureResult
  [21:25:30.479] result() for ClusterFuture ... done
  [21:25:30.479] result() for ClusterFuture ...
  [21:25:30.479] - result already collected: FutureResult
  [21:25:30.480] result() for ClusterFuture ... done
  [21:25:30.480] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:30.480] - nx: 4
  [21:25:30.481] - relay: TRUE
  [21:25:30.481] - stdout: TRUE
  [21:25:30.481] - signal: TRUE
  [21:25:30.481] - resignal: FALSE
  [21:25:30.482] - force: TRUE
  [21:25:30.482] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.482] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.482]  - until=2
  [21:25:30.483]  - relaying element #2
  [21:25:30.483] result() for ClusterFuture ...
  [21:25:30.483] - result already collected: FutureResult
  [21:25:30.483] result() for ClusterFuture ... done
  [21:25:30.484] result() for ClusterFuture ...
  [21:25:30.484] - result already collected: FutureResult
  [21:25:30.484] result() for ClusterFuture ... done
  [21:25:30.485] result() for ClusterFuture ...
  [21:25:30.485] - result already collected: FutureResult
  [21:25:30.485] result() for ClusterFuture ... done
  [21:25:30.486] result() for ClusterFuture ...
  [21:25:30.486] - result already collected: FutureResult
  [21:25:30.486] result() for ClusterFuture ... done
  [21:25:30.486] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.487] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.487] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:30.487]  length: 2 (resolved future 2)
  [21:25:30.488] Future #3
  [21:25:30.488] result() for ClusterFuture ...
  [21:25:30.488] - result already collected: FutureResult
  [21:25:30.488] result() for ClusterFuture ... done
  [21:25:30.489] result() for ClusterFuture ...
  [21:25:30.489] - result already collected: FutureResult
  [21:25:30.489] result() for ClusterFuture ... done
  [21:25:30.490] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:30.490] - nx: 4
  [21:25:30.490] - relay: TRUE
  [21:25:30.490] - stdout: TRUE
  [21:25:30.491] - signal: TRUE
  [21:25:30.491] - resignal: FALSE
  [21:25:30.491] - force: TRUE
  [21:25:30.491] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.492] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.492]  - until=3
  [21:25:30.492]  - relaying element #3
  [21:25:30.529] result() for ClusterFuture ...
  [21:25:30.529] - result already collected: FutureResult
  [21:25:30.529] result() for ClusterFuture ... done
  [21:25:30.530] result() for ClusterFuture ...
  [21:25:30.530] - result already collected: FutureResult
  [21:25:30.530] result() for ClusterFuture ... done
  [21:25:30.531] result() for ClusterFuture ...
  [21:25:30.531] - result already collected: FutureResult
  [21:25:30.531] result() for ClusterFuture ... done
  [21:25:30.531] result() for ClusterFuture ...
  [21:25:30.532] - result already collected: FutureResult
  [21:25:30.532] result() for ClusterFuture ... done
  [21:25:30.532] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.533] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.533] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:30.533]  length: 1 (resolved future 3)
  [21:25:30.534] Future #4
  [21:25:30.534] result() for ClusterFuture ...
  [21:25:30.534] - result already collected: FutureResult
  [21:25:30.534] result() for ClusterFuture ... done
  [21:25:30.535] result() for ClusterFuture ...
  [21:25:30.535] - result already collected: FutureResult
  [21:25:30.535] result() for ClusterFuture ... done
  [21:25:30.536] signalConditionsASAP(ClusterFuture, pos=4) ...
  [21:25:30.536] - nx: 4
  [21:25:30.536] - relay: TRUE
  [21:25:30.536] - stdout: TRUE
  [21:25:30.537] - signal: TRUE
  [21:25:30.537] - resignal: FALSE
  [21:25:30.537] - force: TRUE
  [21:25:30.537] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.538] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.538]  - until=4
  [21:25:30.538]  - relaying element #4
  [21:25:30.539] result() for ClusterFuture ...
  [21:25:30.539] - result already collected: FutureResult
  [21:25:30.539] result() for ClusterFuture ... done
  [21:25:30.539] result() for ClusterFuture ...
  [21:25:30.540] - result already collected: FutureResult
  [21:25:30.540] result() for ClusterFuture ... done
  [21:25:30.540] result() for ClusterFuture ...
  [21:25:30.541] - result already collected: FutureResult
  [21:25:30.541] result() for ClusterFuture ... done
  [21:25:30.541] result() for ClusterFuture ...
  [21:25:30.542] - result already collected: FutureResult
  [21:25:30.558] result() for ClusterFuture ... done
  [21:25:30.558] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.559] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.559] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [21:25:30.559]  length: 0 (resolved future 4)
  [21:25:30.559] Relaying remaining futures
  [21:25:30.560] signalConditionsASAP(NULL, pos=0) ...
  [21:25:30.560] - nx: 4
  [21:25:30.560] - relay: TRUE
  [21:25:30.560] - stdout: TRUE
  [21:25:30.561] - signal: TRUE
  [21:25:30.561] - resignal: FALSE
  [21:25:30.561] - force: TRUE
  [21:25:30.561] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.562] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:30.562] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.562] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.563] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:30.563] resolve() on environment ... DONE
  [21:25:30.563] result() for ClusterFuture ...
  [21:25:30.563] - result already collected: FutureResult
  [21:25:30.564] result() for ClusterFuture ... done
  [21:25:30.564] result() for ClusterFuture ...
  [21:25:30.564] - result already collected: FutureResult
  [21:25:30.564] result() for ClusterFuture ... done
  [21:25:30.565] result() for ClusterFuture ...
  [21:25:30.565] - result already collected: FutureResult
  [21:25:30.565] result() for ClusterFuture ... done
  [21:25:30.566] result() for ClusterFuture ...
  [21:25:30.566] - result already collected: FutureResult
  [21:25:30.566] result() for ClusterFuture ... done
  [21:25:30.566] result() for ClusterFuture ...
  [21:25:30.567] - result already collected: FutureResult
  [21:25:30.567] result() for ClusterFuture ... done
  [21:25:30.567] result() for ClusterFuture ...
  [21:25:30.567] - result already collected: FutureResult
  [21:25:30.568] result() for ClusterFuture ... done
  <environment: 0x55ef22732738> 
  Dimensions: c(2, 3, 1)
  [21:25:30.569] getGlobalsAndPackages() ...
  [21:25:30.569] Searching for globals...
  [21:25:30.570] 
  [21:25:30.570] Searching for globals ... DONE
  [21:25:30.570] - globals: [0] <none>
  [21:25:30.571] getGlobalsAndPackages() ... DONE
  [21:25:30.599] Packages needed by the future expression (n = 0): <none>
  [21:25:30.599] Packages needed by future strategies (n = 0): <none>
  [21:25:30.604] {
  [21:25:30.604]     {
  [21:25:30.604]         ...future.startTime <- base::Sys.time()
  [21:25:30.604]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.604]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.604]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.604]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.604]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.604]         {
  [21:25:30.604]             {
  [21:25:30.604]                 base::local({
  [21:25:30.604]                   has_future <- base::requireNamespace("future", 
  [21:25:30.604]                     quietly = TRUE)
  [21:25:30.604]                   version <- if (has_future) 
  [21:25:30.604]                     utils::packageVersion("future")
  [21:25:30.604]                   else NULL
  [21:25:30.604]                   if (!has_future || version < "1.8.0") {
  [21:25:30.604]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.604]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.604]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.604]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.604]                         "release", "version")], collapse = " "), 
  [21:25:30.604]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.604]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.604]                       info)
  [21:25:30.604]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.604]                     if (!has_future) {
  [21:25:30.604]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.604]                         info)
  [21:25:30.604]                     }
  [21:25:30.604]                     else {
  [21:25:30.604]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.604]                         info, version)
  [21:25:30.604]                     }
  [21:25:30.604]                     base::stop(msg)
  [21:25:30.604]                   }
  [21:25:30.604]                 })
  [21:25:30.604]             }
  [21:25:30.604]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.604]         }
  [21:25:30.604]     }
  [21:25:30.604]     if (base::is.na(TRUE)) {
  [21:25:30.604]     }
  [21:25:30.604]     else {
  [21:25:30.604]         if (TRUE) {
  [21:25:30.604]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.604]                 open = "w")
  [21:25:30.604]         }
  [21:25:30.604]         else {
  [21:25:30.604]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.604]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.604]         }
  [21:25:30.604]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.604]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.604]             base::sink(type = "output", split = FALSE)
  [21:25:30.604]             base::close(...future.stdout)
  [21:25:30.604]         }, add = TRUE)
  [21:25:30.604]     }
  [21:25:30.604]     ...future.frame <- base::sys.nframe()
  [21:25:30.604]     ...future.conditions <- base::list()
  [21:25:30.604]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.604]     ...future.result <- base::tryCatch({
  [21:25:30.604]         base::withCallingHandlers({
  [21:25:30.604]             ...future.value <- base::withVisible(base::local({
  [21:25:30.604]                 ...future.sendCondition <- local({
  [21:25:30.604]                   sendCondition <- NULL
  [21:25:30.604]                   function(frame = 1L) {
  [21:25:30.604]                     if (is.function(sendCondition)) 
  [21:25:30.604]                       return(sendCondition)
  [21:25:30.604]                     ns <- getNamespace("parallel")
  [21:25:30.604]                     if (exists("sendData", mode = "function", 
  [21:25:30.604]                       envir = ns)) {
  [21:25:30.604]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.604]                         envir = ns)
  [21:25:30.604]                       envir <- sys.frame(frame)
  [21:25:30.604]                       master <- NULL
  [21:25:30.604]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.604]                         !identical(envir, emptyenv())) {
  [21:25:30.604]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.604]                           inherits = FALSE)) {
  [21:25:30.604]                           master <- get("master", mode = "list", 
  [21:25:30.604]                             envir = envir, inherits = FALSE)
  [21:25:30.604]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.604]                             sendCondition <<- function(cond) {
  [21:25:30.604]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.604]                                 success = TRUE)
  [21:25:30.604]                               parallel_sendData(master, data)
  [21:25:30.604]                             }
  [21:25:30.604]                             return(sendCondition)
  [21:25:30.604]                           }
  [21:25:30.604]                         }
  [21:25:30.604]                         frame <- frame + 1L
  [21:25:30.604]                         envir <- sys.frame(frame)
  [21:25:30.604]                       }
  [21:25:30.604]                     }
  [21:25:30.604]                     sendCondition <<- function(cond) NULL
  [21:25:30.604]                   }
  [21:25:30.604]                 })
  [21:25:30.604]                 withCallingHandlers({
  [21:25:30.604]                   2
  [21:25:30.604]                 }, immediateCondition = function(cond) {
  [21:25:30.604]                   sendCondition <- ...future.sendCondition()
  [21:25:30.604]                   sendCondition(cond)
  [21:25:30.604]                   muffleCondition <- function (cond) 
  [21:25:30.604]                   {
  [21:25:30.604]                     inherits <- base::inherits
  [21:25:30.604]                     invokeRestart <- base::invokeRestart
  [21:25:30.604]                     muffled <- FALSE
  [21:25:30.604]                     if (inherits(cond, "message")) {
  [21:25:30.604]                       invokeRestart("muffleMessage")
  [21:25:30.604]                       muffled <- TRUE
  [21:25:30.604]                     }
  [21:25:30.604]                     else if (inherits(cond, "warning")) {
  [21:25:30.604]                       invokeRestart("muffleWarning")
  [21:25:30.604]                       muffled <- TRUE
  [21:25:30.604]                     }
  [21:25:30.604]                     else if (inherits(cond, "condition")) {
  [21:25:30.604]                       computeRestarts <- base::computeRestarts
  [21:25:30.604]                       grepl <- base::grepl
  [21:25:30.604]                       is.null <- base::is.null
  [21:25:30.604]                       restarts <- computeRestarts(cond)
  [21:25:30.604]                       for (restart in restarts) {
  [21:25:30.604]                         name <- restart$name
  [21:25:30.604]                         if (is.null(name)) 
  [21:25:30.604]                           next
  [21:25:30.604]                         if (!grepl("^muffle", name)) 
  [21:25:30.604]                           next
  [21:25:30.604]                         invokeRestart(restart)
  [21:25:30.604]                         muffled <- TRUE
  [21:25:30.604]                         break
  [21:25:30.604]                       }
  [21:25:30.604]                     }
  [21:25:30.604]                     invisible(muffled)
  [21:25:30.604]                   }
  [21:25:30.604]                   muffleCondition(cond)
  [21:25:30.604]                 })
  [21:25:30.604]             }))
  [21:25:30.604]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.604]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.604]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.604]                 version = "1.8")
  [21:25:30.604]         }, condition = base::local({
  [21:25:30.604]             c <- base::c
  [21:25:30.604]             inherits <- base::inherits
  [21:25:30.604]             invokeRestart <- base::invokeRestart
  [21:25:30.604]             length <- base::length
  [21:25:30.604]             list <- base::list
  [21:25:30.604]             seq.int <- base::seq.int
  [21:25:30.604]             signalCondition <- base::signalCondition
  [21:25:30.604]             sys.calls <- base::sys.calls
  [21:25:30.604]             Sys.time <- base::Sys.time
  [21:25:30.604]             `[[` <- base::`[[`
  [21:25:30.604]             `+` <- base::`+`
  [21:25:30.604]             `<<-` <- base::`<<-`
  [21:25:30.604]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.604]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.604]                   3L)]
  [21:25:30.604]             }
  [21:25:30.604]             function(cond) {
  [21:25:30.604]                 if (inherits(cond, "error")) {
  [21:25:30.604]                   sessionInformation <- function() {
  [21:25:30.604]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.604]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.604]                       search = base::search(), system = base::Sys.info())
  [21:25:30.604]                   }
  [21:25:30.604]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.604]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.604]                     cond$call), session = sessionInformation(), 
  [21:25:30.604]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.604]                   signalCondition(cond)
  [21:25:30.604]                 }
  [21:25:30.604]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.604]                 ))) {
  [21:25:30.604]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.604]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.604]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.604]                   if (!signal) {
  [21:25:30.604]                     muffleCondition <- function (cond) 
  [21:25:30.604]                     {
  [21:25:30.604]                       inherits <- base::inherits
  [21:25:30.604]                       invokeRestart <- base::invokeRestart
  [21:25:30.604]                       muffled <- FALSE
  [21:25:30.604]                       if (inherits(cond, "message")) {
  [21:25:30.604]                         invokeRestart("muffleMessage")
  [21:25:30.604]                         muffled <- TRUE
  [21:25:30.604]                       }
  [21:25:30.604]                       else if (inherits(cond, "warning")) {
  [21:25:30.604]                         invokeRestart("muffleWarning")
  [21:25:30.604]                         muffled <- TRUE
  [21:25:30.604]                       }
  [21:25:30.604]                       else if (inherits(cond, "condition")) {
  [21:25:30.604]                         computeRestarts <- base::computeRestarts
  [21:25:30.604]                         grepl <- base::grepl
  [21:25:30.604]                         is.null <- base::is.null
  [21:25:30.604]                         restarts <- computeRestarts(cond)
  [21:25:30.604]                         for (restart in restarts) {
  [21:25:30.604]                           name <- restart$name
  [21:25:30.604]                           if (is.null(name)) 
  [21:25:30.604]                             next
  [21:25:30.604]                           if (!grepl("^muffle", name)) 
  [21:25:30.604]                             next
  [21:25:30.604]                           invokeRestart(restart)
  [21:25:30.604]                           muffled <- TRUE
  [21:25:30.604]                           break
  [21:25:30.604]                         }
  [21:25:30.604]                       }
  [21:25:30.604]                       invisible(muffled)
  [21:25:30.604]                     }
  [21:25:30.604]                     muffleCondition(cond)
  [21:25:30.604]                   }
  [21:25:30.604]                 }
  [21:25:30.604]             }
  [21:25:30.604]         }))
  [21:25:30.604]     }, error = function(ex) {
  [21:25:30.604]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.604]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.604]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.604]     }, finally = {
  [21:25:30.604]         {
  [21:25:30.604]             NULL
  [21:25:30.604]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.604]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.604]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.604]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.604]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.604]                 ...) 
  [21:25:30.604]             {
  [21:25:30.604]                 if (substitute) 
  [21:25:30.604]                   expr <- substitute(expr)
  [21:25:30.604]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.604]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.604]                   globals = globals, persistent = persistent, 
  [21:25:30.604]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.604]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.604]                   label = label, ...)
  [21:25:30.604]                 if (!future$lazy) 
  [21:25:30.604]                   future <- run(future)
  [21:25:30.604]                 invisible(future)
  [21:25:30.604]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.604]         }
  [21:25:30.604]         base::options(...future.oldOptions)
  [21:25:30.604]     })
  [21:25:30.604]     Sys.time
  [21:25:30.604]     if (base::is.na(TRUE)) {
  [21:25:30.604]     }
  [21:25:30.604]     else {
  [21:25:30.604]         base::sink(type = "output", split = FALSE)
  [21:25:30.604]         if (TRUE) {
  [21:25:30.604]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.604]         }
  [21:25:30.604]         else {
  [21:25:30.604]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.604]         }
  [21:25:30.604]         base::close(...future.stdout)
  [21:25:30.604]         ...future.stdout <- NULL
  [21:25:30.604]     }
  [21:25:30.604]     ...future.result$conditions <- ...future.conditions
  [21:25:30.604]     ...future.result
  [21:25:30.604] }
  [21:25:30.610] ClusterFuture started
  [21:25:30.610] getGlobalsAndPackages() ...
  [21:25:30.611] Searching for globals...
  [21:25:30.611] 
  [21:25:30.612] Searching for globals ... DONE
  [21:25:30.612] - globals: [0] <none>
  [21:25:30.612] getGlobalsAndPackages() ... DONE
  [21:25:30.616] Packages needed by the future expression (n = 0): <none>
  [21:25:30.616] Packages needed by future strategies (n = 0): <none>
  [21:25:30.620] {
  [21:25:30.620]     {
  [21:25:30.620]         ...future.startTime <- base::Sys.time()
  [21:25:30.620]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.620]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.620]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.620]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.620]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.620]         {
  [21:25:30.620]             {
  [21:25:30.620]                 base::local({
  [21:25:30.620]                   has_future <- base::requireNamespace("future", 
  [21:25:30.620]                     quietly = TRUE)
  [21:25:30.620]                   version <- if (has_future) 
  [21:25:30.620]                     utils::packageVersion("future")
  [21:25:30.620]                   else NULL
  [21:25:30.620]                   if (!has_future || version < "1.8.0") {
  [21:25:30.620]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.620]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.620]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.620]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.620]                         "release", "version")], collapse = " "), 
  [21:25:30.620]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.620]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.620]                       info)
  [21:25:30.620]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.620]                     if (!has_future) {
  [21:25:30.620]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.620]                         info)
  [21:25:30.620]                     }
  [21:25:30.620]                     else {
  [21:25:30.620]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.620]                         info, version)
  [21:25:30.620]                     }
  [21:25:30.620]                     base::stop(msg)
  [21:25:30.620]                   }
  [21:25:30.620]                 })
  [21:25:30.620]             }
  [21:25:30.620]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.620]         }
  [21:25:30.620]     }
  [21:25:30.620]     if (base::is.na(TRUE)) {
  [21:25:30.620]     }
  [21:25:30.620]     else {
  [21:25:30.620]         if (TRUE) {
  [21:25:30.620]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.620]                 open = "w")
  [21:25:30.620]         }
  [21:25:30.620]         else {
  [21:25:30.620]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.620]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.620]         }
  [21:25:30.620]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.620]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.620]             base::sink(type = "output", split = FALSE)
  [21:25:30.620]             base::close(...future.stdout)
  [21:25:30.620]         }, add = TRUE)
  [21:25:30.620]     }
  [21:25:30.620]     ...future.frame <- base::sys.nframe()
  [21:25:30.620]     ...future.conditions <- base::list()
  [21:25:30.620]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.620]     ...future.result <- base::tryCatch({
  [21:25:30.620]         base::withCallingHandlers({
  [21:25:30.620]             ...future.value <- base::withVisible(base::local({
  [21:25:30.620]                 ...future.sendCondition <- local({
  [21:25:30.620]                   sendCondition <- NULL
  [21:25:30.620]                   function(frame = 1L) {
  [21:25:30.620]                     if (is.function(sendCondition)) 
  [21:25:30.620]                       return(sendCondition)
  [21:25:30.620]                     ns <- getNamespace("parallel")
  [21:25:30.620]                     if (exists("sendData", mode = "function", 
  [21:25:30.620]                       envir = ns)) {
  [21:25:30.620]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.620]                         envir = ns)
  [21:25:30.620]                       envir <- sys.frame(frame)
  [21:25:30.620]                       master <- NULL
  [21:25:30.620]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.620]                         !identical(envir, emptyenv())) {
  [21:25:30.620]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.620]                           inherits = FALSE)) {
  [21:25:30.620]                           master <- get("master", mode = "list", 
  [21:25:30.620]                             envir = envir, inherits = FALSE)
  [21:25:30.620]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.620]                             sendCondition <<- function(cond) {
  [21:25:30.620]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.620]                                 success = TRUE)
  [21:25:30.620]                               parallel_sendData(master, data)
  [21:25:30.620]                             }
  [21:25:30.620]                             return(sendCondition)
  [21:25:30.620]                           }
  [21:25:30.620]                         }
  [21:25:30.620]                         frame <- frame + 1L
  [21:25:30.620]                         envir <- sys.frame(frame)
  [21:25:30.620]                       }
  [21:25:30.620]                     }
  [21:25:30.620]                     sendCondition <<- function(cond) NULL
  [21:25:30.620]                   }
  [21:25:30.620]                 })
  [21:25:30.620]                 withCallingHandlers({
  [21:25:30.620]                   NULL
  [21:25:30.620]                 }, immediateCondition = function(cond) {
  [21:25:30.620]                   sendCondition <- ...future.sendCondition()
  [21:25:30.620]                   sendCondition(cond)
  [21:25:30.620]                   muffleCondition <- function (cond) 
  [21:25:30.620]                   {
  [21:25:30.620]                     inherits <- base::inherits
  [21:25:30.620]                     invokeRestart <- base::invokeRestart
  [21:25:30.620]                     muffled <- FALSE
  [21:25:30.620]                     if (inherits(cond, "message")) {
  [21:25:30.620]                       invokeRestart("muffleMessage")
  [21:25:30.620]                       muffled <- TRUE
  [21:25:30.620]                     }
  [21:25:30.620]                     else if (inherits(cond, "warning")) {
  [21:25:30.620]                       invokeRestart("muffleWarning")
  [21:25:30.620]                       muffled <- TRUE
  [21:25:30.620]                     }
  [21:25:30.620]                     else if (inherits(cond, "condition")) {
  [21:25:30.620]                       computeRestarts <- base::computeRestarts
  [21:25:30.620]                       grepl <- base::grepl
  [21:25:30.620]                       is.null <- base::is.null
  [21:25:30.620]                       restarts <- computeRestarts(cond)
  [21:25:30.620]                       for (restart in restarts) {
  [21:25:30.620]                         name <- restart$name
  [21:25:30.620]                         if (is.null(name)) 
  [21:25:30.620]                           next
  [21:25:30.620]                         if (!grepl("^muffle", name)) 
  [21:25:30.620]                           next
  [21:25:30.620]                         invokeRestart(restart)
  [21:25:30.620]                         muffled <- TRUE
  [21:25:30.620]                         break
  [21:25:30.620]                       }
  [21:25:30.620]                     }
  [21:25:30.620]                     invisible(muffled)
  [21:25:30.620]                   }
  [21:25:30.620]                   muffleCondition(cond)
  [21:25:30.620]                 })
  [21:25:30.620]             }))
  [21:25:30.620]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.620]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.620]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.620]                 version = "1.8")
  [21:25:30.620]         }, condition = base::local({
  [21:25:30.620]             c <- base::c
  [21:25:30.620]             inherits <- base::inherits
  [21:25:30.620]             invokeRestart <- base::invokeRestart
  [21:25:30.620]             length <- base::length
  [21:25:30.620]             list <- base::list
  [21:25:30.620]             seq.int <- base::seq.int
  [21:25:30.620]             signalCondition <- base::signalCondition
  [21:25:30.620]             sys.calls <- base::sys.calls
  [21:25:30.620]             Sys.time <- base::Sys.time
  [21:25:30.620]             `[[` <- base::`[[`
  [21:25:30.620]             `+` <- base::`+`
  [21:25:30.620]             `<<-` <- base::`<<-`
  [21:25:30.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.620]                   3L)]
  [21:25:30.620]             }
  [21:25:30.620]             function(cond) {
  [21:25:30.620]                 if (inherits(cond, "error")) {
  [21:25:30.620]                   sessionInformation <- function() {
  [21:25:30.620]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.620]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.620]                       search = base::search(), system = base::Sys.info())
  [21:25:30.620]                   }
  [21:25:30.620]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.620]                     cond$call), session = sessionInformation(), 
  [21:25:30.620]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.620]                   signalCondition(cond)
  [21:25:30.620]                 }
  [21:25:30.620]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.620]                 ))) {
  [21:25:30.620]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.620]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.620]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.620]                   if (!signal) {
  [21:25:30.620]                     muffleCondition <- function (cond) 
  [21:25:30.620]                     {
  [21:25:30.620]                       inherits <- base::inherits
  [21:25:30.620]                       invokeRestart <- base::invokeRestart
  [21:25:30.620]                       muffled <- FALSE
  [21:25:30.620]                       if (inherits(cond, "message")) {
  [21:25:30.620]                         invokeRestart("muffleMessage")
  [21:25:30.620]                         muffled <- TRUE
  [21:25:30.620]                       }
  [21:25:30.620]                       else if (inherits(cond, "warning")) {
  [21:25:30.620]                         invokeRestart("muffleWarning")
  [21:25:30.620]                         muffled <- TRUE
  [21:25:30.620]                       }
  [21:25:30.620]                       else if (inherits(cond, "condition")) {
  [21:25:30.620]                         computeRestarts <- base::computeRestarts
  [21:25:30.620]                         grepl <- base::grepl
  [21:25:30.620]                         is.null <- base::is.null
  [21:25:30.620]                         restarts <- computeRestarts(cond)
  [21:25:30.620]                         for (restart in restarts) {
  [21:25:30.620]                           name <- restart$name
  [21:25:30.620]                           if (is.null(name)) 
  [21:25:30.620]                             next
  [21:25:30.620]                           if (!grepl("^muffle", name)) 
  [21:25:30.620]                             next
  [21:25:30.620]                           invokeRestart(restart)
  [21:25:30.620]                           muffled <- TRUE
  [21:25:30.620]                           break
  [21:25:30.620]                         }
  [21:25:30.620]                       }
  [21:25:30.620]                       invisible(muffled)
  [21:25:30.620]                     }
  [21:25:30.620]                     muffleCondition(cond)
  [21:25:30.620]                   }
  [21:25:30.620]                 }
  [21:25:30.620]             }
  [21:25:30.620]         }))
  [21:25:30.620]     }, error = function(ex) {
  [21:25:30.620]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.620]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.620]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.620]     }, finally = {
  [21:25:30.620]         {
  [21:25:30.620]             NULL
  [21:25:30.620]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.620]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.620]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.620]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.620]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.620]                 ...) 
  [21:25:30.620]             {
  [21:25:30.620]                 if (substitute) 
  [21:25:30.620]                   expr <- substitute(expr)
  [21:25:30.620]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.620]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.620]                   globals = globals, persistent = persistent, 
  [21:25:30.620]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.620]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.620]                   label = label, ...)
  [21:25:30.620]                 if (!future$lazy) 
  [21:25:30.620]                   future <- run(future)
  [21:25:30.620]                 invisible(future)
  [21:25:30.620]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.620]         }
  [21:25:30.620]         base::options(...future.oldOptions)
  [21:25:30.620]     })
  [21:25:30.620]     Sys.time
  [21:25:30.620]     if (base::is.na(TRUE)) {
  [21:25:30.620]     }
  [21:25:30.620]     else {
  [21:25:30.620]         base::sink(type = "output", split = FALSE)
  [21:25:30.620]         if (TRUE) {
  [21:25:30.620]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.620]         }
  [21:25:30.620]         else {
  [21:25:30.620]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.620]         }
  [21:25:30.620]         base::close(...future.stdout)
  [21:25:30.620]         ...future.stdout <- NULL
  [21:25:30.620]     }
  [21:25:30.620]     ...future.result$conditions <- ...future.conditions
  [21:25:30.620]     ...future.result
  [21:25:30.620] }
  [21:25:30.641] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.655] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.656] - Validating connection of ClusterFuture
  [21:25:30.656] - received message: FutureResult
  [21:25:30.657] - Received FutureResult
  [21:25:30.657] - Erased future from FutureRegistry
  [21:25:30.657] result() for ClusterFuture ...
  [21:25:30.657] - result already collected: FutureResult
  [21:25:30.658] result() for ClusterFuture ... done
  [21:25:30.658] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.659] result() for ClusterFuture ...
  [21:25:30.659] - result already collected: FutureResult
  [21:25:30.659] result() for ClusterFuture ... done
  [21:25:30.659] result() for ClusterFuture ...
  [21:25:30.660] - result already collected: FutureResult
  [21:25:30.660] result() for ClusterFuture ... done
  [21:25:30.665] ClusterFuture started
  [21:25:30.666] getGlobalsAndPackages() ...
  [21:25:30.667] Searching for globals...
  [21:25:30.668] - globals found: [1] '{'
  [21:25:30.668] Searching for globals ... DONE
  [21:25:30.669] Resolving globals: FALSE
  [21:25:30.669] 
  [21:25:30.670] 
  [21:25:30.670] getGlobalsAndPackages() ... DONE
  [21:25:30.690] Packages needed by the future expression (n = 0): <none>
  [21:25:30.691] Packages needed by future strategies (n = 0): <none>
  [21:25:30.695] {
  [21:25:30.695]     {
  [21:25:30.695]         ...future.startTime <- base::Sys.time()
  [21:25:30.695]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.695]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.695]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.695]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.695]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.695]         {
  [21:25:30.695]             {
  [21:25:30.695]                 base::local({
  [21:25:30.695]                   has_future <- base::requireNamespace("future", 
  [21:25:30.695]                     quietly = TRUE)
  [21:25:30.695]                   version <- if (has_future) 
  [21:25:30.695]                     utils::packageVersion("future")
  [21:25:30.695]                   else NULL
  [21:25:30.695]                   if (!has_future || version < "1.8.0") {
  [21:25:30.695]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.695]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.695]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.695]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.695]                         "release", "version")], collapse = " "), 
  [21:25:30.695]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.695]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.695]                       info)
  [21:25:30.695]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.695]                     if (!has_future) {
  [21:25:30.695]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.695]                         info)
  [21:25:30.695]                     }
  [21:25:30.695]                     else {
  [21:25:30.695]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.695]                         info, version)
  [21:25:30.695]                     }
  [21:25:30.695]                     base::stop(msg)
  [21:25:30.695]                   }
  [21:25:30.695]                 })
  [21:25:30.695]             }
  [21:25:30.695]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.695]         }
  [21:25:30.695]     }
  [21:25:30.695]     if (base::is.na(TRUE)) {
  [21:25:30.695]     }
  [21:25:30.695]     else {
  [21:25:30.695]         if (TRUE) {
  [21:25:30.695]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.695]                 open = "w")
  [21:25:30.695]         }
  [21:25:30.695]         else {
  [21:25:30.695]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.695]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.695]         }
  [21:25:30.695]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.695]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.695]             base::sink(type = "output", split = FALSE)
  [21:25:30.695]             base::close(...future.stdout)
  [21:25:30.695]         }, add = TRUE)
  [21:25:30.695]     }
  [21:25:30.695]     ...future.frame <- base::sys.nframe()
  [21:25:30.695]     ...future.conditions <- base::list()
  [21:25:30.695]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.695]     ...future.result <- base::tryCatch({
  [21:25:30.695]         base::withCallingHandlers({
  [21:25:30.695]             ...future.value <- base::withVisible(base::local({
  [21:25:30.695]                 ...future.sendCondition <- local({
  [21:25:30.695]                   sendCondition <- NULL
  [21:25:30.695]                   function(frame = 1L) {
  [21:25:30.695]                     if (is.function(sendCondition)) 
  [21:25:30.695]                       return(sendCondition)
  [21:25:30.695]                     ns <- getNamespace("parallel")
  [21:25:30.695]                     if (exists("sendData", mode = "function", 
  [21:25:30.695]                       envir = ns)) {
  [21:25:30.695]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.695]                         envir = ns)
  [21:25:30.695]                       envir <- sys.frame(frame)
  [21:25:30.695]                       master <- NULL
  [21:25:30.695]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.695]                         !identical(envir, emptyenv())) {
  [21:25:30.695]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.695]                           inherits = FALSE)) {
  [21:25:30.695]                           master <- get("master", mode = "list", 
  [21:25:30.695]                             envir = envir, inherits = FALSE)
  [21:25:30.695]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.695]                             sendCondition <<- function(cond) {
  [21:25:30.695]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.695]                                 success = TRUE)
  [21:25:30.695]                               parallel_sendData(master, data)
  [21:25:30.695]                             }
  [21:25:30.695]                             return(sendCondition)
  [21:25:30.695]                           }
  [21:25:30.695]                         }
  [21:25:30.695]                         frame <- frame + 1L
  [21:25:30.695]                         envir <- sys.frame(frame)
  [21:25:30.695]                       }
  [21:25:30.695]                     }
  [21:25:30.695]                     sendCondition <<- function(cond) NULL
  [21:25:30.695]                   }
  [21:25:30.695]                 })
  [21:25:30.695]                 withCallingHandlers({
  [21:25:30.695]                   {
  [21:25:30.695]                     4
  [21:25:30.695]                   }
  [21:25:30.695]                 }, immediateCondition = function(cond) {
  [21:25:30.695]                   sendCondition <- ...future.sendCondition()
  [21:25:30.695]                   sendCondition(cond)
  [21:25:30.695]                   muffleCondition <- function (cond) 
  [21:25:30.695]                   {
  [21:25:30.695]                     inherits <- base::inherits
  [21:25:30.695]                     invokeRestart <- base::invokeRestart
  [21:25:30.695]                     muffled <- FALSE
  [21:25:30.695]                     if (inherits(cond, "message")) {
  [21:25:30.695]                       invokeRestart("muffleMessage")
  [21:25:30.695]                       muffled <- TRUE
  [21:25:30.695]                     }
  [21:25:30.695]                     else if (inherits(cond, "warning")) {
  [21:25:30.695]                       invokeRestart("muffleWarning")
  [21:25:30.695]                       muffled <- TRUE
  [21:25:30.695]                     }
  [21:25:30.695]                     else if (inherits(cond, "condition")) {
  [21:25:30.695]                       computeRestarts <- base::computeRestarts
  [21:25:30.695]                       grepl <- base::grepl
  [21:25:30.695]                       is.null <- base::is.null
  [21:25:30.695]                       restarts <- computeRestarts(cond)
  [21:25:30.695]                       for (restart in restarts) {
  [21:25:30.695]                         name <- restart$name
  [21:25:30.695]                         if (is.null(name)) 
  [21:25:30.695]                           next
  [21:25:30.695]                         if (!grepl("^muffle", name)) 
  [21:25:30.695]                           next
  [21:25:30.695]                         invokeRestart(restart)
  [21:25:30.695]                         muffled <- TRUE
  [21:25:30.695]                         break
  [21:25:30.695]                       }
  [21:25:30.695]                     }
  [21:25:30.695]                     invisible(muffled)
  [21:25:30.695]                   }
  [21:25:30.695]                   muffleCondition(cond)
  [21:25:30.695]                 })
  [21:25:30.695]             }))
  [21:25:30.695]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.695]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.695]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.695]                 version = "1.8")
  [21:25:30.695]         }, condition = base::local({
  [21:25:30.695]             c <- base::c
  [21:25:30.695]             inherits <- base::inherits
  [21:25:30.695]             invokeRestart <- base::invokeRestart
  [21:25:30.695]             length <- base::length
  [21:25:30.695]             list <- base::list
  [21:25:30.695]             seq.int <- base::seq.int
  [21:25:30.695]             signalCondition <- base::signalCondition
  [21:25:30.695]             sys.calls <- base::sys.calls
  [21:25:30.695]             Sys.time <- base::Sys.time
  [21:25:30.695]             `[[` <- base::`[[`
  [21:25:30.695]             `+` <- base::`+`
  [21:25:30.695]             `<<-` <- base::`<<-`
  [21:25:30.695]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.695]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.695]                   3L)]
  [21:25:30.695]             }
  [21:25:30.695]             function(cond) {
  [21:25:30.695]                 if (inherits(cond, "error")) {
  [21:25:30.695]                   sessionInformation <- function() {
  [21:25:30.695]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.695]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.695]                       search = base::search(), system = base::Sys.info())
  [21:25:30.695]                   }
  [21:25:30.695]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.695]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.695]                     cond$call), session = sessionInformation(), 
  [21:25:30.695]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.695]                   signalCondition(cond)
  [21:25:30.695]                 }
  [21:25:30.695]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.695]                 ))) {
  [21:25:30.695]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.695]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.695]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.695]                   if (!signal) {
  [21:25:30.695]                     muffleCondition <- function (cond) 
  [21:25:30.695]                     {
  [21:25:30.695]                       inherits <- base::inherits
  [21:25:30.695]                       invokeRestart <- base::invokeRestart
  [21:25:30.695]                       muffled <- FALSE
  [21:25:30.695]                       if (inherits(cond, "message")) {
  [21:25:30.695]                         invokeRestart("muffleMessage")
  [21:25:30.695]                         muffled <- TRUE
  [21:25:30.695]                       }
  [21:25:30.695]                       else if (inherits(cond, "warning")) {
  [21:25:30.695]                         invokeRestart("muffleWarning")
  [21:25:30.695]                         muffled <- TRUE
  [21:25:30.695]                       }
  [21:25:30.695]                       else if (inherits(cond, "condition")) {
  [21:25:30.695]                         computeRestarts <- base::computeRestarts
  [21:25:30.695]                         grepl <- base::grepl
  [21:25:30.695]                         is.null <- base::is.null
  [21:25:30.695]                         restarts <- computeRestarts(cond)
  [21:25:30.695]                         for (restart in restarts) {
  [21:25:30.695]                           name <- restart$name
  [21:25:30.695]                           if (is.null(name)) 
  [21:25:30.695]                             next
  [21:25:30.695]                           if (!grepl("^muffle", name)) 
  [21:25:30.695]                             next
  [21:25:30.695]                           invokeRestart(restart)
  [21:25:30.695]                           muffled <- TRUE
  [21:25:30.695]                           break
  [21:25:30.695]                         }
  [21:25:30.695]                       }
  [21:25:30.695]                       invisible(muffled)
  [21:25:30.695]                     }
  [21:25:30.695]                     muffleCondition(cond)
  [21:25:30.695]                   }
  [21:25:30.695]                 }
  [21:25:30.695]             }
  [21:25:30.695]         }))
  [21:25:30.695]     }, error = function(ex) {
  [21:25:30.695]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.695]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.695]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.695]     }, finally = {
  [21:25:30.695]         {
  [21:25:30.695]             NULL
  [21:25:30.695]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.695]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.695]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.695]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.695]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.695]                 ...) 
  [21:25:30.695]             {
  [21:25:30.695]                 if (substitute) 
  [21:25:30.695]                   expr <- substitute(expr)
  [21:25:30.695]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.695]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.695]                   globals = globals, persistent = persistent, 
  [21:25:30.695]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.695]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.695]                   label = label, ...)
  [21:25:30.695]                 if (!future$lazy) 
  [21:25:30.695]                   future <- run(future)
  [21:25:30.695]                 invisible(future)
  [21:25:30.695]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.695]         }
  [21:25:30.695]         base::options(...future.oldOptions)
  [21:25:30.695]     })
  [21:25:30.695]     Sys.time
  [21:25:30.695]     if (base::is.na(TRUE)) {
  [21:25:30.695]     }
  [21:25:30.695]     else {
  [21:25:30.695]         base::sink(type = "output", split = FALSE)
  [21:25:30.695]         if (TRUE) {
  [21:25:30.695]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.695]         }
  [21:25:30.695]         else {
  [21:25:30.695]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.695]         }
  [21:25:30.695]         base::close(...future.stdout)
  [21:25:30.695]         ...future.stdout <- NULL
  [21:25:30.695]     }
  [21:25:30.695]     ...future.result$conditions <- ...future.conditions
  [21:25:30.695]     ...future.result
  [21:25:30.695] }
  [21:25:30.699] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.711] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.712] - Validating connection of ClusterFuture
  [21:25:30.712] - received message: FutureResult
  [21:25:30.712] - Received FutureResult
  [21:25:30.713] - Erased future from FutureRegistry
  [21:25:30.713] result() for ClusterFuture ...
  [21:25:30.713] - result already collected: FutureResult
  [21:25:30.714] result() for ClusterFuture ... done
  [21:25:30.714] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.714] result() for ClusterFuture ...
  [21:25:30.715] - result already collected: FutureResult
  [21:25:30.715] result() for ClusterFuture ... done
  [21:25:30.715] result() for ClusterFuture ...
  [21:25:30.716] - result already collected: FutureResult
  [21:25:30.716] result() for ClusterFuture ... done
  [21:25:30.726] ClusterFuture started
  <environment: 0x55ef213b0e20> 
  <environment: 0x55ef21566930> 
  [21:25:30.771] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.771] - Validating connection of ClusterFuture
  [21:25:30.772] - received message: FutureResult
  [21:25:30.772] - Received FutureResult
  [21:25:30.772] - Erased future from FutureRegistry
  [21:25:30.772] result() for ClusterFuture ...
  [21:25:30.773] - result already collected: FutureResult
  [21:25:30.773] result() for ClusterFuture ... done
  [21:25:30.773] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:30.776] resolve() on environment ...
  [21:25:30.777]  recursive: 0
  [21:25:30.778]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:30.778] signalConditionsASAP(numeric, pos=1) ...
  [21:25:30.779] - nx: 4
  [21:25:30.779] - relay: TRUE
  [21:25:30.779] - stdout: TRUE
  [21:25:30.780] - signal: TRUE
  [21:25:30.780] - resignal: FALSE
  [21:25:30.780] - force: TRUE
  [21:25:30.780] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.781] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.781]  - until=2
  [21:25:30.781]  - relaying element #2
  [21:25:30.781] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.782] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.782] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:30.782]  length: 3 (resolved future 1)
  [21:25:30.783] Future #2
  [21:25:30.783] result() for ClusterFuture ...
  [21:25:30.783] - result already collected: FutureResult
  [21:25:30.783] result() for ClusterFuture ... done
  [21:25:30.784] result() for ClusterFuture ...
  [21:25:30.784] - result already collected: FutureResult
  [21:25:30.784] result() for ClusterFuture ... done
  [21:25:30.785] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:30.785] - nx: 4
  [21:25:30.785] - relay: TRUE
  [21:25:30.785] - stdout: TRUE
  [21:25:30.786] - signal: TRUE
  [21:25:30.786] - resignal: FALSE
  [21:25:30.786] - force: TRUE
  [21:25:30.786] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:30.787] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:30.787]  - until=2
  [21:25:30.787]  - relaying element #2
  [21:25:30.787] result() for ClusterFuture ...
  [21:25:30.788] - result already collected: FutureResult
  [21:25:30.788] result() for ClusterFuture ... done
  [21:25:30.788] result() for ClusterFuture ...
  [21:25:30.789] - result already collected: FutureResult
  [21:25:30.789] result() for ClusterFuture ... done
  [21:25:30.789] result() for ClusterFuture ...
  [21:25:30.790] - result already collected: FutureResult
  [21:25:30.790] result() for ClusterFuture ... done
  [21:25:30.790] result() for ClusterFuture ...
  [21:25:30.790] - result already collected: FutureResult
  [21:25:30.791] result() for ClusterFuture ... done
  [21:25:30.791] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.791] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.791] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:30.792]  length: 2 (resolved future 2)
  [21:25:30.792] Future #3
  [21:25:30.792] result() for ClusterFuture ...
  [21:25:30.793] - result already collected: FutureResult
  [21:25:30.793] result() for ClusterFuture ... done
  [21:25:30.793] result() for ClusterFuture ...
  [21:25:30.793] - result already collected: FutureResult
  [21:25:30.805] result() for ClusterFuture ... done
  [21:25:30.806] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:30.806] - nx: 4
  [21:25:30.806] - relay: TRUE
  [21:25:30.806] - stdout: TRUE
  [21:25:30.807] - signal: TRUE
  [21:25:30.807] - resignal: FALSE
  [21:25:30.807] - force: TRUE
  [21:25:30.807] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:30.808] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:30.808]  - until=3
  [21:25:30.808]  - relaying element #3
  [21:25:30.808] result() for ClusterFuture ...
  [21:25:30.809] - result already collected: FutureResult
  [21:25:30.809] result() for ClusterFuture ... done
  [21:25:30.809] result() for ClusterFuture ...
  [21:25:30.809] - result already collected: FutureResult
  [21:25:30.810] result() for ClusterFuture ... done
  [21:25:30.810] result() for ClusterFuture ...
  [21:25:30.810] - result already collected: FutureResult
  [21:25:30.810] result() for ClusterFuture ... done
  [21:25:30.811] result() for ClusterFuture ...
  [21:25:30.811] - result already collected: FutureResult
  [21:25:30.811] result() for ClusterFuture ... done
  [21:25:30.811] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.812] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.812] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:30.812]  length: 1 (resolved future 3)
  [21:25:30.813] Future #4
  [21:25:30.813] result() for ClusterFuture ...
  [21:25:30.813] - result already collected: FutureResult
  [21:25:30.813] result() for ClusterFuture ... done
  [21:25:30.814] result() for ClusterFuture ...
  [21:25:30.814] - result already collected: FutureResult
  [21:25:30.814] result() for ClusterFuture ... done
  [21:25:30.814] signalConditionsASAP(ClusterFuture, pos=4) ...
  [21:25:30.815] - nx: 4
  [21:25:30.815] - relay: TRUE
  [21:25:30.815] - stdout: TRUE
  [21:25:30.815] - signal: TRUE
  [21:25:30.855] - resignal: FALSE
  [21:25:30.855] - force: TRUE
  [21:25:30.856] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:30.856] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:30.856]  - until=4
  [21:25:30.857]  - relaying element #4
  [21:25:30.857] result() for ClusterFuture ...
  [21:25:30.857] - result already collected: FutureResult
  [21:25:30.858] result() for ClusterFuture ... done
  [21:25:30.858] result() for ClusterFuture ...
  [21:25:30.858] - result already collected: FutureResult
  [21:25:30.858] result() for ClusterFuture ... done
  [21:25:30.859] result() for ClusterFuture ...
  [21:25:30.859] - result already collected: FutureResult
  [21:25:30.859] result() for ClusterFuture ... done
  [21:25:30.860] result() for ClusterFuture ...
  [21:25:30.860] - result already collected: FutureResult
  [21:25:30.860] result() for ClusterFuture ... done
  [21:25:30.860] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.861] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.861] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [21:25:30.861]  length: 0 (resolved future 4)
  [21:25:30.861] Relaying remaining futures
  [21:25:30.861] signalConditionsASAP(NULL, pos=0) ...
  [21:25:30.862] - nx: 4
  [21:25:30.862] - relay: TRUE
  [21:25:30.862] - stdout: TRUE
  [21:25:30.862] - signal: TRUE
  [21:25:30.863] - resignal: FALSE
  [21:25:30.863] - force: TRUE
  [21:25:30.863] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.863] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:30.864] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:30.864] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:30.864] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:30.864] resolve() on environment ... DONE
  [21:25:30.865] result() for ClusterFuture ...
  [21:25:30.865] - result already collected: FutureResult
  [21:25:30.865] result() for ClusterFuture ... done
  [21:25:30.865] result() for ClusterFuture ...
  [21:25:30.865] - result already collected: FutureResult
  [21:25:30.866] result() for ClusterFuture ... done
  [21:25:30.866] result() for ClusterFuture ...
  [21:25:30.866] - result already collected: FutureResult
  [21:25:30.866] result() for ClusterFuture ... done
  [21:25:30.867] result() for ClusterFuture ...
  [21:25:30.867] - result already collected: FutureResult
  [21:25:30.867] result() for ClusterFuture ... done
  [21:25:30.867] result() for ClusterFuture ...
  [21:25:30.868] - result already collected: FutureResult
  [21:25:30.868] result() for ClusterFuture ... done
  [21:25:30.868] result() for ClusterFuture ...
  [21:25:30.868] - result already collected: FutureResult
  [21:25:30.869] result() for ClusterFuture ... done
  <environment: 0x55ef225a9ec8> 
  Dimensions: c(2, 1, 3, 1)
  [21:25:30.870] getGlobalsAndPackages() ...
  [21:25:30.886] Searching for globals...
  [21:25:30.887] 
  [21:25:30.887] Searching for globals ... DONE
  [21:25:30.887] - globals: [0] <none>
  [21:25:30.888] getGlobalsAndPackages() ... DONE
  [21:25:30.892] Packages needed by the future expression (n = 0): <none>
  [21:25:30.892] Packages needed by future strategies (n = 0): <none>
  [21:25:30.911] {
  [21:25:30.911]     {
  [21:25:30.911]         ...future.startTime <- base::Sys.time()
  [21:25:30.911]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.911]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.911]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.911]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.911]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.911]         {
  [21:25:30.911]             {
  [21:25:30.911]                 base::local({
  [21:25:30.911]                   has_future <- base::requireNamespace("future", 
  [21:25:30.911]                     quietly = TRUE)
  [21:25:30.911]                   version <- if (has_future) 
  [21:25:30.911]                     utils::packageVersion("future")
  [21:25:30.911]                   else NULL
  [21:25:30.911]                   if (!has_future || version < "1.8.0") {
  [21:25:30.911]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.911]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.911]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.911]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.911]                         "release", "version")], collapse = " "), 
  [21:25:30.911]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.911]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.911]                       info)
  [21:25:30.911]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.911]                     if (!has_future) {
  [21:25:30.911]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.911]                         info)
  [21:25:30.911]                     }
  [21:25:30.911]                     else {
  [21:25:30.911]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.911]                         info, version)
  [21:25:30.911]                     }
  [21:25:30.911]                     base::stop(msg)
  [21:25:30.911]                   }
  [21:25:30.911]                 })
  [21:25:30.911]             }
  [21:25:30.911]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.911]         }
  [21:25:30.911]     }
  [21:25:30.911]     if (base::is.na(TRUE)) {
  [21:25:30.911]     }
  [21:25:30.911]     else {
  [21:25:30.911]         if (TRUE) {
  [21:25:30.911]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.911]                 open = "w")
  [21:25:30.911]         }
  [21:25:30.911]         else {
  [21:25:30.911]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.911]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.911]         }
  [21:25:30.911]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.911]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.911]             base::sink(type = "output", split = FALSE)
  [21:25:30.911]             base::close(...future.stdout)
  [21:25:30.911]         }, add = TRUE)
  [21:25:30.911]     }
  [21:25:30.911]     ...future.frame <- base::sys.nframe()
  [21:25:30.911]     ...future.conditions <- base::list()
  [21:25:30.911]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.911]     ...future.result <- base::tryCatch({
  [21:25:30.911]         base::withCallingHandlers({
  [21:25:30.911]             ...future.value <- base::withVisible(base::local({
  [21:25:30.911]                 ...future.sendCondition <- local({
  [21:25:30.911]                   sendCondition <- NULL
  [21:25:30.911]                   function(frame = 1L) {
  [21:25:30.911]                     if (is.function(sendCondition)) 
  [21:25:30.911]                       return(sendCondition)
  [21:25:30.911]                     ns <- getNamespace("parallel")
  [21:25:30.911]                     if (exists("sendData", mode = "function", 
  [21:25:30.911]                       envir = ns)) {
  [21:25:30.911]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.911]                         envir = ns)
  [21:25:30.911]                       envir <- sys.frame(frame)
  [21:25:30.911]                       master <- NULL
  [21:25:30.911]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.911]                         !identical(envir, emptyenv())) {
  [21:25:30.911]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.911]                           inherits = FALSE)) {
  [21:25:30.911]                           master <- get("master", mode = "list", 
  [21:25:30.911]                             envir = envir, inherits = FALSE)
  [21:25:30.911]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.911]                             sendCondition <<- function(cond) {
  [21:25:30.911]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.911]                                 success = TRUE)
  [21:25:30.911]                               parallel_sendData(master, data)
  [21:25:30.911]                             }
  [21:25:30.911]                             return(sendCondition)
  [21:25:30.911]                           }
  [21:25:30.911]                         }
  [21:25:30.911]                         frame <- frame + 1L
  [21:25:30.911]                         envir <- sys.frame(frame)
  [21:25:30.911]                       }
  [21:25:30.911]                     }
  [21:25:30.911]                     sendCondition <<- function(cond) NULL
  [21:25:30.911]                   }
  [21:25:30.911]                 })
  [21:25:30.911]                 withCallingHandlers({
  [21:25:30.911]                   2
  [21:25:30.911]                 }, immediateCondition = function(cond) {
  [21:25:30.911]                   sendCondition <- ...future.sendCondition()
  [21:25:30.911]                   sendCondition(cond)
  [21:25:30.911]                   muffleCondition <- function (cond) 
  [21:25:30.911]                   {
  [21:25:30.911]                     inherits <- base::inherits
  [21:25:30.911]                     invokeRestart <- base::invokeRestart
  [21:25:30.911]                     muffled <- FALSE
  [21:25:30.911]                     if (inherits(cond, "message")) {
  [21:25:30.911]                       invokeRestart("muffleMessage")
  [21:25:30.911]                       muffled <- TRUE
  [21:25:30.911]                     }
  [21:25:30.911]                     else if (inherits(cond, "warning")) {
  [21:25:30.911]                       invokeRestart("muffleWarning")
  [21:25:30.911]                       muffled <- TRUE
  [21:25:30.911]                     }
  [21:25:30.911]                     else if (inherits(cond, "condition")) {
  [21:25:30.911]                       computeRestarts <- base::computeRestarts
  [21:25:30.911]                       grepl <- base::grepl
  [21:25:30.911]                       is.null <- base::is.null
  [21:25:30.911]                       restarts <- computeRestarts(cond)
  [21:25:30.911]                       for (restart in restarts) {
  [21:25:30.911]                         name <- restart$name
  [21:25:30.911]                         if (is.null(name)) 
  [21:25:30.911]                           next
  [21:25:30.911]                         if (!grepl("^muffle", name)) 
  [21:25:30.911]                           next
  [21:25:30.911]                         invokeRestart(restart)
  [21:25:30.911]                         muffled <- TRUE
  [21:25:30.911]                         break
  [21:25:30.911]                       }
  [21:25:30.911]                     }
  [21:25:30.911]                     invisible(muffled)
  [21:25:30.911]                   }
  [21:25:30.911]                   muffleCondition(cond)
  [21:25:30.911]                 })
  [21:25:30.911]             }))
  [21:25:30.911]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.911]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.911]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.911]                 version = "1.8")
  [21:25:30.911]         }, condition = base::local({
  [21:25:30.911]             c <- base::c
  [21:25:30.911]             inherits <- base::inherits
  [21:25:30.911]             invokeRestart <- base::invokeRestart
  [21:25:30.911]             length <- base::length
  [21:25:30.911]             list <- base::list
  [21:25:30.911]             seq.int <- base::seq.int
  [21:25:30.911]             signalCondition <- base::signalCondition
  [21:25:30.911]             sys.calls <- base::sys.calls
  [21:25:30.911]             Sys.time <- base::Sys.time
  [21:25:30.911]             `[[` <- base::`[[`
  [21:25:30.911]             `+` <- base::`+`
  [21:25:30.911]             `<<-` <- base::`<<-`
  [21:25:30.911]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.911]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.911]                   3L)]
  [21:25:30.911]             }
  [21:25:30.911]             function(cond) {
  [21:25:30.911]                 if (inherits(cond, "error")) {
  [21:25:30.911]                   sessionInformation <- function() {
  [21:25:30.911]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.911]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.911]                       search = base::search(), system = base::Sys.info())
  [21:25:30.911]                   }
  [21:25:30.911]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.911]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.911]                     cond$call), session = sessionInformation(), 
  [21:25:30.911]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.911]                   signalCondition(cond)
  [21:25:30.911]                 }
  [21:25:30.911]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.911]                 ))) {
  [21:25:30.911]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.911]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.911]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.911]                   if (!signal) {
  [21:25:30.911]                     muffleCondition <- function (cond) 
  [21:25:30.911]                     {
  [21:25:30.911]                       inherits <- base::inherits
  [21:25:30.911]                       invokeRestart <- base::invokeRestart
  [21:25:30.911]                       muffled <- FALSE
  [21:25:30.911]                       if (inherits(cond, "message")) {
  [21:25:30.911]                         invokeRestart("muffleMessage")
  [21:25:30.911]                         muffled <- TRUE
  [21:25:30.911]                       }
  [21:25:30.911]                       else if (inherits(cond, "warning")) {
  [21:25:30.911]                         invokeRestart("muffleWarning")
  [21:25:30.911]                         muffled <- TRUE
  [21:25:30.911]                       }
  [21:25:30.911]                       else if (inherits(cond, "condition")) {
  [21:25:30.911]                         computeRestarts <- base::computeRestarts
  [21:25:30.911]                         grepl <- base::grepl
  [21:25:30.911]                         is.null <- base::is.null
  [21:25:30.911]                         restarts <- computeRestarts(cond)
  [21:25:30.911]                         for (restart in restarts) {
  [21:25:30.911]                           name <- restart$name
  [21:25:30.911]                           if (is.null(name)) 
  [21:25:30.911]                             next
  [21:25:30.911]                           if (!grepl("^muffle", name)) 
  [21:25:30.911]                             next
  [21:25:30.911]                           invokeRestart(restart)
  [21:25:30.911]                           muffled <- TRUE
  [21:25:30.911]                           break
  [21:25:30.911]                         }
  [21:25:30.911]                       }
  [21:25:30.911]                       invisible(muffled)
  [21:25:30.911]                     }
  [21:25:30.911]                     muffleCondition(cond)
  [21:25:30.911]                   }
  [21:25:30.911]                 }
  [21:25:30.911]             }
  [21:25:30.911]         }))
  [21:25:30.911]     }, error = function(ex) {
  [21:25:30.911]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.911]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.911]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.911]     }, finally = {
  [21:25:30.911]         {
  [21:25:30.911]             NULL
  [21:25:30.911]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.911]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.911]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.911]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.911]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.911]                 ...) 
  [21:25:30.911]             {
  [21:25:30.911]                 if (substitute) 
  [21:25:30.911]                   expr <- substitute(expr)
  [21:25:30.911]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.911]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.911]                   globals = globals, persistent = persistent, 
  [21:25:30.911]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.911]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.911]                   label = label, ...)
  [21:25:30.911]                 if (!future$lazy) 
  [21:25:30.911]                   future <- run(future)
  [21:25:30.911]                 invisible(future)
  [21:25:30.911]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.911]         }
  [21:25:30.911]         base::options(...future.oldOptions)
  [21:25:30.911]     })
  [21:25:30.911]     Sys.time
  [21:25:30.911]     if (base::is.na(TRUE)) {
  [21:25:30.911]     }
  [21:25:30.911]     else {
  [21:25:30.911]         base::sink(type = "output", split = FALSE)
  [21:25:30.911]         if (TRUE) {
  [21:25:30.911]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.911]         }
  [21:25:30.911]         else {
  [21:25:30.911]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.911]         }
  [21:25:30.911]         base::close(...future.stdout)
  [21:25:30.911]         ...future.stdout <- NULL
  [21:25:30.911]     }
  [21:25:30.911]     ...future.result$conditions <- ...future.conditions
  [21:25:30.911]     ...future.result
  [21:25:30.911] }
  [21:25:30.917] ClusterFuture started
  [21:25:30.918] getGlobalsAndPackages() ...
  [21:25:30.918] Searching for globals...
  [21:25:30.919] 
  [21:25:30.919] Searching for globals ... DONE
  [21:25:30.919] - globals: [0] <none>
  [21:25:30.920] getGlobalsAndPackages() ... DONE
  [21:25:30.924] Packages needed by the future expression (n = 0): <none>
  [21:25:30.924] Packages needed by future strategies (n = 0): <none>
  [21:25:30.928] {
  [21:25:30.928]     {
  [21:25:30.928]         ...future.startTime <- base::Sys.time()
  [21:25:30.928]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:30.928]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:30.928]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:30.928]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:30.928]             future.resolve.recursive = NULL, width = 80L)
  [21:25:30.928]         {
  [21:25:30.928]             {
  [21:25:30.928]                 base::local({
  [21:25:30.928]                   has_future <- base::requireNamespace("future", 
  [21:25:30.928]                     quietly = TRUE)
  [21:25:30.928]                   version <- if (has_future) 
  [21:25:30.928]                     utils::packageVersion("future")
  [21:25:30.928]                   else NULL
  [21:25:30.928]                   if (!has_future || version < "1.8.0") {
  [21:25:30.928]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:30.928]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:30.928]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:30.928]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:30.928]                         "release", "version")], collapse = " "), 
  [21:25:30.928]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:30.928]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:30.928]                       info)
  [21:25:30.928]                     info <- base::paste(info, collapse = "; ")
  [21:25:30.928]                     if (!has_future) {
  [21:25:30.928]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:30.928]                         info)
  [21:25:30.928]                     }
  [21:25:30.928]                     else {
  [21:25:30.928]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:30.928]                         info, version)
  [21:25:30.928]                     }
  [21:25:30.928]                     base::stop(msg)
  [21:25:30.928]                   }
  [21:25:30.928]                 })
  [21:25:30.928]             }
  [21:25:30.928]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:30.928]         }
  [21:25:30.928]     }
  [21:25:30.928]     if (base::is.na(TRUE)) {
  [21:25:30.928]     }
  [21:25:30.928]     else {
  [21:25:30.928]         if (TRUE) {
  [21:25:30.928]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:30.928]                 open = "w")
  [21:25:30.928]         }
  [21:25:30.928]         else {
  [21:25:30.928]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:30.928]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:30.928]         }
  [21:25:30.928]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:30.928]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:30.928]             base::sink(type = "output", split = FALSE)
  [21:25:30.928]             base::close(...future.stdout)
  [21:25:30.928]         }, add = TRUE)
  [21:25:30.928]     }
  [21:25:30.928]     ...future.frame <- base::sys.nframe()
  [21:25:30.928]     ...future.conditions <- base::list()
  [21:25:30.928]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:30.928]     ...future.result <- base::tryCatch({
  [21:25:30.928]         base::withCallingHandlers({
  [21:25:30.928]             ...future.value <- base::withVisible(base::local({
  [21:25:30.928]                 ...future.sendCondition <- local({
  [21:25:30.928]                   sendCondition <- NULL
  [21:25:30.928]                   function(frame = 1L) {
  [21:25:30.928]                     if (is.function(sendCondition)) 
  [21:25:30.928]                       return(sendCondition)
  [21:25:30.928]                     ns <- getNamespace("parallel")
  [21:25:30.928]                     if (exists("sendData", mode = "function", 
  [21:25:30.928]                       envir = ns)) {
  [21:25:30.928]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:30.928]                         envir = ns)
  [21:25:30.928]                       envir <- sys.frame(frame)
  [21:25:30.928]                       master <- NULL
  [21:25:30.928]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:30.928]                         !identical(envir, emptyenv())) {
  [21:25:30.928]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:30.928]                           inherits = FALSE)) {
  [21:25:30.928]                           master <- get("master", mode = "list", 
  [21:25:30.928]                             envir = envir, inherits = FALSE)
  [21:25:30.928]                           if (inherits(master, "SOCKnode")) {
  [21:25:30.928]                             sendCondition <<- function(cond) {
  [21:25:30.928]                               data <- list(type = "VALUE", value = cond, 
  [21:25:30.928]                                 success = TRUE)
  [21:25:30.928]                               parallel_sendData(master, data)
  [21:25:30.928]                             }
  [21:25:30.928]                             return(sendCondition)
  [21:25:30.928]                           }
  [21:25:30.928]                         }
  [21:25:30.928]                         frame <- frame + 1L
  [21:25:30.928]                         envir <- sys.frame(frame)
  [21:25:30.928]                       }
  [21:25:30.928]                     }
  [21:25:30.928]                     sendCondition <<- function(cond) NULL
  [21:25:30.928]                   }
  [21:25:30.928]                 })
  [21:25:30.928]                 withCallingHandlers({
  [21:25:30.928]                   NULL
  [21:25:30.928]                 }, immediateCondition = function(cond) {
  [21:25:30.928]                   sendCondition <- ...future.sendCondition()
  [21:25:30.928]                   sendCondition(cond)
  [21:25:30.928]                   muffleCondition <- function (cond) 
  [21:25:30.928]                   {
  [21:25:30.928]                     inherits <- base::inherits
  [21:25:30.928]                     invokeRestart <- base::invokeRestart
  [21:25:30.928]                     muffled <- FALSE
  [21:25:30.928]                     if (inherits(cond, "message")) {
  [21:25:30.928]                       invokeRestart("muffleMessage")
  [21:25:30.928]                       muffled <- TRUE
  [21:25:30.928]                     }
  [21:25:30.928]                     else if (inherits(cond, "warning")) {
  [21:25:30.928]                       invokeRestart("muffleWarning")
  [21:25:30.928]                       muffled <- TRUE
  [21:25:30.928]                     }
  [21:25:30.928]                     else if (inherits(cond, "condition")) {
  [21:25:30.928]                       computeRestarts <- base::computeRestarts
  [21:25:30.928]                       grepl <- base::grepl
  [21:25:30.928]                       is.null <- base::is.null
  [21:25:30.928]                       restarts <- computeRestarts(cond)
  [21:25:30.928]                       for (restart in restarts) {
  [21:25:30.928]                         name <- restart$name
  [21:25:30.928]                         if (is.null(name)) 
  [21:25:30.928]                           next
  [21:25:30.928]                         if (!grepl("^muffle", name)) 
  [21:25:30.928]                           next
  [21:25:30.928]                         invokeRestart(restart)
  [21:25:30.928]                         muffled <- TRUE
  [21:25:30.928]                         break
  [21:25:30.928]                       }
  [21:25:30.928]                     }
  [21:25:30.928]                     invisible(muffled)
  [21:25:30.928]                   }
  [21:25:30.928]                   muffleCondition(cond)
  [21:25:30.928]                 })
  [21:25:30.928]             }))
  [21:25:30.928]             future::FutureResult(value = ...future.value$value, 
  [21:25:30.928]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.928]                   ...future.rng), started = ...future.startTime, 
  [21:25:30.928]                 version = "1.8")
  [21:25:30.928]         }, condition = base::local({
  [21:25:30.928]             c <- base::c
  [21:25:30.928]             inherits <- base::inherits
  [21:25:30.928]             invokeRestart <- base::invokeRestart
  [21:25:30.928]             length <- base::length
  [21:25:30.928]             list <- base::list
  [21:25:30.928]             seq.int <- base::seq.int
  [21:25:30.928]             signalCondition <- base::signalCondition
  [21:25:30.928]             sys.calls <- base::sys.calls
  [21:25:30.928]             Sys.time <- base::Sys.time
  [21:25:30.928]             `[[` <- base::`[[`
  [21:25:30.928]             `+` <- base::`+`
  [21:25:30.928]             `<<-` <- base::`<<-`
  [21:25:30.928]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:30.928]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:30.928]                   3L)]
  [21:25:30.928]             }
  [21:25:30.928]             function(cond) {
  [21:25:30.928]                 if (inherits(cond, "error")) {
  [21:25:30.928]                   sessionInformation <- function() {
  [21:25:30.928]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:30.928]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:30.928]                       search = base::search(), system = base::Sys.info())
  [21:25:30.928]                   }
  [21:25:30.928]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.928]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:30.928]                     cond$call), session = sessionInformation(), 
  [21:25:30.928]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:30.928]                   signalCondition(cond)
  [21:25:30.928]                 }
  [21:25:30.928]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:30.928]                 ))) {
  [21:25:30.928]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:30.928]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:30.928]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:30.928]                   if (!signal) {
  [21:25:30.928]                     muffleCondition <- function (cond) 
  [21:25:30.928]                     {
  [21:25:30.928]                       inherits <- base::inherits
  [21:25:30.928]                       invokeRestart <- base::invokeRestart
  [21:25:30.928]                       muffled <- FALSE
  [21:25:30.928]                       if (inherits(cond, "message")) {
  [21:25:30.928]                         invokeRestart("muffleMessage")
  [21:25:30.928]                         muffled <- TRUE
  [21:25:30.928]                       }
  [21:25:30.928]                       else if (inherits(cond, "warning")) {
  [21:25:30.928]                         invokeRestart("muffleWarning")
  [21:25:30.928]                         muffled <- TRUE
  [21:25:30.928]                       }
  [21:25:30.928]                       else if (inherits(cond, "condition")) {
  [21:25:30.928]                         computeRestarts <- base::computeRestarts
  [21:25:30.928]                         grepl <- base::grepl
  [21:25:30.928]                         is.null <- base::is.null
  [21:25:30.928]                         restarts <- computeRestarts(cond)
  [21:25:30.928]                         for (restart in restarts) {
  [21:25:30.928]                           name <- restart$name
  [21:25:30.928]                           if (is.null(name)) 
  [21:25:30.928]                             next
  [21:25:30.928]                           if (!grepl("^muffle", name)) 
  [21:25:30.928]                             next
  [21:25:30.928]                           invokeRestart(restart)
  [21:25:30.928]                           muffled <- TRUE
  [21:25:30.928]                           break
  [21:25:30.928]                         }
  [21:25:30.928]                       }
  [21:25:30.928]                       invisible(muffled)
  [21:25:30.928]                     }
  [21:25:30.928]                     muffleCondition(cond)
  [21:25:30.928]                   }
  [21:25:30.928]                 }
  [21:25:30.928]             }
  [21:25:30.928]         }))
  [21:25:30.928]     }, error = function(ex) {
  [21:25:30.928]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:30.928]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:30.928]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:30.928]     }, finally = {
  [21:25:30.928]         {
  [21:25:30.928]             NULL
  [21:25:30.928]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:30.928]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:30.928]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:30.928]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:30.928]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:30.928]                 ...) 
  [21:25:30.928]             {
  [21:25:30.928]                 if (substitute) 
  [21:25:30.928]                   expr <- substitute(expr)
  [21:25:30.928]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:30.928]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:30.928]                   globals = globals, persistent = persistent, 
  [21:25:30.928]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:30.928]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:30.928]                   label = label, ...)
  [21:25:30.928]                 if (!future$lazy) 
  [21:25:30.928]                   future <- run(future)
  [21:25:30.928]                 invisible(future)
  [21:25:30.928]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:30.928]         }
  [21:25:30.928]         base::options(...future.oldOptions)
  [21:25:30.928]     })
  [21:25:30.928]     Sys.time
  [21:25:30.928]     if (base::is.na(TRUE)) {
  [21:25:30.928]     }
  [21:25:30.928]     else {
  [21:25:30.928]         base::sink(type = "output", split = FALSE)
  [21:25:30.928]         if (TRUE) {
  [21:25:30.928]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:30.928]         }
  [21:25:30.928]         else {
  [21:25:30.928]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:30.928]         }
  [21:25:30.928]         base::close(...future.stdout)
  [21:25:30.928]         ...future.stdout <- NULL
  [21:25:30.928]     }
  [21:25:30.928]     ...future.result$conditions <- ...future.conditions
  [21:25:30.928]     ...future.result
  [21:25:30.928] }
  [21:25:30.949] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:30.963] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:30.964] - Validating connection of ClusterFuture
  [21:25:30.964] - received message: FutureResult
  [21:25:30.964] - Received FutureResult
  [21:25:30.964] - Erased future from FutureRegistry
  [21:25:30.965] result() for ClusterFuture ...
  [21:25:30.965] - result already collected: FutureResult
  [21:25:30.965] result() for ClusterFuture ... done
  [21:25:30.966] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:30.966] result() for ClusterFuture ...
  [21:25:30.966] - result already collected: FutureResult
  [21:25:30.966] result() for ClusterFuture ... done
  [21:25:30.967] result() for ClusterFuture ...
  [21:25:30.967] - result already collected: FutureResult
  [21:25:30.967] result() for ClusterFuture ... done
  [21:25:30.970] ClusterFuture started
  [21:25:30.971] getGlobalsAndPackages() ...
  [21:25:30.971] Searching for globals...
  [21:25:30.972] - globals found: [1] '{'
  [21:25:30.973] Searching for globals ... DONE
  [21:25:30.973] Resolving globals: FALSE
  [21:25:30.974] 
  [21:25:30.974] 
  [21:25:30.974] getGlobalsAndPackages() ... DONE
  [21:25:30.981] Packages needed by the future expression (n = 0): <none>
  [21:25:31.006] Packages needed by future strategies (n = 0): <none>
  [21:25:31.016] {
  [21:25:31.016]     {
  [21:25:31.016]         ...future.startTime <- base::Sys.time()
  [21:25:31.016]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.016]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.016]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.016]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.016]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.016]         {
  [21:25:31.016]             {
  [21:25:31.016]                 base::local({
  [21:25:31.016]                   has_future <- base::requireNamespace("future", 
  [21:25:31.016]                     quietly = TRUE)
  [21:25:31.016]                   version <- if (has_future) 
  [21:25:31.016]                     utils::packageVersion("future")
  [21:25:31.016]                   else NULL
  [21:25:31.016]                   if (!has_future || version < "1.8.0") {
  [21:25:31.016]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.016]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.016]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.016]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.016]                         "release", "version")], collapse = " "), 
  [21:25:31.016]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.016]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.016]                       info)
  [21:25:31.016]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.016]                     if (!has_future) {
  [21:25:31.016]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.016]                         info)
  [21:25:31.016]                     }
  [21:25:31.016]                     else {
  [21:25:31.016]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.016]                         info, version)
  [21:25:31.016]                     }
  [21:25:31.016]                     base::stop(msg)
  [21:25:31.016]                   }
  [21:25:31.016]                 })
  [21:25:31.016]             }
  [21:25:31.016]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.016]         }
  [21:25:31.016]     }
  [21:25:31.016]     if (base::is.na(TRUE)) {
  [21:25:31.016]     }
  [21:25:31.016]     else {
  [21:25:31.016]         if (TRUE) {
  [21:25:31.016]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.016]                 open = "w")
  [21:25:31.016]         }
  [21:25:31.016]         else {
  [21:25:31.016]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.016]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.016]         }
  [21:25:31.016]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.016]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.016]             base::sink(type = "output", split = FALSE)
  [21:25:31.016]             base::close(...future.stdout)
  [21:25:31.016]         }, add = TRUE)
  [21:25:31.016]     }
  [21:25:31.016]     ...future.frame <- base::sys.nframe()
  [21:25:31.016]     ...future.conditions <- base::list()
  [21:25:31.016]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.016]     ...future.result <- base::tryCatch({
  [21:25:31.016]         base::withCallingHandlers({
  [21:25:31.016]             ...future.value <- base::withVisible(base::local({
  [21:25:31.016]                 ...future.sendCondition <- local({
  [21:25:31.016]                   sendCondition <- NULL
  [21:25:31.016]                   function(frame = 1L) {
  [21:25:31.016]                     if (is.function(sendCondition)) 
  [21:25:31.016]                       return(sendCondition)
  [21:25:31.016]                     ns <- getNamespace("parallel")
  [21:25:31.016]                     if (exists("sendData", mode = "function", 
  [21:25:31.016]                       envir = ns)) {
  [21:25:31.016]                       parallel_sendData <- get("sendData", mode = "function", 
  [21:25:31.016]                         envir = ns)
  [21:25:31.016]                       envir <- sys.frame(frame)
  [21:25:31.016]                       master <- NULL
  [21:25:31.016]                       while (!identical(envir, .GlobalEnv) && 
  [21:25:31.016]                         !identical(envir, emptyenv())) {
  [21:25:31.016]                         if (exists("master", mode = "list", envir = envir, 
  [21:25:31.016]                           inherits = FALSE)) {
  [21:25:31.016]                           master <- get("master", mode = "list", 
  [21:25:31.016]                             envir = envir, inherits = FALSE)
  [21:25:31.016]                           if (inherits(master, "SOCKnode")) {
  [21:25:31.016]                             sendCondition <<- function(cond) {
  [21:25:31.016]                               data <- list(type = "VALUE", value = cond, 
  [21:25:31.016]                                 success = TRUE)
  [21:25:31.016]                               parallel_sendData(master, data)
  [21:25:31.016]                             }
  [21:25:31.016]                             return(sendCondition)
  [21:25:31.016]                           }
  [21:25:31.016]                         }
  [21:25:31.016]                         frame <- frame + 1L
  [21:25:31.016]                         envir <- sys.frame(frame)
  [21:25:31.016]                       }
  [21:25:31.016]                     }
  [21:25:31.016]                     sendCondition <<- function(cond) NULL
  [21:25:31.016]                   }
  [21:25:31.016]                 })
  [21:25:31.016]                 withCallingHandlers({
  [21:25:31.016]                   {
  [21:25:31.016]                     4
  [21:25:31.016]                   }
  [21:25:31.016]                 }, immediateCondition = function(cond) {
  [21:25:31.016]                   sendCondition <- ...future.sendCondition()
  [21:25:31.016]                   sendCondition(cond)
  [21:25:31.016]                   muffleCondition <- function (cond) 
  [21:25:31.016]                   {
  [21:25:31.016]                     inherits <- base::inherits
  [21:25:31.016]                     invokeRestart <- base::invokeRestart
  [21:25:31.016]                     muffled <- FALSE
  [21:25:31.016]                     if (inherits(cond, "message")) {
  [21:25:31.016]                       invokeRestart("muffleMessage")
  [21:25:31.016]                       muffled <- TRUE
  [21:25:31.016]                     }
  [21:25:31.016]                     else if (inherits(cond, "warning")) {
  [21:25:31.016]                       invokeRestart("muffleWarning")
  [21:25:31.016]                       muffled <- TRUE
  [21:25:31.016]                     }
  [21:25:31.016]                     else if (inherits(cond, "condition")) {
  [21:25:31.016]                       computeRestarts <- base::computeRestarts
  [21:25:31.016]                       grepl <- base::grepl
  [21:25:31.016]                       is.null <- base::is.null
  [21:25:31.016]                       restarts <- computeRestarts(cond)
  [21:25:31.016]                       for (restart in restarts) {
  [21:25:31.016]                         name <- restart$name
  [21:25:31.016]                         if (is.null(name)) 
  [21:25:31.016]                           next
  [21:25:31.016]                         if (!grepl("^muffle", name)) 
  [21:25:31.016]                           next
  [21:25:31.016]                         invokeRestart(restart)
  [21:25:31.016]                         muffled <- TRUE
  [21:25:31.016]                         break
  [21:25:31.016]                       }
  [21:25:31.016]                     }
  [21:25:31.016]                     invisible(muffled)
  [21:25:31.016]                   }
  [21:25:31.016]                   muffleCondition(cond)
  [21:25:31.016]                 })
  [21:25:31.016]             }))
  [21:25:31.016]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.016]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.016]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.016]                 version = "1.8")
  [21:25:31.016]         }, condition = base::local({
  [21:25:31.016]             c <- base::c
  [21:25:31.016]             inherits <- base::inherits
  [21:25:31.016]             invokeRestart <- base::invokeRestart
  [21:25:31.016]             length <- base::length
  [21:25:31.016]             list <- base::list
  [21:25:31.016]             seq.int <- base::seq.int
  [21:25:31.016]             signalCondition <- base::signalCondition
  [21:25:31.016]             sys.calls <- base::sys.calls
  [21:25:31.016]             Sys.time <- base::Sys.time
  [21:25:31.016]             `[[` <- base::`[[`
  [21:25:31.016]             `+` <- base::`+`
  [21:25:31.016]             `<<-` <- base::`<<-`
  [21:25:31.016]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.016]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.016]                   3L)]
  [21:25:31.016]             }
  [21:25:31.016]             function(cond) {
  [21:25:31.016]                 if (inherits(cond, "error")) {
  [21:25:31.016]                   sessionInformation <- function() {
  [21:25:31.016]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.016]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.016]                       search = base::search(), system = base::Sys.info())
  [21:25:31.016]                   }
  [21:25:31.016]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.016]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.016]                     cond$call), session = sessionInformation(), 
  [21:25:31.016]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.016]                   signalCondition(cond)
  [21:25:31.016]                 }
  [21:25:31.016]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.016]                 ))) {
  [21:25:31.016]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.016]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.016]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.016]                   if (!signal) {
  [21:25:31.016]                     muffleCondition <- function (cond) 
  [21:25:31.016]                     {
  [21:25:31.016]                       inherits <- base::inherits
  [21:25:31.016]                       invokeRestart <- base::invokeRestart
  [21:25:31.016]                       muffled <- FALSE
  [21:25:31.016]                       if (inherits(cond, "message")) {
  [21:25:31.016]                         invokeRestart("muffleMessage")
  [21:25:31.016]                         muffled <- TRUE
  [21:25:31.016]                       }
  [21:25:31.016]                       else if (inherits(cond, "warning")) {
  [21:25:31.016]                         invokeRestart("muffleWarning")
  [21:25:31.016]                         muffled <- TRUE
  [21:25:31.016]                       }
  [21:25:31.016]                       else if (inherits(cond, "condition")) {
  [21:25:31.016]                         computeRestarts <- base::computeRestarts
  [21:25:31.016]                         grepl <- base::grepl
  [21:25:31.016]                         is.null <- base::is.null
  [21:25:31.016]                         restarts <- computeRestarts(cond)
  [21:25:31.016]                         for (restart in restarts) {
  [21:25:31.016]                           name <- restart$name
  [21:25:31.016]                           if (is.null(name)) 
  [21:25:31.016]                             next
  [21:25:31.016]                           if (!grepl("^muffle", name)) 
  [21:25:31.016]                             next
  [21:25:31.016]                           invokeRestart(restart)
  [21:25:31.016]                           muffled <- TRUE
  [21:25:31.016]                           break
  [21:25:31.016]                         }
  [21:25:31.016]                       }
  [21:25:31.016]                       invisible(muffled)
  [21:25:31.016]                     }
  [21:25:31.016]                     muffleCondition(cond)
  [21:25:31.016]                   }
  [21:25:31.016]                 }
  [21:25:31.016]             }
  [21:25:31.016]         }))
  [21:25:31.016]     }, error = function(ex) {
  [21:25:31.016]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.016]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.016]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.016]     }, finally = {
  [21:25:31.016]         {
  [21:25:31.016]             NULL
  [21:25:31.016]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.016]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.016]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [21:25:31.016]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [21:25:31.016]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [21:25:31.016]                 ...) 
  [21:25:31.016]             {
  [21:25:31.016]                 if (substitute) 
  [21:25:31.016]                   expr <- substitute(expr)
  [21:25:31.016]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [21:25:31.016]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.016]                   globals = globals, persistent = persistent, 
  [21:25:31.016]                   workers = workers, user = user, revtunnel = revtunnel, 
  [21:25:31.016]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [21:25:31.016]                   label = label, ...)
  [21:25:31.016]                 if (!future$lazy) 
  [21:25:31.016]                   future <- run(future)
  [21:25:31.016]                 invisible(future)
  [21:25:31.016]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.016]         }
  [21:25:31.016]         base::options(...future.oldOptions)
  [21:25:31.016]     })
  [21:25:31.016]     Sys.time
  [21:25:31.016]     if (base::is.na(TRUE)) {
  [21:25:31.016]     }
  [21:25:31.016]     else {
  [21:25:31.016]         base::sink(type = "output", split = FALSE)
  [21:25:31.016]         if (TRUE) {
  [21:25:31.016]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.016]         }
  [21:25:31.016]         else {
  [21:25:31.016]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.016]         }
  [21:25:31.016]         base::close(...future.stdout)
  [21:25:31.016]         ...future.stdout <- NULL
  [21:25:31.016]     }
  [21:25:31.016]     ...future.result$conditions <- ...future.conditions
  [21:25:31.016]     ...future.result
  [21:25:31.016] }
  [21:25:31.020] Poll #1 (0): usedNodes() = 1, workers = 1
  [21:25:31.032] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:31.033] - Validating connection of ClusterFuture
  [21:25:31.033] - received message: FutureResult
  [21:25:31.033] - Received FutureResult
  [21:25:31.034] - Erased future from FutureRegistry
  [21:25:31.034] result() for ClusterFuture ...
  [21:25:31.034] - result already collected: FutureResult
  [21:25:31.035] result() for ClusterFuture ... done
  [21:25:31.035] receiveMessageFromWorker() for ClusterFuture ... done
  [21:25:31.036] result() for ClusterFuture ...
  [21:25:31.036] - result already collected: FutureResult
  [21:25:31.036] result() for ClusterFuture ... done
  [21:25:31.037] result() for ClusterFuture ...
  [21:25:31.037] - result already collected: FutureResult
  [21:25:31.037] result() for ClusterFuture ... done
  [21:25:31.040] ClusterFuture started
  <environment: 0x55ef21886460> 
  <environment: 0x55ef217a8928> 
  [21:25:31.091] receiveMessageFromWorker() for ClusterFuture ...
  [21:25:31.091] - Validating connection of ClusterFuture
  [21:25:31.091] - received message: FutureResult
  [21:25:31.092] - Received FutureResult
  [21:25:31.092] - Erased future from FutureRegistry
  [21:25:31.092] result() for ClusterFuture ...
  [21:25:31.093] - result already collected: FutureResult
  [21:25:31.093] result() for ClusterFuture ... done
  [21:25:31.093] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [21:25:31.096] resolve() on environment ...
  [21:25:31.097]  recursive: 0
  [21:25:31.098]  elements: [4] 'a', 'b', 'c', 'd'
  [21:25:31.098] signalConditionsASAP(numeric, pos=1) ...
  [21:25:31.099] - nx: 4
  [21:25:31.099] - relay: TRUE
  [21:25:31.099] - stdout: TRUE
  [21:25:31.099] - signal: TRUE
  [21:25:31.100] - resignal: FALSE
  [21:25:31.100] - force: TRUE
  [21:25:31.100] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:31.100] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:31.101]  - until=2
  [21:25:31.101]  - relaying element #2
  [21:25:31.101] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:31.101] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:31.102] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:31.102]  length: 3 (resolved future 1)
  [21:25:31.102] Future #2
  [21:25:31.103] result() for ClusterFuture ...
  [21:25:31.103] - result already collected: FutureResult
  [21:25:31.103] result() for ClusterFuture ... done
  [21:25:31.103] result() for ClusterFuture ...
  [21:25:31.104] - result already collected: FutureResult
  [21:25:31.104] result() for ClusterFuture ... done
  [21:25:31.104] signalConditionsASAP(ClusterFuture, pos=2) ...
  [21:25:31.105] - nx: 4
  [21:25:31.105] - relay: TRUE
  [21:25:31.105] - stdout: TRUE
  [21:25:31.105] - signal: TRUE
  [21:25:31.106] - resignal: FALSE
  [21:25:31.106] - force: TRUE
  [21:25:31.106] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:25:31.106] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:25:31.107]  - until=2
  [21:25:31.107]  - relaying element #2
  [21:25:31.107] result() for ClusterFuture ...
  [21:25:31.107] - result already collected: FutureResult
  [21:25:31.108] result() for ClusterFuture ... done
  [21:25:31.108] result() for ClusterFuture ...
  [21:25:31.108] - result already collected: FutureResult
  [21:25:31.109] result() for ClusterFuture ... done
  [21:25:31.109] result() for ClusterFuture ...
  [21:25:31.109] - result already collected: FutureResult
  [21:25:31.110] result() for ClusterFuture ... done
  [21:25:31.122] result() for ClusterFuture ...
  [21:25:31.122] - result already collected: FutureResult
  [21:25:31.123] result() for ClusterFuture ... done
  [21:25:31.123] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:31.123] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:31.123] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [21:25:31.124]  length: 2 (resolved future 2)
  [21:25:31.124] Future #3
  [21:25:31.124] result() for ClusterFuture ...
  [21:25:31.125] - result already collected: FutureResult
  [21:25:31.125] result() for ClusterFuture ... done
  [21:25:31.125] result() for ClusterFuture ...
  [21:25:31.126] - result already collected: FutureResult
  [21:25:31.126] result() for ClusterFuture ... done
  [21:25:31.126] signalConditionsASAP(ClusterFuture, pos=3) ...
  [21:25:31.126] - nx: 4
  [21:25:31.127] - relay: TRUE
  [21:25:31.127] - stdout: TRUE
  [21:25:31.127] - signal: TRUE
  [21:25:31.127] - resignal: FALSE
  [21:25:31.128] - force: TRUE
  [21:25:31.128] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:25:31.128] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [21:25:31.129]  - until=3
  [21:25:31.129]  - relaying element #3
  [21:25:31.129] result() for ClusterFuture ...
  [21:25:31.129] - result already collected: FutureResult
  [21:25:31.130] result() for ClusterFuture ... done
  [21:25:31.130] result() for ClusterFuture ...
  [21:25:31.130] - result already collected: FutureResult
  [21:25:31.131] result() for ClusterFuture ... done
  [21:25:31.131] result() for ClusterFuture ...
  [21:25:31.131] - result already collected: FutureResult
  [21:25:31.132] result() for ClusterFuture ... done
  [21:25:31.132] result() for ClusterFuture ...
  [21:25:31.132] - result already collected: FutureResult
  [21:25:31.132] result() for ClusterFuture ... done
  [21:25:31.133] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:31.133] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:31.133] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [21:25:31.134]  length: 1 (resolved future 3)
  [21:25:31.150] Future #4
  [21:25:31.150] result() for ClusterFuture ...
  [21:25:31.151] - result already collected: FutureResult
  [21:25:31.151] result() for ClusterFuture ... done
  [21:25:31.151] result() for ClusterFuture ...
  [21:25:31.152] - result already collected: FutureResult
  [21:25:31.152] result() for ClusterFuture ... done
  [21:25:31.152] signalConditionsASAP(ClusterFuture, pos=4) ...
  [21:25:31.152] - nx: 4
  [21:25:31.153] - relay: TRUE
  [21:25:31.153] - stdout: TRUE
  [21:25:31.153] - signal: TRUE
  [21:25:31.153] - resignal: FALSE
  [21:25:31.154] - force: TRUE
  [21:25:31.154] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:25:31.154] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [21:25:31.154]  - until=4
  [21:25:31.155]  - relaying element #4
  [21:25:31.155] result() for ClusterFuture ...
  [21:25:31.155] - result already collected: FutureResult
  [21:25:31.156] result() for ClusterFuture ... done
  [21:25:31.156] result() for ClusterFuture ...
  [21:25:31.156] - result already collected: FutureResult
  [21:25:31.156] result() for ClusterFuture ... done
  [21:25:31.157] result() for ClusterFuture ...
  [21:25:31.157] - result already collected: FutureResult
  [21:25:31.157] result() for ClusterFuture ... done
  [21:25:31.158] result() for ClusterFuture ...
  [21:25:31.158] - result already collected: FutureResult
  [21:25:31.158] result() for ClusterFuture ... done
  [21:25:31.158] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:31.159] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:31.163] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [21:25:31.163]  length: 0 (resolved future 4)
  [21:25:31.163] Relaying remaining futures
  [21:25:31.164] signalConditionsASAP(NULL, pos=0) ...
  [21:25:31.164] - nx: 4
  [21:25:31.164] - relay: TRUE
  [21:25:31.164] - stdout: TRUE
  [21:25:31.165] - signal: TRUE
  [21:25:31.165] - resignal: FALSE
  [21:25:31.165] - force: TRUE
  [21:25:31.165] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:31.166] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [21:25:31.182] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:25:31.183] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [21:25:31.183] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:31.183] resolve() on environment ... DONE
  [21:25:31.183] result() for ClusterFuture ...
  [21:25:31.184] - result already collected: FutureResult
  [21:25:31.184] result() for ClusterFuture ... done
  [21:25:31.184] result() for ClusterFuture ...
  [21:25:31.184] - result already collected: FutureResult
  [21:25:31.185] result() for ClusterFuture ... done
  [21:25:31.185] result() for ClusterFuture ...
  [21:25:31.185] - result already collected: FutureResult
  [21:25:31.185] result() for ClusterFuture ... done
  [21:25:31.186] result() for ClusterFuture ...
  [21:25:31.186] - result already collected: FutureResult
  [21:25:31.186] result() for ClusterFuture ... done
  [21:25:31.186] result() for ClusterFuture ...
  [21:25:31.187] - result already collected: FutureResult
  [21:25:31.187] result() for ClusterFuture ... done
  [21:25:31.187] result() for ClusterFuture ...
  [21:25:31.187] - result already collected: FutureResult
  [21:25:31.188] result() for ClusterFuture ... done
  <environment: 0x55ef2119d0a0> 
  *** futures() - environment ... DONE
  Type of object: listenv
  Type of future: sequential
  [21:25:31.189] plan(): Setting new future strategy stack:
  [21:25:31.189] List of future strategies:
  [21:25:31.189] 1. sequential:
  [21:25:31.189]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.189]    - tweaked: FALSE
  [21:25:31.189]    - call: plan(strategy)
  [21:25:31.198] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [21:25:31.199] getGlobalsAndPackages() ...
  [21:25:31.200] Searching for globals...
  [21:25:31.200] 
  [21:25:31.201] Searching for globals ... DONE
  [21:25:31.201] - globals: [0] <none>
  [21:25:31.201] getGlobalsAndPackages() ... DONE
  [21:25:31.203] Packages needed by the future expression (n = 0): <none>
  [21:25:31.203] Packages needed by future strategies (n = 0): <none>
  [21:25:31.207] {
  [21:25:31.207]     {
  [21:25:31.207]         ...future.startTime <- base::Sys.time()
  [21:25:31.207]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.207]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.207]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.207]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.207]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.207]         {
  [21:25:31.207]             {
  [21:25:31.207]                 base::local({
  [21:25:31.207]                   has_future <- base::requireNamespace("future", 
  [21:25:31.207]                     quietly = TRUE)
  [21:25:31.207]                   version <- if (has_future) 
  [21:25:31.207]                     utils::packageVersion("future")
  [21:25:31.207]                   else NULL
  [21:25:31.207]                   if (!has_future || version < "1.8.0") {
  [21:25:31.207]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.207]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.207]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.207]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.207]                         "release", "version")], collapse = " "), 
  [21:25:31.207]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.207]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.207]                       info)
  [21:25:31.207]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.207]                     if (!has_future) {
  [21:25:31.207]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.207]                         info)
  [21:25:31.207]                     }
  [21:25:31.207]                     else {
  [21:25:31.207]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.207]                         info, version)
  [21:25:31.207]                     }
  [21:25:31.207]                     base::stop(msg)
  [21:25:31.207]                   }
  [21:25:31.207]                 })
  [21:25:31.207]             }
  [21:25:31.207]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.207]         }
  [21:25:31.207]     }
  [21:25:31.207]     if (base::is.na(TRUE)) {
  [21:25:31.207]     }
  [21:25:31.207]     else {
  [21:25:31.207]         if (TRUE) {
  [21:25:31.207]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.207]                 open = "w")
  [21:25:31.207]         }
  [21:25:31.207]         else {
  [21:25:31.207]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.207]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.207]         }
  [21:25:31.207]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.207]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.207]             base::sink(type = "output", split = FALSE)
  [21:25:31.207]             base::close(...future.stdout)
  [21:25:31.207]         }, add = TRUE)
  [21:25:31.207]     }
  [21:25:31.207]     ...future.frame <- base::sys.nframe()
  [21:25:31.207]     ...future.conditions <- base::list()
  [21:25:31.207]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.207]     ...future.result <- base::tryCatch({
  [21:25:31.207]         base::withCallingHandlers({
  [21:25:31.207]             ...future.value <- base::withVisible(base::local(2))
  [21:25:31.207]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.207]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.207]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.207]                 version = "1.8")
  [21:25:31.207]         }, condition = base::local({
  [21:25:31.207]             c <- base::c
  [21:25:31.207]             inherits <- base::inherits
  [21:25:31.207]             invokeRestart <- base::invokeRestart
  [21:25:31.207]             length <- base::length
  [21:25:31.207]             list <- base::list
  [21:25:31.207]             seq.int <- base::seq.int
  [21:25:31.207]             signalCondition <- base::signalCondition
  [21:25:31.207]             sys.calls <- base::sys.calls
  [21:25:31.207]             Sys.time <- base::Sys.time
  [21:25:31.207]             `[[` <- base::`[[`
  [21:25:31.207]             `+` <- base::`+`
  [21:25:31.207]             `<<-` <- base::`<<-`
  [21:25:31.207]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.207]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.207]                   3L)]
  [21:25:31.207]             }
  [21:25:31.207]             function(cond) {
  [21:25:31.207]                 if (inherits(cond, "error")) {
  [21:25:31.207]                   sessionInformation <- function() {
  [21:25:31.207]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.207]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.207]                       search = base::search(), system = base::Sys.info())
  [21:25:31.207]                   }
  [21:25:31.207]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.207]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.207]                     cond$call), session = sessionInformation(), 
  [21:25:31.207]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.207]                   signalCondition(cond)
  [21:25:31.207]                 }
  [21:25:31.207]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.207]                 ))) {
  [21:25:31.207]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.207]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.207]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.207]                   if (!signal) {
  [21:25:31.207]                     muffleCondition <- function (cond) 
  [21:25:31.207]                     {
  [21:25:31.207]                       inherits <- base::inherits
  [21:25:31.207]                       invokeRestart <- base::invokeRestart
  [21:25:31.207]                       muffled <- FALSE
  [21:25:31.207]                       if (inherits(cond, "message")) {
  [21:25:31.207]                         invokeRestart("muffleMessage")
  [21:25:31.207]                         muffled <- TRUE
  [21:25:31.207]                       }
  [21:25:31.207]                       else if (inherits(cond, "warning")) {
  [21:25:31.207]                         invokeRestart("muffleWarning")
  [21:25:31.207]                         muffled <- TRUE
  [21:25:31.207]                       }
  [21:25:31.207]                       else if (inherits(cond, "condition")) {
  [21:25:31.207]                         computeRestarts <- base::computeRestarts
  [21:25:31.207]                         grepl <- base::grepl
  [21:25:31.207]                         is.null <- base::is.null
  [21:25:31.207]                         restarts <- computeRestarts(cond)
  [21:25:31.207]                         for (restart in restarts) {
  [21:25:31.207]                           name <- restart$name
  [21:25:31.207]                           if (is.null(name)) 
  [21:25:31.207]                             next
  [21:25:31.207]                           if (!grepl("^muffle", name)) 
  [21:25:31.207]                             next
  [21:25:31.207]                           invokeRestart(restart)
  [21:25:31.207]                           muffled <- TRUE
  [21:25:31.207]                           break
  [21:25:31.207]                         }
  [21:25:31.207]                       }
  [21:25:31.207]                       invisible(muffled)
  [21:25:31.207]                     }
  [21:25:31.207]                     muffleCondition(cond)
  [21:25:31.207]                   }
  [21:25:31.207]                 }
  [21:25:31.207]             }
  [21:25:31.207]         }))
  [21:25:31.207]     }, error = function(ex) {
  [21:25:31.207]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.207]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.207]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.207]     }, finally = {
  [21:25:31.207]         {
  [21:25:31.207]             NULL
  [21:25:31.207]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.207]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.207]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.207]                 label = NULL, ...) 
  [21:25:31.207]             {
  [21:25:31.207]                 if (substitute) 
  [21:25:31.207]                   expr <- substitute(expr)
  [21:25:31.207]                 local <- as.logical(local)
  [21:25:31.207]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.207]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.207]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.207]                   label = label, ...)
  [21:25:31.207]                 if (!future$lazy) 
  [21:25:31.207]                   future <- run(future)
  [21:25:31.207]                 invisible(future)
  [21:25:31.207]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.207]         }
  [21:25:31.207]         base::options(...future.oldOptions)
  [21:25:31.207]     })
  [21:25:31.207]     Sys.time
  [21:25:31.207]     if (base::is.na(TRUE)) {
  [21:25:31.207]     }
  [21:25:31.207]     else {
  [21:25:31.207]         base::sink(type = "output", split = FALSE)
  [21:25:31.207]         if (TRUE) {
  [21:25:31.207]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.207]         }
  [21:25:31.207]         else {
  [21:25:31.207]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.207]         }
  [21:25:31.207]         base::close(...future.stdout)
  [21:25:31.207]         ...future.stdout <- NULL
  [21:25:31.207]     }
  [21:25:31.207]     ...future.result$conditions <- ...future.conditions
  [21:25:31.207]     ...future.result
  [21:25:31.207] }
  [21:25:31.212] plan(): Setting new future strategy stack:
  [21:25:31.212] List of future strategies:
  [21:25:31.212] 1. sequential:
  [21:25:31.212]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.212]    - tweaked: FALSE
  [21:25:31.212]    - call: NULL
  [21:25:31.213] plan(): nbrOfWorkers() = 1
  [21:25:31.231] plan(): Setting new future strategy stack:
  [21:25:31.231] List of future strategies:
  [21:25:31.231] 1. sequential:
  [21:25:31.231]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.231]    - tweaked: FALSE
  [21:25:31.231]    - call: plan(strategy)
  [21:25:31.232] plan(): nbrOfWorkers() = 1
  [21:25:31.233] SequentialFuture started (and completed)
  [21:25:31.233] getGlobalsAndPackages() ...
  [21:25:31.233] Searching for globals...
  [21:25:31.234] 
  [21:25:31.234] Searching for globals ... DONE
  [21:25:31.235] - globals: [0] <none>
  [21:25:31.235] getGlobalsAndPackages() ... DONE
  [21:25:31.236] Packages needed by the future expression (n = 0): <none>
  [21:25:31.237] Packages needed by future strategies (n = 0): <none>
  [21:25:31.241] {
  [21:25:31.241]     {
  [21:25:31.241]         ...future.startTime <- base::Sys.time()
  [21:25:31.241]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.241]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.241]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.241]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.241]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.241]         {
  [21:25:31.241]             {
  [21:25:31.241]                 base::local({
  [21:25:31.241]                   has_future <- base::requireNamespace("future", 
  [21:25:31.241]                     quietly = TRUE)
  [21:25:31.241]                   version <- if (has_future) 
  [21:25:31.241]                     utils::packageVersion("future")
  [21:25:31.241]                   else NULL
  [21:25:31.241]                   if (!has_future || version < "1.8.0") {
  [21:25:31.241]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.241]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.241]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.241]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.241]                         "release", "version")], collapse = " "), 
  [21:25:31.241]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.241]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.241]                       info)
  [21:25:31.241]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.241]                     if (!has_future) {
  [21:25:31.241]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.241]                         info)
  [21:25:31.241]                     }
  [21:25:31.241]                     else {
  [21:25:31.241]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.241]                         info, version)
  [21:25:31.241]                     }
  [21:25:31.241]                     base::stop(msg)
  [21:25:31.241]                   }
  [21:25:31.241]                 })
  [21:25:31.241]             }
  [21:25:31.241]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.241]         }
  [21:25:31.241]     }
  [21:25:31.241]     if (base::is.na(TRUE)) {
  [21:25:31.241]     }
  [21:25:31.241]     else {
  [21:25:31.241]         if (TRUE) {
  [21:25:31.241]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.241]                 open = "w")
  [21:25:31.241]         }
  [21:25:31.241]         else {
  [21:25:31.241]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.241]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.241]         }
  [21:25:31.241]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.241]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.241]             base::sink(type = "output", split = FALSE)
  [21:25:31.241]             base::close(...future.stdout)
  [21:25:31.241]         }, add = TRUE)
  [21:25:31.241]     }
  [21:25:31.241]     ...future.frame <- base::sys.nframe()
  [21:25:31.241]     ...future.conditions <- base::list()
  [21:25:31.241]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.241]     ...future.result <- base::tryCatch({
  [21:25:31.241]         base::withCallingHandlers({
  [21:25:31.241]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:31.241]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.241]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.241]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.241]                 version = "1.8")
  [21:25:31.241]         }, condition = base::local({
  [21:25:31.241]             c <- base::c
  [21:25:31.241]             inherits <- base::inherits
  [21:25:31.241]             invokeRestart <- base::invokeRestart
  [21:25:31.241]             length <- base::length
  [21:25:31.241]             list <- base::list
  [21:25:31.241]             seq.int <- base::seq.int
  [21:25:31.241]             signalCondition <- base::signalCondition
  [21:25:31.241]             sys.calls <- base::sys.calls
  [21:25:31.241]             Sys.time <- base::Sys.time
  [21:25:31.241]             `[[` <- base::`[[`
  [21:25:31.241]             `+` <- base::`+`
  [21:25:31.241]             `<<-` <- base::`<<-`
  [21:25:31.241]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.241]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.241]                   3L)]
  [21:25:31.241]             }
  [21:25:31.241]             function(cond) {
  [21:25:31.241]                 if (inherits(cond, "error")) {
  [21:25:31.241]                   sessionInformation <- function() {
  [21:25:31.241]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.241]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.241]                       search = base::search(), system = base::Sys.info())
  [21:25:31.241]                   }
  [21:25:31.241]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.241]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.241]                     cond$call), session = sessionInformation(), 
  [21:25:31.241]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.241]                   signalCondition(cond)
  [21:25:31.241]                 }
  [21:25:31.241]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.241]                 ))) {
  [21:25:31.241]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.241]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.241]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.241]                   if (!signal) {
  [21:25:31.241]                     muffleCondition <- function (cond) 
  [21:25:31.241]                     {
  [21:25:31.241]                       inherits <- base::inherits
  [21:25:31.241]                       invokeRestart <- base::invokeRestart
  [21:25:31.241]                       muffled <- FALSE
  [21:25:31.241]                       if (inherits(cond, "message")) {
  [21:25:31.241]                         invokeRestart("muffleMessage")
  [21:25:31.241]                         muffled <- TRUE
  [21:25:31.241]                       }
  [21:25:31.241]                       else if (inherits(cond, "warning")) {
  [21:25:31.241]                         invokeRestart("muffleWarning")
  [21:25:31.241]                         muffled <- TRUE
  [21:25:31.241]                       }
  [21:25:31.241]                       else if (inherits(cond, "condition")) {
  [21:25:31.241]                         computeRestarts <- base::computeRestarts
  [21:25:31.241]                         grepl <- base::grepl
  [21:25:31.241]                         is.null <- base::is.null
  [21:25:31.241]                         restarts <- computeRestarts(cond)
  [21:25:31.241]                         for (restart in restarts) {
  [21:25:31.241]                           name <- restart$name
  [21:25:31.241]                           if (is.null(name)) 
  [21:25:31.241]                             next
  [21:25:31.241]                           if (!grepl("^muffle", name)) 
  [21:25:31.241]                             next
  [21:25:31.241]                           invokeRestart(restart)
  [21:25:31.241]                           muffled <- TRUE
  [21:25:31.241]                           break
  [21:25:31.241]                         }
  [21:25:31.241]                       }
  [21:25:31.241]                       invisible(muffled)
  [21:25:31.241]                     }
  [21:25:31.241]                     muffleCondition(cond)
  [21:25:31.241]                   }
  [21:25:31.241]                 }
  [21:25:31.241]             }
  [21:25:31.241]         }))
  [21:25:31.241]     }, error = function(ex) {
  [21:25:31.241]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.241]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.241]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.241]     }, finally = {
  [21:25:31.241]         {
  [21:25:31.241]             NULL
  [21:25:31.241]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.241]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.241]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.241]                 label = NULL, ...) 
  [21:25:31.241]             {
  [21:25:31.241]                 if (substitute) 
  [21:25:31.241]                   expr <- substitute(expr)
  [21:25:31.241]                 local <- as.logical(local)
  [21:25:31.241]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.241]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.241]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.241]                   label = label, ...)
  [21:25:31.241]                 if (!future$lazy) 
  [21:25:31.241]                   future <- run(future)
  [21:25:31.241]                 invisible(future)
  [21:25:31.241]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.241]         }
  [21:25:31.241]         base::options(...future.oldOptions)
  [21:25:31.241]     })
  [21:25:31.241]     Sys.time
  [21:25:31.241]     if (base::is.na(TRUE)) {
  [21:25:31.241]     }
  [21:25:31.241]     else {
  [21:25:31.241]         base::sink(type = "output", split = FALSE)
  [21:25:31.241]         if (TRUE) {
  [21:25:31.241]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.241]         }
  [21:25:31.241]         else {
  [21:25:31.241]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.241]         }
  [21:25:31.241]         base::close(...future.stdout)
  [21:25:31.241]         ...future.stdout <- NULL
  [21:25:31.241]     }
  [21:25:31.241]     ...future.result$conditions <- ...future.conditions
  [21:25:31.241]     ...future.result
  [21:25:31.241] }
  [21:25:31.258] plan(): Setting new future strategy stack:
  [21:25:31.258] List of future strategies:
  [21:25:31.258] 1. sequential:
  [21:25:31.258]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.258]    - tweaked: FALSE
  [21:25:31.258]    - call: NULL
  [21:25:31.259] plan(): nbrOfWorkers() = 1
  [21:25:31.260] plan(): Setting new future strategy stack:
  [21:25:31.260] List of future strategies:
  [21:25:31.260] 1. sequential:
  [21:25:31.260]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.260]    - tweaked: FALSE
  [21:25:31.260]    - call: plan(strategy)
  [21:25:31.261] plan(): nbrOfWorkers() = 1
  [21:25:31.262] SequentialFuture started (and completed)
  [21:25:31.263] getGlobalsAndPackages() ...
  [21:25:31.263] Searching for globals...
  [21:25:31.265] - globals found: [1] '{'
  [21:25:31.265] Searching for globals ... DONE
  [21:25:31.265] Resolving globals: FALSE
  [21:25:31.266] 
  [21:25:31.266] 
  [21:25:31.266] getGlobalsAndPackages() ... DONE
  [21:25:31.268] Packages needed by the future expression (n = 0): <none>
  [21:25:31.269] Packages needed by future strategies (n = 0): <none>
  [21:25:31.294] {
  [21:25:31.294]     {
  [21:25:31.294]         ...future.startTime <- base::Sys.time()
  [21:25:31.294]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.294]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.294]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.294]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.294]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.294]         {
  [21:25:31.294]             {
  [21:25:31.294]                 base::local({
  [21:25:31.294]                   has_future <- base::requireNamespace("future", 
  [21:25:31.294]                     quietly = TRUE)
  [21:25:31.294]                   version <- if (has_future) 
  [21:25:31.294]                     utils::packageVersion("future")
  [21:25:31.294]                   else NULL
  [21:25:31.294]                   if (!has_future || version < "1.8.0") {
  [21:25:31.294]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.294]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.294]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.294]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.294]                         "release", "version")], collapse = " "), 
  [21:25:31.294]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.294]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.294]                       info)
  [21:25:31.294]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.294]                     if (!has_future) {
  [21:25:31.294]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.294]                         info)
  [21:25:31.294]                     }
  [21:25:31.294]                     else {
  [21:25:31.294]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.294]                         info, version)
  [21:25:31.294]                     }
  [21:25:31.294]                     base::stop(msg)
  [21:25:31.294]                   }
  [21:25:31.294]                 })
  [21:25:31.294]             }
  [21:25:31.294]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.294]         }
  [21:25:31.294]     }
  [21:25:31.294]     if (base::is.na(TRUE)) {
  [21:25:31.294]     }
  [21:25:31.294]     else {
  [21:25:31.294]         if (TRUE) {
  [21:25:31.294]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.294]                 open = "w")
  [21:25:31.294]         }
  [21:25:31.294]         else {
  [21:25:31.294]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.294]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.294]         }
  [21:25:31.294]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.294]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.294]             base::sink(type = "output", split = FALSE)
  [21:25:31.294]             base::close(...future.stdout)
  [21:25:31.294]         }, add = TRUE)
  [21:25:31.294]     }
  [21:25:31.294]     ...future.frame <- base::sys.nframe()
  [21:25:31.294]     ...future.conditions <- base::list()
  [21:25:31.294]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.294]     ...future.result <- base::tryCatch({
  [21:25:31.294]         base::withCallingHandlers({
  [21:25:31.294]             ...future.value <- base::withVisible(base::local({
  [21:25:31.294]                 4
  [21:25:31.294]             }))
  [21:25:31.294]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.294]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.294]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.294]                 version = "1.8")
  [21:25:31.294]         }, condition = base::local({
  [21:25:31.294]             c <- base::c
  [21:25:31.294]             inherits <- base::inherits
  [21:25:31.294]             invokeRestart <- base::invokeRestart
  [21:25:31.294]             length <- base::length
  [21:25:31.294]             list <- base::list
  [21:25:31.294]             seq.int <- base::seq.int
  [21:25:31.294]             signalCondition <- base::signalCondition
  [21:25:31.294]             sys.calls <- base::sys.calls
  [21:25:31.294]             Sys.time <- base::Sys.time
  [21:25:31.294]             `[[` <- base::`[[`
  [21:25:31.294]             `+` <- base::`+`
  [21:25:31.294]             `<<-` <- base::`<<-`
  [21:25:31.294]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.294]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.294]                   3L)]
  [21:25:31.294]             }
  [21:25:31.294]             function(cond) {
  [21:25:31.294]                 if (inherits(cond, "error")) {
  [21:25:31.294]                   sessionInformation <- function() {
  [21:25:31.294]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.294]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.294]                       search = base::search(), system = base::Sys.info())
  [21:25:31.294]                   }
  [21:25:31.294]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.294]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.294]                     cond$call), session = sessionInformation(), 
  [21:25:31.294]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.294]                   signalCondition(cond)
  [21:25:31.294]                 }
  [21:25:31.294]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.294]                 ))) {
  [21:25:31.294]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.294]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.294]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.294]                   if (!signal) {
  [21:25:31.294]                     muffleCondition <- function (cond) 
  [21:25:31.294]                     {
  [21:25:31.294]                       inherits <- base::inherits
  [21:25:31.294]                       invokeRestart <- base::invokeRestart
  [21:25:31.294]                       muffled <- FALSE
  [21:25:31.294]                       if (inherits(cond, "message")) {
  [21:25:31.294]                         invokeRestart("muffleMessage")
  [21:25:31.294]                         muffled <- TRUE
  [21:25:31.294]                       }
  [21:25:31.294]                       else if (inherits(cond, "warning")) {
  [21:25:31.294]                         invokeRestart("muffleWarning")
  [21:25:31.294]                         muffled <- TRUE
  [21:25:31.294]                       }
  [21:25:31.294]                       else if (inherits(cond, "condition")) {
  [21:25:31.294]                         computeRestarts <- base::computeRestarts
  [21:25:31.294]                         grepl <- base::grepl
  [21:25:31.294]                         is.null <- base::is.null
  [21:25:31.294]                         restarts <- computeRestarts(cond)
  [21:25:31.294]                         for (restart in restarts) {
  [21:25:31.294]                           name <- restart$name
  [21:25:31.294]                           if (is.null(name)) 
  [21:25:31.294]                             next
  [21:25:31.294]                           if (!grepl("^muffle", name)) 
  [21:25:31.294]                             next
  [21:25:31.294]                           invokeRestart(restart)
  [21:25:31.294]                           muffled <- TRUE
  [21:25:31.294]                           break
  [21:25:31.294]                         }
  [21:25:31.294]                       }
  [21:25:31.294]                       invisible(muffled)
  [21:25:31.294]                     }
  [21:25:31.294]                     muffleCondition(cond)
  [21:25:31.294]                   }
  [21:25:31.294]                 }
  [21:25:31.294]             }
  [21:25:31.294]         }))
  [21:25:31.294]     }, error = function(ex) {
  [21:25:31.294]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.294]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.294]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.294]     }, finally = {
  [21:25:31.294]         {
  [21:25:31.294]             NULL
  [21:25:31.294]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.294]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.294]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.294]                 label = NULL, ...) 
  [21:25:31.294]             {
  [21:25:31.294]                 if (substitute) 
  [21:25:31.294]                   expr <- substitute(expr)
  [21:25:31.294]                 local <- as.logical(local)
  [21:25:31.294]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.294]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.294]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.294]                   label = label, ...)
  [21:25:31.294]                 if (!future$lazy) 
  [21:25:31.294]                   future <- run(future)
  [21:25:31.294]                 invisible(future)
  [21:25:31.294]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.294]         }
  [21:25:31.294]         base::options(...future.oldOptions)
  [21:25:31.294]     })
  [21:25:31.294]     Sys.time
  [21:25:31.294]     if (base::is.na(TRUE)) {
  [21:25:31.294]     }
  [21:25:31.294]     else {
  [21:25:31.294]         base::sink(type = "output", split = FALSE)
  [21:25:31.294]         if (TRUE) {
  [21:25:31.294]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.294]         }
  [21:25:31.294]         else {
  [21:25:31.294]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.294]         }
  [21:25:31.294]         base::close(...future.stdout)
  [21:25:31.294]         ...future.stdout <- NULL
  [21:25:31.294]     }
  [21:25:31.294]     ...future.result$conditions <- ...future.conditions
  [21:25:31.294]     ...future.result
  [21:25:31.294] }
  [21:25:31.298] plan(): Setting new future strategy stack:
  [21:25:31.299] List of future strategies:
  [21:25:31.299] 1. sequential:
  [21:25:31.299]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.299]    - tweaked: FALSE
  [21:25:31.299]    - call: NULL
  [21:25:31.300] plan(): nbrOfWorkers() = 1
  [21:25:31.301] plan(): Setting new future strategy stack:
  [21:25:31.301] List of future strategies:
  [21:25:31.301] 1. sequential:
  [21:25:31.301]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.301]    - tweaked: FALSE
  [21:25:31.301]    - call: plan(strategy)
  [21:25:31.318] plan(): nbrOfWorkers() = 1
  [21:25:31.319] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ef21020f18> 
  Classes 'listenv', 'environment' <environment: 0x55ef20f02100> 
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [21:25:31.331] resolve() on list environment ...
  [21:25:31.331]  recursive: 0
  [21:25:31.333]  length: 6
  [21:25:31.350]  elements: 'a', 'b', 'c', 'd', '', ''
  [21:25:31.350] signalConditionsASAP(numeric, pos=1) ...
  [21:25:31.351] - nx: 6
  [21:25:31.351] - relay: TRUE
  [21:25:31.351] - stdout: TRUE
  [21:25:31.351] - signal: TRUE
  [21:25:31.352] - resignal: FALSE
  [21:25:31.352] - force: TRUE
  [21:25:31.352] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.352] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.353]  - until=2
  [21:25:31.353]  - relaying element #2
  [21:25:31.353] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.354] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.354] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:31.354]  length: 5 (resolved future 1)
  [21:25:31.355] Future #2
  [21:25:31.355] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:31.355] - nx: 6
  [21:25:31.355] - relay: TRUE
  [21:25:31.356] - stdout: TRUE
  [21:25:31.356] - signal: TRUE
  [21:25:31.356] - resignal: FALSE
  [21:25:31.356] - force: TRUE
  [21:25:31.357] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.357] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.357]  - until=2
  [21:25:31.358]  - relaying element #2
  [21:25:31.358] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.358] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.359] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:31.359]  length: 4 (resolved future 2)
  [21:25:31.359] Future #3
  [21:25:31.360] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:31.360] - nx: 6
  [21:25:31.360] - relay: TRUE
  [21:25:31.360] - stdout: TRUE
  [21:25:31.361] - signal: TRUE
  [21:25:31.361] - resignal: FALSE
  [21:25:31.361] - force: TRUE
  [21:25:31.361] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.362] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.362]  - until=3
  [21:25:31.362]  - relaying element #3
  [21:25:31.363] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.363] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.363] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:31.364]  length: 3 (resolved future 3)
  [21:25:31.364] Future #4
  [21:25:31.364] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:31.365] - nx: 6
  [21:25:31.365] - relay: TRUE
  [21:25:31.365] - stdout: TRUE
  [21:25:31.365] - signal: TRUE
  [21:25:31.365] - resignal: FALSE
  [21:25:31.391] - force: TRUE
  [21:25:31.391] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.391] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.392]  - until=4
  [21:25:31.392]  - relaying element #4
  [21:25:31.392] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.392] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.393] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:31.393]  length: 2 (resolved future 4)
  [21:25:31.393] signalConditionsASAP(NULL, pos=5) ...
  [21:25:31.393] - nx: 6
  [21:25:31.394] - relay: TRUE
  [21:25:31.394] - stdout: TRUE
  [21:25:31.394] - signal: TRUE
  [21:25:31.394] - resignal: FALSE
  [21:25:31.395] - force: TRUE
  [21:25:31.395] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.395] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.395]  - until=6
  [21:25:31.395]  - relaying element #6
  [21:25:31.396] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.396] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.396] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:31.396]  length: 1 (resolved future 5)
  [21:25:31.397] signalConditionsASAP(numeric, pos=6) ...
  [21:25:31.397] - nx: 6
  [21:25:31.397] - relay: TRUE
  [21:25:31.397] - stdout: TRUE
  [21:25:31.397] - signal: TRUE
  [21:25:31.398] - resignal: FALSE
  [21:25:31.398] - force: TRUE
  [21:25:31.398] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.398] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.399]  - until=6
  [21:25:31.399] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.399] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.399] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:31.400]  length: 0 (resolved future 6)
  [21:25:31.400] Relaying remaining futures
  [21:25:31.400] signalConditionsASAP(NULL, pos=0) ...
  [21:25:31.401] - nx: 6
  [21:25:31.401] - relay: TRUE
  [21:25:31.401] - stdout: TRUE
  [21:25:31.401] - signal: TRUE
  [21:25:31.402] - resignal: FALSE
  [21:25:31.402] - force: TRUE
  [21:25:31.402] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.402] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [21:25:31.403] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.403] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.403] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:31.404] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ef21001c40> 
  Dimensions: c(1, 6)
  [21:25:31.406] getGlobalsAndPackages() ...
  [21:25:31.406] Searching for globals...
  [21:25:31.407] 
  [21:25:31.407] Searching for globals ... DONE
  [21:25:31.407] - globals: [0] <none>
  [21:25:31.407] getGlobalsAndPackages() ... DONE
  [21:25:31.413] Packages needed by the future expression (n = 0): <none>
  [21:25:31.413] Packages needed by future strategies (n = 0): <none>
  [21:25:31.441] {
  [21:25:31.441]     {
  [21:25:31.441]         ...future.startTime <- base::Sys.time()
  [21:25:31.441]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.441]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.441]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.441]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.441]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.441]         {
  [21:25:31.441]             {
  [21:25:31.441]                 base::local({
  [21:25:31.441]                   has_future <- base::requireNamespace("future", 
  [21:25:31.441]                     quietly = TRUE)
  [21:25:31.441]                   version <- if (has_future) 
  [21:25:31.441]                     utils::packageVersion("future")
  [21:25:31.441]                   else NULL
  [21:25:31.441]                   if (!has_future || version < "1.8.0") {
  [21:25:31.441]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.441]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.441]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.441]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.441]                         "release", "version")], collapse = " "), 
  [21:25:31.441]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.441]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.441]                       info)
  [21:25:31.441]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.441]                     if (!has_future) {
  [21:25:31.441]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.441]                         info)
  [21:25:31.441]                     }
  [21:25:31.441]                     else {
  [21:25:31.441]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.441]                         info, version)
  [21:25:31.441]                     }
  [21:25:31.441]                     base::stop(msg)
  [21:25:31.441]                   }
  [21:25:31.441]                 })
  [21:25:31.441]             }
  [21:25:31.441]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.441]         }
  [21:25:31.441]     }
  [21:25:31.441]     if (base::is.na(TRUE)) {
  [21:25:31.441]     }
  [21:25:31.441]     else {
  [21:25:31.441]         if (TRUE) {
  [21:25:31.441]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.441]                 open = "w")
  [21:25:31.441]         }
  [21:25:31.441]         else {
  [21:25:31.441]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.441]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.441]         }
  [21:25:31.441]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.441]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.441]             base::sink(type = "output", split = FALSE)
  [21:25:31.441]             base::close(...future.stdout)
  [21:25:31.441]         }, add = TRUE)
  [21:25:31.441]     }
  [21:25:31.441]     ...future.frame <- base::sys.nframe()
  [21:25:31.441]     ...future.conditions <- base::list()
  [21:25:31.441]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.441]     ...future.result <- base::tryCatch({
  [21:25:31.441]         base::withCallingHandlers({
  [21:25:31.441]             ...future.value <- base::withVisible(base::local(2))
  [21:25:31.441]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.441]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.441]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.441]                 version = "1.8")
  [21:25:31.441]         }, condition = base::local({
  [21:25:31.441]             c <- base::c
  [21:25:31.441]             inherits <- base::inherits
  [21:25:31.441]             invokeRestart <- base::invokeRestart
  [21:25:31.441]             length <- base::length
  [21:25:31.441]             list <- base::list
  [21:25:31.441]             seq.int <- base::seq.int
  [21:25:31.441]             signalCondition <- base::signalCondition
  [21:25:31.441]             sys.calls <- base::sys.calls
  [21:25:31.441]             Sys.time <- base::Sys.time
  [21:25:31.441]             `[[` <- base::`[[`
  [21:25:31.441]             `+` <- base::`+`
  [21:25:31.441]             `<<-` <- base::`<<-`
  [21:25:31.441]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.441]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.441]                   3L)]
  [21:25:31.441]             }
  [21:25:31.441]             function(cond) {
  [21:25:31.441]                 if (inherits(cond, "error")) {
  [21:25:31.441]                   sessionInformation <- function() {
  [21:25:31.441]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.441]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.441]                       search = base::search(), system = base::Sys.info())
  [21:25:31.441]                   }
  [21:25:31.441]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.441]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.441]                     cond$call), session = sessionInformation(), 
  [21:25:31.441]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.441]                   signalCondition(cond)
  [21:25:31.441]                 }
  [21:25:31.441]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.441]                 ))) {
  [21:25:31.441]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.441]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.441]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.441]                   if (!signal) {
  [21:25:31.441]                     muffleCondition <- function (cond) 
  [21:25:31.441]                     {
  [21:25:31.441]                       inherits <- base::inherits
  [21:25:31.441]                       invokeRestart <- base::invokeRestart
  [21:25:31.441]                       muffled <- FALSE
  [21:25:31.441]                       if (inherits(cond, "message")) {
  [21:25:31.441]                         invokeRestart("muffleMessage")
  [21:25:31.441]                         muffled <- TRUE
  [21:25:31.441]                       }
  [21:25:31.441]                       else if (inherits(cond, "warning")) {
  [21:25:31.441]                         invokeRestart("muffleWarning")
  [21:25:31.441]                         muffled <- TRUE
  [21:25:31.441]                       }
  [21:25:31.441]                       else if (inherits(cond, "condition")) {
  [21:25:31.441]                         computeRestarts <- base::computeRestarts
  [21:25:31.441]                         grepl <- base::grepl
  [21:25:31.441]                         is.null <- base::is.null
  [21:25:31.441]                         restarts <- computeRestarts(cond)
  [21:25:31.441]                         for (restart in restarts) {
  [21:25:31.441]                           name <- restart$name
  [21:25:31.441]                           if (is.null(name)) 
  [21:25:31.441]                             next
  [21:25:31.441]                           if (!grepl("^muffle", name)) 
  [21:25:31.441]                             next
  [21:25:31.441]                           invokeRestart(restart)
  [21:25:31.441]                           muffled <- TRUE
  [21:25:31.441]                           break
  [21:25:31.441]                         }
  [21:25:31.441]                       }
  [21:25:31.441]                       invisible(muffled)
  [21:25:31.441]                     }
  [21:25:31.441]                     muffleCondition(cond)
  [21:25:31.441]                   }
  [21:25:31.441]                 }
  [21:25:31.441]             }
  [21:25:31.441]         }))
  [21:25:31.441]     }, error = function(ex) {
  [21:25:31.441]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.441]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.441]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.441]     }, finally = {
  [21:25:31.441]         {
  [21:25:31.441]             NULL
  [21:25:31.441]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.441]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.441]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.441]                 label = NULL, ...) 
  [21:25:31.441]             {
  [21:25:31.441]                 if (substitute) 
  [21:25:31.441]                   expr <- substitute(expr)
  [21:25:31.441]                 local <- as.logical(local)
  [21:25:31.441]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.441]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.441]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.441]                   label = label, ...)
  [21:25:31.441]                 if (!future$lazy) 
  [21:25:31.441]                   future <- run(future)
  [21:25:31.441]                 invisible(future)
  [21:25:31.441]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.441]         }
  [21:25:31.441]         base::options(...future.oldOptions)
  [21:25:31.441]     })
  [21:25:31.441]     Sys.time
  [21:25:31.441]     if (base::is.na(TRUE)) {
  [21:25:31.441]     }
  [21:25:31.441]     else {
  [21:25:31.441]         base::sink(type = "output", split = FALSE)
  [21:25:31.441]         if (TRUE) {
  [21:25:31.441]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.441]         }
  [21:25:31.441]         else {
  [21:25:31.441]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.441]         }
  [21:25:31.441]         base::close(...future.stdout)
  [21:25:31.441]         ...future.stdout <- NULL
  [21:25:31.441]     }
  [21:25:31.441]     ...future.result$conditions <- ...future.conditions
  [21:25:31.441]     ...future.result
  [21:25:31.441] }
  [21:25:31.446] plan(): Setting new future strategy stack:
  [21:25:31.446] List of future strategies:
  [21:25:31.446] 1. sequential:
  [21:25:31.446]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.446]    - tweaked: FALSE
  [21:25:31.446]    - call: NULL
  [21:25:31.447] plan(): nbrOfWorkers() = 1
  [21:25:31.448] plan(): Setting new future strategy stack:
  [21:25:31.448] List of future strategies:
  [21:25:31.448] 1. sequential:
  [21:25:31.448]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.448]    - tweaked: FALSE
  [21:25:31.448]    - call: plan(strategy)
  [21:25:31.449] plan(): nbrOfWorkers() = 1
  [21:25:31.450] SequentialFuture started (and completed)
  [21:25:31.450] getGlobalsAndPackages() ...
  [21:25:31.450] Searching for globals...
  [21:25:31.451] 
  [21:25:31.451] Searching for globals ... DONE
  [21:25:31.452] - globals: [0] <none>
  [21:25:31.452] getGlobalsAndPackages() ... DONE
  [21:25:31.453] Packages needed by the future expression (n = 0): <none>
  [21:25:31.454] Packages needed by future strategies (n = 0): <none>
  [21:25:31.478] {
  [21:25:31.478]     {
  [21:25:31.478]         ...future.startTime <- base::Sys.time()
  [21:25:31.478]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.478]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.478]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.478]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.478]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.478]         {
  [21:25:31.478]             {
  [21:25:31.478]                 base::local({
  [21:25:31.478]                   has_future <- base::requireNamespace("future", 
  [21:25:31.478]                     quietly = TRUE)
  [21:25:31.478]                   version <- if (has_future) 
  [21:25:31.478]                     utils::packageVersion("future")
  [21:25:31.478]                   else NULL
  [21:25:31.478]                   if (!has_future || version < "1.8.0") {
  [21:25:31.478]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.478]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.478]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.478]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.478]                         "release", "version")], collapse = " "), 
  [21:25:31.478]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.478]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.478]                       info)
  [21:25:31.478]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.478]                     if (!has_future) {
  [21:25:31.478]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.478]                         info)
  [21:25:31.478]                     }
  [21:25:31.478]                     else {
  [21:25:31.478]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.478]                         info, version)
  [21:25:31.478]                     }
  [21:25:31.478]                     base::stop(msg)
  [21:25:31.478]                   }
  [21:25:31.478]                 })
  [21:25:31.478]             }
  [21:25:31.478]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.478]         }
  [21:25:31.478]     }
  [21:25:31.478]     if (base::is.na(TRUE)) {
  [21:25:31.478]     }
  [21:25:31.478]     else {
  [21:25:31.478]         if (TRUE) {
  [21:25:31.478]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.478]                 open = "w")
  [21:25:31.478]         }
  [21:25:31.478]         else {
  [21:25:31.478]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.478]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.478]         }
  [21:25:31.478]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.478]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.478]             base::sink(type = "output", split = FALSE)
  [21:25:31.478]             base::close(...future.stdout)
  [21:25:31.478]         }, add = TRUE)
  [21:25:31.478]     }
  [21:25:31.478]     ...future.frame <- base::sys.nframe()
  [21:25:31.478]     ...future.conditions <- base::list()
  [21:25:31.478]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.478]     ...future.result <- base::tryCatch({
  [21:25:31.478]         base::withCallingHandlers({
  [21:25:31.478]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:31.478]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.478]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.478]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.478]                 version = "1.8")
  [21:25:31.478]         }, condition = base::local({
  [21:25:31.478]             c <- base::c
  [21:25:31.478]             inherits <- base::inherits
  [21:25:31.478]             invokeRestart <- base::invokeRestart
  [21:25:31.478]             length <- base::length
  [21:25:31.478]             list <- base::list
  [21:25:31.478]             seq.int <- base::seq.int
  [21:25:31.478]             signalCondition <- base::signalCondition
  [21:25:31.478]             sys.calls <- base::sys.calls
  [21:25:31.478]             Sys.time <- base::Sys.time
  [21:25:31.478]             `[[` <- base::`[[`
  [21:25:31.478]             `+` <- base::`+`
  [21:25:31.478]             `<<-` <- base::`<<-`
  [21:25:31.478]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.478]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.478]                   3L)]
  [21:25:31.478]             }
  [21:25:31.478]             function(cond) {
  [21:25:31.478]                 if (inherits(cond, "error")) {
  [21:25:31.478]                   sessionInformation <- function() {
  [21:25:31.478]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.478]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.478]                       search = base::search(), system = base::Sys.info())
  [21:25:31.478]                   }
  [21:25:31.478]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.478]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.478]                     cond$call), session = sessionInformation(), 
  [21:25:31.478]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.478]                   signalCondition(cond)
  [21:25:31.478]                 }
  [21:25:31.478]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.478]                 ))) {
  [21:25:31.478]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.478]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.478]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.478]                   if (!signal) {
  [21:25:31.478]                     muffleCondition <- function (cond) 
  [21:25:31.478]                     {
  [21:25:31.478]                       inherits <- base::inherits
  [21:25:31.478]                       invokeRestart <- base::invokeRestart
  [21:25:31.478]                       muffled <- FALSE
  [21:25:31.478]                       if (inherits(cond, "message")) {
  [21:25:31.478]                         invokeRestart("muffleMessage")
  [21:25:31.478]                         muffled <- TRUE
  [21:25:31.478]                       }
  [21:25:31.478]                       else if (inherits(cond, "warning")) {
  [21:25:31.478]                         invokeRestart("muffleWarning")
  [21:25:31.478]                         muffled <- TRUE
  [21:25:31.478]                       }
  [21:25:31.478]                       else if (inherits(cond, "condition")) {
  [21:25:31.478]                         computeRestarts <- base::computeRestarts
  [21:25:31.478]                         grepl <- base::grepl
  [21:25:31.478]                         is.null <- base::is.null
  [21:25:31.478]                         restarts <- computeRestarts(cond)
  [21:25:31.478]                         for (restart in restarts) {
  [21:25:31.478]                           name <- restart$name
  [21:25:31.478]                           if (is.null(name)) 
  [21:25:31.478]                             next
  [21:25:31.478]                           if (!grepl("^muffle", name)) 
  [21:25:31.478]                             next
  [21:25:31.478]                           invokeRestart(restart)
  [21:25:31.478]                           muffled <- TRUE
  [21:25:31.478]                           break
  [21:25:31.478]                         }
  [21:25:31.478]                       }
  [21:25:31.478]                       invisible(muffled)
  [21:25:31.478]                     }
  [21:25:31.478]                     muffleCondition(cond)
  [21:25:31.478]                   }
  [21:25:31.478]                 }
  [21:25:31.478]             }
  [21:25:31.478]         }))
  [21:25:31.478]     }, error = function(ex) {
  [21:25:31.478]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.478]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.478]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.478]     }, finally = {
  [21:25:31.478]         {
  [21:25:31.478]             NULL
  [21:25:31.478]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.478]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.478]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.478]                 label = NULL, ...) 
  [21:25:31.478]             {
  [21:25:31.478]                 if (substitute) 
  [21:25:31.478]                   expr <- substitute(expr)
  [21:25:31.478]                 local <- as.logical(local)
  [21:25:31.478]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.478]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.478]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.478]                   label = label, ...)
  [21:25:31.478]                 if (!future$lazy) 
  [21:25:31.478]                   future <- run(future)
  [21:25:31.478]                 invisible(future)
  [21:25:31.478]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.478]         }
  [21:25:31.478]         base::options(...future.oldOptions)
  [21:25:31.478]     })
  [21:25:31.478]     Sys.time
  [21:25:31.478]     if (base::is.na(TRUE)) {
  [21:25:31.478]     }
  [21:25:31.478]     else {
  [21:25:31.478]         base::sink(type = "output", split = FALSE)
  [21:25:31.478]         if (TRUE) {
  [21:25:31.478]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.478]         }
  [21:25:31.478]         else {
  [21:25:31.478]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.478]         }
  [21:25:31.478]         base::close(...future.stdout)
  [21:25:31.478]         ...future.stdout <- NULL
  [21:25:31.478]     }
  [21:25:31.478]     ...future.result$conditions <- ...future.conditions
  [21:25:31.478]     ...future.result
  [21:25:31.478] }
  [21:25:31.483] plan(): Setting new future strategy stack:
  [21:25:31.483] List of future strategies:
  [21:25:31.483] 1. sequential:
  [21:25:31.483]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.483]    - tweaked: FALSE
  [21:25:31.483]    - call: NULL
  [21:25:31.484] plan(): nbrOfWorkers() = 1
  [21:25:31.485] plan(): Setting new future strategy stack:
  [21:25:31.485] List of future strategies:
  [21:25:31.485] 1. sequential:
  [21:25:31.485]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.485]    - tweaked: FALSE
  [21:25:31.485]    - call: plan(strategy)
  [21:25:31.486] plan(): nbrOfWorkers() = 1
  [21:25:31.486] SequentialFuture started (and completed)
  [21:25:31.496] getGlobalsAndPackages() ...
  [21:25:31.496] Searching for globals...
  [21:25:31.497] - globals found: [1] '{'
  [21:25:31.498] Searching for globals ... DONE
  [21:25:31.498] Resolving globals: FALSE
  [21:25:31.499] 
  [21:25:31.499] 
  [21:25:31.499] getGlobalsAndPackages() ... DONE
  [21:25:31.501] Packages needed by the future expression (n = 0): <none>
  [21:25:31.501] Packages needed by future strategies (n = 0): <none>
  [21:25:31.544] {
  [21:25:31.544]     {
  [21:25:31.544]         ...future.startTime <- base::Sys.time()
  [21:25:31.544]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.544]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.544]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.544]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.544]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.544]         {
  [21:25:31.544]             {
  [21:25:31.544]                 base::local({
  [21:25:31.544]                   has_future <- base::requireNamespace("future", 
  [21:25:31.544]                     quietly = TRUE)
  [21:25:31.544]                   version <- if (has_future) 
  [21:25:31.544]                     utils::packageVersion("future")
  [21:25:31.544]                   else NULL
  [21:25:31.544]                   if (!has_future || version < "1.8.0") {
  [21:25:31.544]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.544]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.544]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.544]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.544]                         "release", "version")], collapse = " "), 
  [21:25:31.544]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.544]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.544]                       info)
  [21:25:31.544]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.544]                     if (!has_future) {
  [21:25:31.544]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.544]                         info)
  [21:25:31.544]                     }
  [21:25:31.544]                     else {
  [21:25:31.544]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.544]                         info, version)
  [21:25:31.544]                     }
  [21:25:31.544]                     base::stop(msg)
  [21:25:31.544]                   }
  [21:25:31.544]                 })
  [21:25:31.544]             }
  [21:25:31.544]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.544]         }
  [21:25:31.544]     }
  [21:25:31.544]     if (base::is.na(TRUE)) {
  [21:25:31.544]     }
  [21:25:31.544]     else {
  [21:25:31.544]         if (TRUE) {
  [21:25:31.544]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.544]                 open = "w")
  [21:25:31.544]         }
  [21:25:31.544]         else {
  [21:25:31.544]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.544]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.544]         }
  [21:25:31.544]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.544]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.544]             base::sink(type = "output", split = FALSE)
  [21:25:31.544]             base::close(...future.stdout)
  [21:25:31.544]         }, add = TRUE)
  [21:25:31.544]     }
  [21:25:31.544]     ...future.frame <- base::sys.nframe()
  [21:25:31.544]     ...future.conditions <- base::list()
  [21:25:31.544]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.544]     ...future.result <- base::tryCatch({
  [21:25:31.544]         base::withCallingHandlers({
  [21:25:31.544]             ...future.value <- base::withVisible(base::local({
  [21:25:31.544]                 4
  [21:25:31.544]             }))
  [21:25:31.544]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.544]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.544]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.544]                 version = "1.8")
  [21:25:31.544]         }, condition = base::local({
  [21:25:31.544]             c <- base::c
  [21:25:31.544]             inherits <- base::inherits
  [21:25:31.544]             invokeRestart <- base::invokeRestart
  [21:25:31.544]             length <- base::length
  [21:25:31.544]             list <- base::list
  [21:25:31.544]             seq.int <- base::seq.int
  [21:25:31.544]             signalCondition <- base::signalCondition
  [21:25:31.544]             sys.calls <- base::sys.calls
  [21:25:31.544]             Sys.time <- base::Sys.time
  [21:25:31.544]             `[[` <- base::`[[`
  [21:25:31.544]             `+` <- base::`+`
  [21:25:31.544]             `<<-` <- base::`<<-`
  [21:25:31.544]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.544]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.544]                   3L)]
  [21:25:31.544]             }
  [21:25:31.544]             function(cond) {
  [21:25:31.544]                 if (inherits(cond, "error")) {
  [21:25:31.544]                   sessionInformation <- function() {
  [21:25:31.544]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.544]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.544]                       search = base::search(), system = base::Sys.info())
  [21:25:31.544]                   }
  [21:25:31.544]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.544]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.544]                     cond$call), session = sessionInformation(), 
  [21:25:31.544]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.544]                   signalCondition(cond)
  [21:25:31.544]                 }
  [21:25:31.544]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.544]                 ))) {
  [21:25:31.544]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.544]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.544]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.544]                   if (!signal) {
  [21:25:31.544]                     muffleCondition <- function (cond) 
  [21:25:31.544]                     {
  [21:25:31.544]                       inherits <- base::inherits
  [21:25:31.544]                       invokeRestart <- base::invokeRestart
  [21:25:31.544]                       muffled <- FALSE
  [21:25:31.544]                       if (inherits(cond, "message")) {
  [21:25:31.544]                         invokeRestart("muffleMessage")
  [21:25:31.544]                         muffled <- TRUE
  [21:25:31.544]                       }
  [21:25:31.544]                       else if (inherits(cond, "warning")) {
  [21:25:31.544]                         invokeRestart("muffleWarning")
  [21:25:31.544]                         muffled <- TRUE
  [21:25:31.544]                       }
  [21:25:31.544]                       else if (inherits(cond, "condition")) {
  [21:25:31.544]                         computeRestarts <- base::computeRestarts
  [21:25:31.544]                         grepl <- base::grepl
  [21:25:31.544]                         is.null <- base::is.null
  [21:25:31.544]                         restarts <- computeRestarts(cond)
  [21:25:31.544]                         for (restart in restarts) {
  [21:25:31.544]                           name <- restart$name
  [21:25:31.544]                           if (is.null(name)) 
  [21:25:31.544]                             next
  [21:25:31.544]                           if (!grepl("^muffle", name)) 
  [21:25:31.544]                             next
  [21:25:31.544]                           invokeRestart(restart)
  [21:25:31.544]                           muffled <- TRUE
  [21:25:31.544]                           break
  [21:25:31.544]                         }
  [21:25:31.544]                       }
  [21:25:31.544]                       invisible(muffled)
  [21:25:31.544]                     }
  [21:25:31.544]                     muffleCondition(cond)
  [21:25:31.544]                   }
  [21:25:31.544]                 }
  [21:25:31.544]             }
  [21:25:31.544]         }))
  [21:25:31.544]     }, error = function(ex) {
  [21:25:31.544]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.544]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.544]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.544]     }, finally = {
  [21:25:31.544]         {
  [21:25:31.544]             NULL
  [21:25:31.544]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.544]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.544]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.544]                 label = NULL, ...) 
  [21:25:31.544]             {
  [21:25:31.544]                 if (substitute) 
  [21:25:31.544]                   expr <- substitute(expr)
  [21:25:31.544]                 local <- as.logical(local)
  [21:25:31.544]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.544]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.544]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.544]                   label = label, ...)
  [21:25:31.544]                 if (!future$lazy) 
  [21:25:31.544]                   future <- run(future)
  [21:25:31.544]                 invisible(future)
  [21:25:31.544]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.544]         }
  [21:25:31.544]         base::options(...future.oldOptions)
  [21:25:31.544]     })
  [21:25:31.544]     Sys.time
  [21:25:31.544]     if (base::is.na(TRUE)) {
  [21:25:31.544]     }
  [21:25:31.544]     else {
  [21:25:31.544]         base::sink(type = "output", split = FALSE)
  [21:25:31.544]         if (TRUE) {
  [21:25:31.544]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.544]         }
  [21:25:31.544]         else {
  [21:25:31.544]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.544]         }
  [21:25:31.544]         base::close(...future.stdout)
  [21:25:31.544]         ...future.stdout <- NULL
  [21:25:31.544]     }
  [21:25:31.544]     ...future.result$conditions <- ...future.conditions
  [21:25:31.544]     ...future.result
  [21:25:31.544] }
  [21:25:31.549] plan(): Setting new future strategy stack:
  [21:25:31.549] List of future strategies:
  [21:25:31.549] 1. sequential:
  [21:25:31.549]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.549]    - tweaked: FALSE
  [21:25:31.549]    - call: NULL
  [21:25:31.550] plan(): nbrOfWorkers() = 1
  [21:25:31.551] plan(): Setting new future strategy stack:
  [21:25:31.551] List of future strategies:
  [21:25:31.551] 1. sequential:
  [21:25:31.551]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.551]    - tweaked: FALSE
  [21:25:31.551]    - call: plan(strategy)
  [21:25:31.552] plan(): nbrOfWorkers() = 1
  [21:25:31.553] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ef22af3630> 
  Classes 'listenv', 'environment' <environment: 0x55ef20918088> 
   - attr(*, "dim.")= int [1:2] 1 6
   - attr(*, "dimnames.")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
   logi [1, 1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [21:25:31.588] resolve() on list environment ...
  [21:25:31.588]  recursive: 0
  [21:25:31.596]  length: 6
  [21:25:31.597]  elements: 'a', 'b', 'c', 'd', '', ''
  [21:25:31.597] signalConditionsASAP(numeric, pos=1) ...
  [21:25:31.597] - nx: 6
  [21:25:31.598] - relay: TRUE
  [21:25:31.598] - stdout: TRUE
  [21:25:31.598] - signal: TRUE
  [21:25:31.598] - resignal: FALSE
  [21:25:31.599] - force: TRUE
  [21:25:31.599] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.599] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.599]  - until=2
  [21:25:31.600]  - relaying element #2
  [21:25:31.600] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.600] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.601] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:31.601]  length: 5 (resolved future 1)
  [21:25:31.601] Future #2
  [21:25:31.602] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:31.602] - nx: 6
  [21:25:31.602] - relay: TRUE
  [21:25:31.622] - stdout: TRUE
  [21:25:31.622] - signal: TRUE
  [21:25:31.622] - resignal: FALSE
  [21:25:31.623] - force: TRUE
  [21:25:31.623] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.624] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.624]  - until=2
  [21:25:31.624]  - relaying element #2
  [21:25:31.625] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.625] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.625] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:31.625]  length: 4 (resolved future 2)
  [21:25:31.626] Future #3
  [21:25:31.626] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:31.626] - nx: 6
  [21:25:31.627] - relay: TRUE
  [21:25:31.627] - stdout: TRUE
  [21:25:31.627] - signal: TRUE
  [21:25:31.627] - resignal: FALSE
  [21:25:31.628] - force: TRUE
  [21:25:31.628] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.628] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.629]  - until=3
  [21:25:31.629]  - relaying element #3
  [21:25:31.630] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.640] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.641] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:31.641]  length: 3 (resolved future 3)
  [21:25:31.641] Future #4
  [21:25:31.642] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:31.642] - nx: 6
  [21:25:31.642] - relay: TRUE
  [21:25:31.643] - stdout: TRUE
  [21:25:31.643] - signal: TRUE
  [21:25:31.643] - resignal: FALSE
  [21:25:31.643] - force: TRUE
  [21:25:31.644] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.644] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.644]  - until=4
  [21:25:31.644]  - relaying element #4
  [21:25:31.645] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.645] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.645] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:31.646]  length: 2 (resolved future 4)
  [21:25:31.646] signalConditionsASAP(NULL, pos=5) ...
  [21:25:31.646] - nx: 6
  [21:25:31.647] - relay: TRUE
  [21:25:31.647] - stdout: TRUE
  [21:25:31.647] - signal: TRUE
  [21:25:31.647] - resignal: FALSE
  [21:25:31.648] - force: TRUE
  [21:25:31.648] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.648] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.648]  - until=6
  [21:25:31.649]  - relaying element #6
  [21:25:31.649] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.649] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.650] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:31.650]  length: 1 (resolved future 5)
  [21:25:31.650] signalConditionsASAP(numeric, pos=6) ...
  [21:25:31.650] - nx: 6
  [21:25:31.651] - relay: TRUE
  [21:25:31.651] - stdout: TRUE
  [21:25:31.670] - signal: TRUE
  [21:25:31.670] - resignal: FALSE
  [21:25:31.670] - force: TRUE
  [21:25:31.671] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.671] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.671]  - until=6
  [21:25:31.672] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.672] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.672] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:31.672]  length: 0 (resolved future 6)
  [21:25:31.673] Relaying remaining futures
  [21:25:31.673] signalConditionsASAP(NULL, pos=0) ...
  [21:25:31.673] - nx: 6
  [21:25:31.673] - relay: TRUE
  [21:25:31.674] - stdout: TRUE
  [21:25:31.674] - signal: TRUE
  [21:25:31.674] - resignal: FALSE
  [21:25:31.674] - force: TRUE
  [21:25:31.675] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.675] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [21:25:31.675] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.676] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.676] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:31.676] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ef21a0eb18> 
   - attr(*, "dim.")= int [1:2] 1 6
   - attr(*, "dimnames.")=List of 2
    ..$ : chr "a"
    ..$ : chr [1:6] "a" "b" "c" "d" ...
  Dimensions: c(2, 3)
  [21:25:31.681] getGlobalsAndPackages() ...
  [21:25:31.682] Searching for globals...
  [21:25:31.683] 
  [21:25:31.683] Searching for globals ... DONE
  [21:25:31.683] - globals: [0] <none>
  [21:25:31.703] getGlobalsAndPackages() ... DONE
  [21:25:31.705] Packages needed by the future expression (n = 0): <none>
  [21:25:31.705] Packages needed by future strategies (n = 0): <none>
  [21:25:31.710] {
  [21:25:31.710]     {
  [21:25:31.710]         ...future.startTime <- base::Sys.time()
  [21:25:31.710]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.710]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.710]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.710]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.710]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.710]         {
  [21:25:31.710]             {
  [21:25:31.710]                 base::local({
  [21:25:31.710]                   has_future <- base::requireNamespace("future", 
  [21:25:31.710]                     quietly = TRUE)
  [21:25:31.710]                   version <- if (has_future) 
  [21:25:31.710]                     utils::packageVersion("future")
  [21:25:31.710]                   else NULL
  [21:25:31.710]                   if (!has_future || version < "1.8.0") {
  [21:25:31.710]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.710]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.710]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.710]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.710]                         "release", "version")], collapse = " "), 
  [21:25:31.710]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.710]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.710]                       info)
  [21:25:31.710]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.710]                     if (!has_future) {
  [21:25:31.710]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.710]                         info)
  [21:25:31.710]                     }
  [21:25:31.710]                     else {
  [21:25:31.710]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.710]                         info, version)
  [21:25:31.710]                     }
  [21:25:31.710]                     base::stop(msg)
  [21:25:31.710]                   }
  [21:25:31.710]                 })
  [21:25:31.710]             }
  [21:25:31.710]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.710]         }
  [21:25:31.710]     }
  [21:25:31.710]     if (base::is.na(TRUE)) {
  [21:25:31.710]     }
  [21:25:31.710]     else {
  [21:25:31.710]         if (TRUE) {
  [21:25:31.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.710]                 open = "w")
  [21:25:31.710]         }
  [21:25:31.710]         else {
  [21:25:31.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.710]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.710]         }
  [21:25:31.710]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.710]             base::sink(type = "output", split = FALSE)
  [21:25:31.710]             base::close(...future.stdout)
  [21:25:31.710]         }, add = TRUE)
  [21:25:31.710]     }
  [21:25:31.710]     ...future.frame <- base::sys.nframe()
  [21:25:31.710]     ...future.conditions <- base::list()
  [21:25:31.710]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.710]     ...future.result <- base::tryCatch({
  [21:25:31.710]         base::withCallingHandlers({
  [21:25:31.710]             ...future.value <- base::withVisible(base::local(2))
  [21:25:31.710]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.710]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.710]                 version = "1.8")
  [21:25:31.710]         }, condition = base::local({
  [21:25:31.710]             c <- base::c
  [21:25:31.710]             inherits <- base::inherits
  [21:25:31.710]             invokeRestart <- base::invokeRestart
  [21:25:31.710]             length <- base::length
  [21:25:31.710]             list <- base::list
  [21:25:31.710]             seq.int <- base::seq.int
  [21:25:31.710]             signalCondition <- base::signalCondition
  [21:25:31.710]             sys.calls <- base::sys.calls
  [21:25:31.710]             Sys.time <- base::Sys.time
  [21:25:31.710]             `[[` <- base::`[[`
  [21:25:31.710]             `+` <- base::`+`
  [21:25:31.710]             `<<-` <- base::`<<-`
  [21:25:31.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.710]                   3L)]
  [21:25:31.710]             }
  [21:25:31.710]             function(cond) {
  [21:25:31.710]                 if (inherits(cond, "error")) {
  [21:25:31.710]                   sessionInformation <- function() {
  [21:25:31.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.710]                       search = base::search(), system = base::Sys.info())
  [21:25:31.710]                   }
  [21:25:31.710]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.710]                     cond$call), session = sessionInformation(), 
  [21:25:31.710]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.710]                   signalCondition(cond)
  [21:25:31.710]                 }
  [21:25:31.710]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.710]                 ))) {
  [21:25:31.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.710]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.710]                   if (!signal) {
  [21:25:31.710]                     muffleCondition <- function (cond) 
  [21:25:31.710]                     {
  [21:25:31.710]                       inherits <- base::inherits
  [21:25:31.710]                       invokeRestart <- base::invokeRestart
  [21:25:31.710]                       muffled <- FALSE
  [21:25:31.710]                       if (inherits(cond, "message")) {
  [21:25:31.710]                         invokeRestart("muffleMessage")
  [21:25:31.710]                         muffled <- TRUE
  [21:25:31.710]                       }
  [21:25:31.710]                       else if (inherits(cond, "warning")) {
  [21:25:31.710]                         invokeRestart("muffleWarning")
  [21:25:31.710]                         muffled <- TRUE
  [21:25:31.710]                       }
  [21:25:31.710]                       else if (inherits(cond, "condition")) {
  [21:25:31.710]                         computeRestarts <- base::computeRestarts
  [21:25:31.710]                         grepl <- base::grepl
  [21:25:31.710]                         is.null <- base::is.null
  [21:25:31.710]                         restarts <- computeRestarts(cond)
  [21:25:31.710]                         for (restart in restarts) {
  [21:25:31.710]                           name <- restart$name
  [21:25:31.710]                           if (is.null(name)) 
  [21:25:31.710]                             next
  [21:25:31.710]                           if (!grepl("^muffle", name)) 
  [21:25:31.710]                             next
  [21:25:31.710]                           invokeRestart(restart)
  [21:25:31.710]                           muffled <- TRUE
  [21:25:31.710]                           break
  [21:25:31.710]                         }
  [21:25:31.710]                       }
  [21:25:31.710]                       invisible(muffled)
  [21:25:31.710]                     }
  [21:25:31.710]                     muffleCondition(cond)
  [21:25:31.710]                   }
  [21:25:31.710]                 }
  [21:25:31.710]             }
  [21:25:31.710]         }))
  [21:25:31.710]     }, error = function(ex) {
  [21:25:31.710]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.710]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.710]     }, finally = {
  [21:25:31.710]         {
  [21:25:31.710]             NULL
  [21:25:31.710]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.710]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.710]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.710]                 label = NULL, ...) 
  [21:25:31.710]             {
  [21:25:31.710]                 if (substitute) 
  [21:25:31.710]                   expr <- substitute(expr)
  [21:25:31.710]                 local <- as.logical(local)
  [21:25:31.710]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.710]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.710]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.710]                   label = label, ...)
  [21:25:31.710]                 if (!future$lazy) 
  [21:25:31.710]                   future <- run(future)
  [21:25:31.710]                 invisible(future)
  [21:25:31.710]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.710]         }
  [21:25:31.710]         base::options(...future.oldOptions)
  [21:25:31.710]     })
  [21:25:31.710]     Sys.time
  [21:25:31.710]     if (base::is.na(TRUE)) {
  [21:25:31.710]     }
  [21:25:31.710]     else {
  [21:25:31.710]         base::sink(type = "output", split = FALSE)
  [21:25:31.710]         if (TRUE) {
  [21:25:31.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.710]         }
  [21:25:31.710]         else {
  [21:25:31.710]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.710]         }
  [21:25:31.710]         base::close(...future.stdout)
  [21:25:31.710]         ...future.stdout <- NULL
  [21:25:31.710]     }
  [21:25:31.710]     ...future.result$conditions <- ...future.conditions
  [21:25:31.710]     ...future.result
  [21:25:31.710] }
  [21:25:31.715] plan(): Setting new future strategy stack:
  [21:25:31.715] List of future strategies:
  [21:25:31.715] 1. sequential:
  [21:25:31.715]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.715]    - tweaked: FALSE
  [21:25:31.715]    - call: NULL
  [21:25:31.716] plan(): nbrOfWorkers() = 1
  [21:25:31.717] plan(): Setting new future strategy stack:
  [21:25:31.717] List of future strategies:
  [21:25:31.717] 1. sequential:
  [21:25:31.717]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.717]    - tweaked: FALSE
  [21:25:31.717]    - call: plan(strategy)
  [21:25:31.734] plan(): nbrOfWorkers() = 1
  [21:25:31.735] SequentialFuture started (and completed)
  [21:25:31.735] getGlobalsAndPackages() ...
  [21:25:31.735] Searching for globals...
  [21:25:31.736] 
  [21:25:31.736] Searching for globals ... DONE
  [21:25:31.736] - globals: [0] <none>
  [21:25:31.737] getGlobalsAndPackages() ... DONE
  [21:25:31.738] Packages needed by the future expression (n = 0): <none>
  [21:25:31.738] Packages needed by future strategies (n = 0): <none>
  [21:25:31.742] {
  [21:25:31.742]     {
  [21:25:31.742]         ...future.startTime <- base::Sys.time()
  [21:25:31.742]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.742]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.742]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.742]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.742]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.742]         {
  [21:25:31.742]             {
  [21:25:31.742]                 base::local({
  [21:25:31.742]                   has_future <- base::requireNamespace("future", 
  [21:25:31.742]                     quietly = TRUE)
  [21:25:31.742]                   version <- if (has_future) 
  [21:25:31.742]                     utils::packageVersion("future")
  [21:25:31.742]                   else NULL
  [21:25:31.742]                   if (!has_future || version < "1.8.0") {
  [21:25:31.742]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.742]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.742]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.742]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.742]                         "release", "version")], collapse = " "), 
  [21:25:31.742]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.742]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.742]                       info)
  [21:25:31.742]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.742]                     if (!has_future) {
  [21:25:31.742]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.742]                         info)
  [21:25:31.742]                     }
  [21:25:31.742]                     else {
  [21:25:31.742]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.742]                         info, version)
  [21:25:31.742]                     }
  [21:25:31.742]                     base::stop(msg)
  [21:25:31.742]                   }
  [21:25:31.742]                 })
  [21:25:31.742]             }
  [21:25:31.742]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.742]         }
  [21:25:31.742]     }
  [21:25:31.742]     if (base::is.na(TRUE)) {
  [21:25:31.742]     }
  [21:25:31.742]     else {
  [21:25:31.742]         if (TRUE) {
  [21:25:31.742]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.742]                 open = "w")
  [21:25:31.742]         }
  [21:25:31.742]         else {
  [21:25:31.742]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.742]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.742]         }
  [21:25:31.742]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.742]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.742]             base::sink(type = "output", split = FALSE)
  [21:25:31.742]             base::close(...future.stdout)
  [21:25:31.742]         }, add = TRUE)
  [21:25:31.742]     }
  [21:25:31.742]     ...future.frame <- base::sys.nframe()
  [21:25:31.742]     ...future.conditions <- base::list()
  [21:25:31.742]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.742]     ...future.result <- base::tryCatch({
  [21:25:31.742]         base::withCallingHandlers({
  [21:25:31.742]             ...future.value <- base::withVisible(base::local(NULL))
  [21:25:31.742]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.742]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.742]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.742]                 version = "1.8")
  [21:25:31.742]         }, condition = base::local({
  [21:25:31.742]             c <- base::c
  [21:25:31.742]             inherits <- base::inherits
  [21:25:31.742]             invokeRestart <- base::invokeRestart
  [21:25:31.742]             length <- base::length
  [21:25:31.742]             list <- base::list
  [21:25:31.742]             seq.int <- base::seq.int
  [21:25:31.742]             signalCondition <- base::signalCondition
  [21:25:31.742]             sys.calls <- base::sys.calls
  [21:25:31.742]             Sys.time <- base::Sys.time
  [21:25:31.742]             `[[` <- base::`[[`
  [21:25:31.742]             `+` <- base::`+`
  [21:25:31.742]             `<<-` <- base::`<<-`
  [21:25:31.742]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.742]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.742]                   3L)]
  [21:25:31.742]             }
  [21:25:31.742]             function(cond) {
  [21:25:31.742]                 if (inherits(cond, "error")) {
  [21:25:31.742]                   sessionInformation <- function() {
  [21:25:31.742]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.742]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.742]                       search = base::search(), system = base::Sys.info())
  [21:25:31.742]                   }
  [21:25:31.742]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.742]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.742]                     cond$call), session = sessionInformation(), 
  [21:25:31.742]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.742]                   signalCondition(cond)
  [21:25:31.742]                 }
  [21:25:31.742]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.742]                 ))) {
  [21:25:31.742]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.742]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.742]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.742]                   if (!signal) {
  [21:25:31.742]                     muffleCondition <- function (cond) 
  [21:25:31.742]                     {
  [21:25:31.742]                       inherits <- base::inherits
  [21:25:31.742]                       invokeRestart <- base::invokeRestart
  [21:25:31.742]                       muffled <- FALSE
  [21:25:31.742]                       if (inherits(cond, "message")) {
  [21:25:31.742]                         invokeRestart("muffleMessage")
  [21:25:31.742]                         muffled <- TRUE
  [21:25:31.742]                       }
  [21:25:31.742]                       else if (inherits(cond, "warning")) {
  [21:25:31.742]                         invokeRestart("muffleWarning")
  [21:25:31.742]                         muffled <- TRUE
  [21:25:31.742]                       }
  [21:25:31.742]                       else if (inherits(cond, "condition")) {
  [21:25:31.742]                         computeRestarts <- base::computeRestarts
  [21:25:31.742]                         grepl <- base::grepl
  [21:25:31.742]                         is.null <- base::is.null
  [21:25:31.742]                         restarts <- computeRestarts(cond)
  [21:25:31.742]                         for (restart in restarts) {
  [21:25:31.742]                           name <- restart$name
  [21:25:31.742]                           if (is.null(name)) 
  [21:25:31.742]                             next
  [21:25:31.742]                           if (!grepl("^muffle", name)) 
  [21:25:31.742]                             next
  [21:25:31.742]                           invokeRestart(restart)
  [21:25:31.742]                           muffled <- TRUE
  [21:25:31.742]                           break
  [21:25:31.742]                         }
  [21:25:31.742]                       }
  [21:25:31.742]                       invisible(muffled)
  [21:25:31.742]                     }
  [21:25:31.742]                     muffleCondition(cond)
  [21:25:31.742]                   }
  [21:25:31.742]                 }
  [21:25:31.742]             }
  [21:25:31.742]         }))
  [21:25:31.742]     }, error = function(ex) {
  [21:25:31.742]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.742]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.742]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.742]     }, finally = {
  [21:25:31.742]         {
  [21:25:31.742]             NULL
  [21:25:31.742]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.742]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.742]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.742]                 label = NULL, ...) 
  [21:25:31.742]             {
  [21:25:31.742]                 if (substitute) 
  [21:25:31.742]                   expr <- substitute(expr)
  [21:25:31.742]                 local <- as.logical(local)
  [21:25:31.742]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.742]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.742]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.742]                   label = label, ...)
  [21:25:31.742]                 if (!future$lazy) 
  [21:25:31.742]                   future <- run(future)
  [21:25:31.742]                 invisible(future)
  [21:25:31.742]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.742]         }
  [21:25:31.742]         base::options(...future.oldOptions)
  [21:25:31.742]     })
  [21:25:31.742]     Sys.time
  [21:25:31.742]     if (base::is.na(TRUE)) {
  [21:25:31.742]     }
  [21:25:31.742]     else {
  [21:25:31.742]         base::sink(type = "output", split = FALSE)
  [21:25:31.742]         if (TRUE) {
  [21:25:31.742]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.742]         }
  [21:25:31.742]         else {
  [21:25:31.742]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.742]         }
  [21:25:31.742]         base::close(...future.stdout)
  [21:25:31.742]         ...future.stdout <- NULL
  [21:25:31.742]     }
  [21:25:31.742]     ...future.result$conditions <- ...future.conditions
  [21:25:31.742]     ...future.result
  [21:25:31.742] }
  [21:25:31.747] plan(): Setting new future strategy stack:
  [21:25:31.747] List of future strategies:
  [21:25:31.747] 1. sequential:
  [21:25:31.747]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.747]    - tweaked: FALSE
  [21:25:31.747]    - call: NULL
  [21:25:31.748] plan(): nbrOfWorkers() = 1
  [21:25:31.755] plan(): Setting new future strategy stack:
  [21:25:31.755] List of future strategies:
  [21:25:31.755] 1. sequential:
  [21:25:31.755]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.755]    - tweaked: FALSE
  [21:25:31.755]    - call: plan(strategy)
  [21:25:31.756] plan(): nbrOfWorkers() = 1
  [21:25:31.757] SequentialFuture started (and completed)
  [21:25:31.758] getGlobalsAndPackages() ...
  [21:25:31.758] Searching for globals...
  [21:25:31.759] - globals found: [1] '{'
  [21:25:31.759] Searching for globals ... DONE
  [21:25:31.760] Resolving globals: FALSE
  [21:25:31.760] 
  [21:25:31.760] 
  [21:25:31.761] getGlobalsAndPackages() ... DONE
  [21:25:31.762] Packages needed by the future expression (n = 0): <none>
  [21:25:31.763] Packages needed by future strategies (n = 0): <none>
  [21:25:31.767] {
  [21:25:31.767]     {
  [21:25:31.767]         ...future.startTime <- base::Sys.time()
  [21:25:31.767]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.767]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.767]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.767]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.767]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.767]         {
  [21:25:31.767]             {
  [21:25:31.767]                 base::local({
  [21:25:31.767]                   has_future <- base::requireNamespace("future", 
  [21:25:31.767]                     quietly = TRUE)
  [21:25:31.767]                   version <- if (has_future) 
  [21:25:31.767]                     utils::packageVersion("future")
  [21:25:31.767]                   else NULL
  [21:25:31.767]                   if (!has_future || version < "1.8.0") {
  [21:25:31.767]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.767]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.767]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.767]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.767]                         "release", "version")], collapse = " "), 
  [21:25:31.767]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.767]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.767]                       info)
  [21:25:31.767]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.767]                     if (!has_future) {
  [21:25:31.767]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.767]                         info)
  [21:25:31.767]                     }
  [21:25:31.767]                     else {
  [21:25:31.767]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.767]                         info, version)
  [21:25:31.767]                     }
  [21:25:31.767]                     base::stop(msg)
  [21:25:31.767]                   }
  [21:25:31.767]                 })
  [21:25:31.767]             }
  [21:25:31.767]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.767]         }
  [21:25:31.767]     }
  [21:25:31.767]     if (base::is.na(TRUE)) {
  [21:25:31.767]     }
  [21:25:31.767]     else {
  [21:25:31.767]         if (TRUE) {
  [21:25:31.767]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.767]                 open = "w")
  [21:25:31.767]         }
  [21:25:31.767]         else {
  [21:25:31.767]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.767]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.767]         }
  [21:25:31.767]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.767]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.767]             base::sink(type = "output", split = FALSE)
  [21:25:31.767]             base::close(...future.stdout)
  [21:25:31.767]         }, add = TRUE)
  [21:25:31.767]     }
  [21:25:31.767]     ...future.frame <- base::sys.nframe()
  [21:25:31.767]     ...future.conditions <- base::list()
  [21:25:31.767]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.767]     ...future.result <- base::tryCatch({
  [21:25:31.767]         base::withCallingHandlers({
  [21:25:31.767]             ...future.value <- base::withVisible(base::local({
  [21:25:31.767]                 4
  [21:25:31.767]             }))
  [21:25:31.767]             future::FutureResult(value = ...future.value$value, 
  [21:25:31.767]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.767]                   ...future.rng), started = ...future.startTime, 
  [21:25:31.767]                 version = "1.8")
  [21:25:31.767]         }, condition = base::local({
  [21:25:31.767]             c <- base::c
  [21:25:31.767]             inherits <- base::inherits
  [21:25:31.767]             invokeRestart <- base::invokeRestart
  [21:25:31.767]             length <- base::length
  [21:25:31.767]             list <- base::list
  [21:25:31.767]             seq.int <- base::seq.int
  [21:25:31.767]             signalCondition <- base::signalCondition
  [21:25:31.767]             sys.calls <- base::sys.calls
  [21:25:31.767]             Sys.time <- base::Sys.time
  [21:25:31.767]             `[[` <- base::`[[`
  [21:25:31.767]             `+` <- base::`+`
  [21:25:31.767]             `<<-` <- base::`<<-`
  [21:25:31.767]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:25:31.767]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:25:31.767]                   3L)]
  [21:25:31.767]             }
  [21:25:31.767]             function(cond) {
  [21:25:31.767]                 if (inherits(cond, "error")) {
  [21:25:31.767]                   sessionInformation <- function() {
  [21:25:31.767]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:25:31.767]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:25:31.767]                       search = base::search(), system = base::Sys.info())
  [21:25:31.767]                   }
  [21:25:31.767]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.767]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:25:31.767]                     cond$call), session = sessionInformation(), 
  [21:25:31.767]                     timestamp = Sys.time(), signaled = 0L)
  [21:25:31.767]                   signalCondition(cond)
  [21:25:31.767]                 }
  [21:25:31.767]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:25:31.767]                 ))) {
  [21:25:31.767]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:25:31.767]                   ...future.conditions[[length(...future.conditions) + 
  [21:25:31.767]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:25:31.767]                   if (!signal) {
  [21:25:31.767]                     muffleCondition <- function (cond) 
  [21:25:31.767]                     {
  [21:25:31.767]                       inherits <- base::inherits
  [21:25:31.767]                       invokeRestart <- base::invokeRestart
  [21:25:31.767]                       muffled <- FALSE
  [21:25:31.767]                       if (inherits(cond, "message")) {
  [21:25:31.767]                         invokeRestart("muffleMessage")
  [21:25:31.767]                         muffled <- TRUE
  [21:25:31.767]                       }
  [21:25:31.767]                       else if (inherits(cond, "warning")) {
  [21:25:31.767]                         invokeRestart("muffleWarning")
  [21:25:31.767]                         muffled <- TRUE
  [21:25:31.767]                       }
  [21:25:31.767]                       else if (inherits(cond, "condition")) {
  [21:25:31.767]                         computeRestarts <- base::computeRestarts
  [21:25:31.767]                         grepl <- base::grepl
  [21:25:31.767]                         is.null <- base::is.null
  [21:25:31.767]                         restarts <- computeRestarts(cond)
  [21:25:31.767]                         for (restart in restarts) {
  [21:25:31.767]                           name <- restart$name
  [21:25:31.767]                           if (is.null(name)) 
  [21:25:31.767]                             next
  [21:25:31.767]                           if (!grepl("^muffle", name)) 
  [21:25:31.767]                             next
  [21:25:31.767]                           invokeRestart(restart)
  [21:25:31.767]                           muffled <- TRUE
  [21:25:31.767]                           break
  [21:25:31.767]                         }
  [21:25:31.767]                       }
  [21:25:31.767]                       invisible(muffled)
  [21:25:31.767]                     }
  [21:25:31.767]                     muffleCondition(cond)
  [21:25:31.767]                   }
  [21:25:31.767]                 }
  [21:25:31.767]             }
  [21:25:31.767]         }))
  [21:25:31.767]     }, error = function(ex) {
  [21:25:31.767]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:25:31.767]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:25:31.767]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:25:31.767]     }, finally = {
  [21:25:31.767]         {
  [21:25:31.767]             NULL
  [21:25:31.767]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:25:31.767]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:25:31.767]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:25:31.767]                 label = NULL, ...) 
  [21:25:31.767]             {
  [21:25:31.767]                 if (substitute) 
  [21:25:31.767]                   expr <- substitute(expr)
  [21:25:31.767]                 local <- as.logical(local)
  [21:25:31.767]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:25:31.767]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:25:31.767]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:25:31.767]                   label = label, ...)
  [21:25:31.767]                 if (!future$lazy) 
  [21:25:31.767]                   future <- run(future)
  [21:25:31.767]                 invisible(future)
  [21:25:31.767]             }), .cleanup = FALSE, .init = FALSE)
  [21:25:31.767]         }
  [21:25:31.767]         base::options(...future.oldOptions)
  [21:25:31.767]     })
  [21:25:31.767]     Sys.time
  [21:25:31.767]     if (base::is.na(TRUE)) {
  [21:25:31.767]     }
  [21:25:31.767]     else {
  [21:25:31.767]         base::sink(type = "output", split = FALSE)
  [21:25:31.767]         if (TRUE) {
  [21:25:31.767]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:25:31.767]         }
  [21:25:31.767]         else {
  [21:25:31.767]             ...future.result["stdout"] <- base::list(NULL)
  [21:25:31.767]         }
  [21:25:31.767]         base::close(...future.stdout)
  [21:25:31.767]         ...future.stdout <- NULL
  [21:25:31.767]     }
  [21:25:31.767]     ...future.result$conditions <- ...future.conditions
  [21:25:31.767]     ...future.result
  [21:25:31.767] }
  [21:25:31.771] plan(): Setting new future strategy stack:
  [21:25:31.771] List of future strategies:
  [21:25:31.771] 1. sequential:
  [21:25:31.771]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.771]    - tweaked: FALSE
  [21:25:31.771]    - call: NULL
  [21:25:31.772] plan(): nbrOfWorkers() = 1
  [21:25:31.773] plan(): Setting new future strategy stack:
  [21:25:31.773] List of future strategies:
  [21:25:31.773] 1. sequential:
  [21:25:31.773]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:25:31.773]    - tweaked: FALSE
  [21:25:31.773]    - call: plan(strategy)
  [21:25:31.774] plan(): nbrOfWorkers() = 1
  [21:25:31.775] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ef22bca108> 
  Classes 'listenv', 'environment' <environment: 0x55ef2308bb78> 
   - attr(*, "dim.")= int [1:2] 2 3
   - attr(*, "dimnames.")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
   logi [1:2, 1:3] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "dimnames")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [21:25:31.796] resolve() on list environment ...
  [21:25:31.796]  recursive: 0
  [21:25:31.799]  length: 6
  [21:25:31.800]  elements: 'a', 'b', 'c', 'd', '', ''
  [21:25:31.800] signalConditionsASAP(numeric, pos=1) ...
  [21:25:31.800] - nx: 6
  [21:25:31.800] - relay: TRUE
  [21:25:31.801] - stdout: TRUE
  [21:25:31.801] - signal: TRUE
  [21:25:31.801] - resignal: FALSE
  [21:25:31.801] - force: TRUE
  [21:25:31.802] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.802] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.802]  - until=2
  [21:25:31.802]  - relaying element #2
  [21:25:31.803] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.803] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.803] signalConditionsASAP(NULL, pos=1) ... done
  [21:25:31.803]  length: 5 (resolved future 1)
  [21:25:31.804] Future #2
  [21:25:31.804] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:25:31.804] - nx: 6
  [21:25:31.805] - relay: TRUE
  [21:25:31.805] - stdout: TRUE
  [21:25:31.805] - signal: TRUE
  [21:25:31.805] - resignal: FALSE
  [21:25:31.806] - force: TRUE
  [21:25:31.806] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.806] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.806]  - until=2
  [21:25:31.807]  - relaying element #2
  [21:25:31.807] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.807] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.808] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:25:31.808]  length: 4 (resolved future 2)
  [21:25:31.808] Future #3
  [21:25:31.809] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:25:31.809] - nx: 6
  [21:25:31.809] - relay: TRUE
  [21:25:31.809] - stdout: TRUE
  [21:25:31.811] - signal: TRUE
  [21:25:31.812] - resignal: FALSE
  [21:25:31.812] - force: TRUE
  [21:25:31.812] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.812] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [21:25:31.813]  - until=3
  [21:25:31.813]  - relaying element #3
  [21:25:31.813] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.814] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.814] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:25:31.814]  length: 3 (resolved future 3)
  [21:25:31.815] Future #4
  [21:25:31.815] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:25:31.815] - nx: 6
  [21:25:31.815] - relay: TRUE
  [21:25:31.816] - stdout: TRUE
  [21:25:31.816] - signal: TRUE
  [21:25:31.816] - resignal: FALSE
  [21:25:31.816] - force: TRUE
  [21:25:31.816] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.817] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [21:25:31.817]  - until=4
  [21:25:31.817]  - relaying element #4
  [21:25:31.818] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.818] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.818] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:25:31.818]  length: 2 (resolved future 4)
  [21:25:31.819] signalConditionsASAP(NULL, pos=5) ...
  [21:25:31.819] - nx: 6
  [21:25:31.819] - relay: TRUE
  [21:25:31.819] - stdout: TRUE
  [21:25:31.820] - signal: TRUE
  [21:25:31.820] - resignal: FALSE
  [21:25:31.820] - force: TRUE
  [21:25:31.820] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.821] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.821]  - until=6
  [21:25:31.821]  - relaying element #6
  [21:25:31.821] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.822] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.822] signalConditionsASAP(NULL, pos=5) ... done
  [21:25:31.822]  length: 1 (resolved future 5)
  [21:25:31.822] signalConditionsASAP(numeric, pos=6) ...
  [21:25:31.823] - nx: 6
  [21:25:31.823] - relay: TRUE
  [21:25:31.823] - stdout: TRUE
  [21:25:31.823] - signal: TRUE
  [21:25:31.824] - resignal: FALSE
  [21:25:31.824] - force: TRUE
  [21:25:31.824] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [21:25:31.824] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.825]  - until=6
  [21:25:31.825] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.825] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.825] signalConditionsASAP(numeric, pos=6) ... done
  [21:25:31.826]  length: 0 (resolved future 6)
  [21:25:31.826] Relaying remaining futures
  [21:25:31.826] signalConditionsASAP(NULL, pos=0) ...
  [21:25:31.826] - nx: 6
  [21:25:31.827] - relay: TRUE
  [21:25:31.827] - stdout: TRUE
  [21:25:31.827] - signal: TRUE
  [21:25:31.827] - resignal: FALSE
  [21:25:31.828] - force: TRUE
  [21:25:31.828] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.828] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [21:25:31.829] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [21:25:31.829] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [21:25:31.829] signalConditionsASAP(NULL, pos=0) ... done
  [21:25:31.829] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ef215b7970> 
   - attr(*, "dim.")= int [1:2] 2 3
   - attr(*, "dimnames.")=List of 2
    ..$ : chr [1:2] "a" "b"
    ..$ : chr [1:3] "a" "b" "c"
  Dimensions: c(2, 3, 1)
  [21:25:31.842] getGlobalsAndPackages() ...
  [21:25:31.858] Searching for globals...
  [21:25:31.859] 
  [21:25:31.859] Searching for globals ... DONE
  [21:25:31.859] - globals: [0] <none>
  [21:25:31.860] getGlobalsAndPackages() ... DONE
  [21:25:31.862] Packages needed by the future expression (n = 0): <none>
  [21:25:31.862] Packages needed by future strategies (n = 0): <none>
  [21:25:31.866] {
  [21:25:31.866]     {
  [21:25:31.866]         ...future.startTime <- base::Sys.time()
  [21:25:31.866]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:25:31.866]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [21:25:31.866]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:25:31.866]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:25:31.866]             future.resolve.recursive = NULL, width = 80L)
  [21:25:31.866]         {
  [21:25:31.866]             {
  [21:25:31.866]                 base::local({
  [21:25:31.866]                   has_future <- base::requireNamespace("future", 
  [21:25:31.866]                     quietly = TRUE)
  [21:25:31.866]                   version <- if (has_future) 
  [21:25:31.866]                     utils::packageVersion("future")
  [21:25:31.866]                   else NULL
  [21:25:31.866]                   if (!has_future || version < "1.8.0") {
  [21:25:31.866]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:25:31.866]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:25:31.866]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:25:31.866]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:25:31.866]                         "release", "version")], collapse = " "), 
  [21:25:31.866]                       hostname = base::Sys.info()[["nodename"]])
  [21:25:31.866]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:25:31.866]                       info)
  [21:25:31.866]                     info <- base::paste(info, collapse = "; ")
  [21:25:31.866]                     if (!has_future) {
  [21:25:31.866]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:25:31.866]                         info)
  [21:25:31.866]                     }
  [21:25:31.866]                     else {
  [21:25:31.866]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:25:31.866]                         info, version)
  [21:25:31.866]                     }
  [21:25:31.866]                     base::stop(msg)
  [21:25:31.866]                   }
  [21:25:31.866]                 })
  [21:25:31.866]             }
  [21:25:31.866]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:25:31.866]         }
  [21:25:31.866]     }
  [21:25:31.866]     if (base::is.na(TRUE)) {
  [21:25:31.866]     }
  [21:25:31.866]     else {
  [21:25:31.866]         if (TRUE) {
  [21:25:31.866]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:25:31.866]                 open = "w")
  [21:25:31.866]         }
  [21:25:31.866]         else {
  [21:25:31.866]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:25:31.866]                 windows = "NUL", "/dev/null"), open = "w")
  [21:25:31.866]         }
  [21:25:31.866]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:25:31.866]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:25:31.866]             base::sink(type = "output", split = FALSE)
  [21:25:31.866]             base::close(...future.stdout)
  [21:25:31.866]         }, add = TRUE)
  [21:25:31.866]     }
  [21:25:31.866]     ...future.frame <- base::sys.nframe()
  [21:25:31.866]     ...future.conditions <- base::list()
  [21:25:31.866]     ...future.rng <- base::globalenv()$.Random.seed
  [21:25:31.866]     ...future.result <- base::tryCatch({
  [21:25:31.866]         base::withCallingHandlers({
  [21:25:31.866]             ...future.value <- base::withVisible(base::local(2))
  [21:25:31.866