Running ‘000.sessionDetails.R’ [6s/9s]
  Running ‘ClusterRegistry.R’ [2s/56s]
  Running ‘Future-class.R’ [1s/21s]
  Running ‘FutureError.R’ [0s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/2s]
  Running ‘as.cluster.R’ [1s/20s]
  Running ‘availableCores.R’ [0s/1s]
  Running ‘availableWorkers.R’ [0s/1s]
  Running ‘backtrace.R’ [1s/2s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [6s/124s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [7s/29s]
  Running ‘dotdotdot.R’ [1s/21s]
  Running ‘early-signaling.R’ [2s/41s]
  Running ‘future,labels.R’ [1s/1s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/22s]
  Running ‘futureAssign_OP.R’ [3s/21s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [4s/34s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [13s/124s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [3s/25s]
  Running ‘globals,manual.R’ [2s/3s]
  Running ‘globals,resolve.R’ [1s/21s]
  Running ‘globals,subassignment.R’ [3s/22s]
  Running ‘globals,toolarge.R’ [1s/21s]
  Running ‘globals,tricky.R’ [6s/31s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [1s/20s]
  Running ‘makeClusterPSOCK.R’ [1s/10s]
  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/3s]
  Running ‘multisession.R’ [4s/62s]
  Running ‘nbrOfWorkers.R’ [4s/78s]
  Running ‘nested_futures,mc.cores.R’ [5s/138s]
  Running ‘nested_futures.R’ [1s/2s]
  Running ‘non-exportable,connections.R’ [1s/19s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [6s/18s]
  Running ‘relaying.R’ [1s/3s]
  Running ‘remote.R’ [1s/20s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/32s]
  Running ‘reserved-keyword-functions.R’ [1s/1s]
  Running ‘resolve.R’ [2s/5s]
  Running ‘resolved-non-blocking-test.R’ [2s/76s]
  Running ‘rng.R’ [9s/35s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/42s]
  Running ‘stdout.R’ [2s/22s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/2s]
  Running ‘utils.R’ [6s/9s]
  Running ‘uuid.R’ [1s/2s]
  Running ‘whichIndex.R’ [1s/1s]
Running the tests in ‘tests/futures.R’ failed.
Complete output:
  > source("incl/start.R")
  [20:54:27.719] plan(): Setting new future strategy stack:
  [20:54:27.721] List of future strategies:
  [20:54:27.721] 1. sequential:
  [20:54:27.721]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.721]    - tweaked: FALSE
  [20:54:27.721]    - call: future::plan("sequential")
  [20:54:27.722] 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
  [20:54:27.920] plan(): Setting new future strategy stack:
  [20:54:27.920] List of future strategies:
  [20:54:27.920] 1. sequential:
  [20:54:27.920]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.920]    - tweaked: FALSE
  [20:54:27.920]    - call: plan(strategy)
  [20:54:27.944] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [20:54:27.946] getGlobalsAndPackages() ...
  [20:54:27.947] Searching for globals...
  [20:54:27.950] 
  [20:54:27.951] Searching for globals ... DONE
  [20:54:27.951] - globals: [0] <none>
  [20:54:27.951] getGlobalsAndPackages() ... DONE
  [20:54:27.954] Packages needed by the future expression (n = 0): <none>
  [20:54:27.955] Packages needed by future strategies (n = 0): <none>
  [20:54:27.959] {
  [20:54:27.959]     {
  [20:54:27.959]         ...future.startTime <- base::Sys.time()
  [20:54:27.959]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:27.959]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:27.959]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [20:54:27.959]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:27.959]             future.resolve.recursive = NULL, width = 80L)
  [20:54:27.959]         {
  [20:54:27.959]             {
  [20:54:27.959]                 has_future <- base::requireNamespace("future", 
  [20:54:27.959]                   quietly = TRUE)
  [20:54:27.959]                 version <- if (has_future) 
  [20:54:27.959]                   utils::packageVersion("future")
  [20:54:27.959]                 else NULL
  [20:54:27.959]                 if (!has_future || version < "1.8.0") {
  [20:54:27.959]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:27.959]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:27.959]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:27.959]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:27.959]                       "release", "version")], collapse = " "), 
  [20:54:27.959]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:27.959]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:27.959]                     info)
  [20:54:27.959]                   info <- base::paste(info, collapse = "; ")
  [20:54:27.959]                   if (!has_future) {
  [20:54:27.959]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:27.959]                       info)
  [20:54:27.959]                   }
  [20:54:27.959]                   else {
  [20:54:27.959]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:27.959]                       info, version)
  [20:54:27.959]                   }
  [20:54:27.959]                   base::stop(msg)
  [20:54:27.959]                 }
  [20:54:27.959]             }
  [20:54:27.959]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:27.959]         }
  [20:54:27.959]     }
  [20:54:27.959]     if (base::is.na(TRUE)) {
  [20:54:27.959]     }
  [20:54:27.959]     else {
  [20:54:27.959]         if (TRUE) {
  [20:54:27.959]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:27.959]                 open = "w")
  [20:54:27.959]         }
  [20:54:27.959]         else {
  [20:54:27.959]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:27.959]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:27.959]         }
  [20:54:27.959]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:27.959]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:27.959]             base::sink(type = "output", split = FALSE)
  [20:54:27.959]             base::close(...future.stdout)
  [20:54:27.959]         }, add = TRUE)
  [20:54:27.959]     }
  [20:54:27.959]     ...future.frame <- base::sys.nframe()
  [20:54:27.959]     ...future.conditions <- base::list()
  [20:54:27.959]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:27.959]     ...future.result <- base::tryCatch({
  [20:54:27.959]         base::withCallingHandlers({
  [20:54:27.959]             ...future.value <- base::withVisible(base::local(2))
  [20:54:27.959]             future::FutureResult(value = ...future.value$value, 
  [20:54:27.959]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:27.959]                   ...future.rng), started = ...future.startTime, 
  [20:54:27.959]                 version = "1.8")
  [20:54:27.959]         }, condition = base::local({
  [20:54:27.959]             c <- base::c
  [20:54:27.959]             inherits <- base::inherits
  [20:54:27.959]             invokeRestart <- base::invokeRestart
  [20:54:27.959]             length <- base::length
  [20:54:27.959]             list <- base::list
  [20:54:27.959]             seq.int <- base::seq.int
  [20:54:27.959]             signalCondition <- base::signalCondition
  [20:54:27.959]             sys.calls <- base::sys.calls
  [20:54:27.959]             Sys.time <- base::Sys.time
  [20:54:27.959]             `[[` <- base::`[[`
  [20:54:27.959]             `+` <- base::`+`
  [20:54:27.959]             `<<-` <- base::`<<-`
  [20:54:27.959]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:27.959]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:27.959]                   3L)]
  [20:54:27.959]             }
  [20:54:27.959]             function(cond) {
  [20:54:27.959]                 if (inherits(cond, "error")) {
  [20:54:27.959]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:27.959]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:27.959]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:27.959]                   signalCondition(cond)
  [20:54:27.959]                 }
  [20:54:27.959]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:27.959]                 ))) {
  [20:54:27.959]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:27.959]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:27.959]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:27.959]                   if (!signal) {
  [20:54:27.959]                     muffleCondition <- function (cond) 
  [20:54:27.959]                     {
  [20:54:27.959]                       inherits <- base::inherits
  [20:54:27.959]                       invokeRestart <- base::invokeRestart
  [20:54:27.959]                       muffled <- FALSE
  [20:54:27.959]                       if (inherits(cond, "message")) {
  [20:54:27.959]                         invokeRestart("muffleMessage")
  [20:54:27.959]                         muffled <- TRUE
  [20:54:27.959]                       }
  [20:54:27.959]                       else if (inherits(cond, "warning")) {
  [20:54:27.959]                         invokeRestart("muffleWarning")
  [20:54:27.959]                         muffled <- TRUE
  [20:54:27.959]                       }
  [20:54:27.959]                       else if (inherits(cond, "condition")) {
  [20:54:27.959]                         computeRestarts <- base::computeRestarts
  [20:54:27.959]                         grepl <- base::grepl
  [20:54:27.959]                         is.null <- base::is.null
  [20:54:27.959]                         restarts <- computeRestarts(cond)
  [20:54:27.959]                         for (restart in restarts) {
  [20:54:27.959]                           name <- restart$name
  [20:54:27.959]                           if (is.null(name)) 
  [20:54:27.959]                             next
  [20:54:27.959]                           if (!grepl("^muffle", name)) 
  [20:54:27.959]                             next
  [20:54:27.959]                           invokeRestart(restart)
  [20:54:27.959]                           muffled <- TRUE
  [20:54:27.959]                           break
  [20:54:27.959]                         }
  [20:54:27.959]                       }
  [20:54:27.959]                       invisible(muffled)
  [20:54:27.959]                     }
  [20:54:27.959]                     muffleCondition(cond)
  [20:54:27.959]                   }
  [20:54:27.959]                 }
  [20:54:27.959]             }
  [20:54:27.959]         }))
  [20:54:27.959]     }, error = function(ex) {
  [20:54:27.959]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:27.959]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:27.959]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:27.959]     }, finally = {
  [20:54:27.959]         {
  [20:54:27.959]             NULL
  [20:54:27.959]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:27.959]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:27.959]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:27.959]                 label = NULL, ...) 
  [20:54:27.959]             {
  [20:54:27.959]                 if (substitute) 
  [20:54:27.959]                   expr <- substitute(expr)
  [20:54:27.959]                 local <- as.logical(local)
  [20:54:27.959]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:27.959]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:27.959]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:27.959]                   label = label, ...)
  [20:54:27.959]                 if (!future$lazy) 
  [20:54:27.959]                   future <- run(future)
  [20:54:27.959]                 invisible(future)
  [20:54:27.959]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:27.959]         }
  [20:54:27.959]         base::options(...future.oldOptions)
  [20:54:27.959]     })
  [20:54:27.959]     Sys.time
  [20:54:27.959]     if (base::is.na(TRUE)) {
  [20:54:27.959]     }
  [20:54:27.959]     else {
  [20:54:27.959]         base::sink(type = "output", split = FALSE)
  [20:54:27.959]         if (TRUE) {
  [20:54:27.959]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:27.959]         }
  [20:54:27.959]         else {
  [20:54:27.959]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:27.959]         }
  [20:54:27.959]         base::close(...future.stdout)
  [20:54:27.959]         ...future.stdout <- NULL
  [20:54:27.959]     }
  [20:54:27.959]     ...future.result$conditions <- ...future.conditions
  [20:54:27.959]     ...future.result
  [20:54:27.959] }
  [20:54:27.964] plan(): Setting new future strategy stack:
  [20:54:27.965] List of future strategies:
  [20:54:27.965] 1. sequential:
  [20:54:27.965]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.965]    - tweaked: FALSE
  [20:54:27.965]    - call: NULL
  [20:54:27.966] plan(): nbrOfWorkers() = 1
  [20:54:27.967] plan(): Setting new future strategy stack:
  [20:54:27.967] List of future strategies:
  [20:54:27.967] 1. sequential:
  [20:54:27.967]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.967]    - tweaked: FALSE
  [20:54:27.967]    - call: plan(strategy)
  [20:54:27.968] plan(): nbrOfWorkers() = 1
  [20:54:27.969] SequentialFuture started (and completed)
  [20:54:27.970] getGlobalsAndPackages() ...
  [20:54:27.970] Searching for globals...
  [20:54:27.971] 
  [20:54:27.971] Searching for globals ... DONE
  [20:54:27.971] - globals: [0] <none>
  [20:54:27.971] getGlobalsAndPackages() ... DONE
  [20:54:27.973] Packages needed by the future expression (n = 0): <none>
  [20:54:27.973] Packages needed by future strategies (n = 0): <none>
  [20:54:27.977] {
  [20:54:27.977]     {
  [20:54:27.977]         ...future.startTime <- base::Sys.time()
  [20:54:27.977]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:27.977]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:27.977]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:27.977]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:27.977]             future.resolve.recursive = NULL, width = 80L)
  [20:54:27.977]         {
  [20:54:27.977]             {
  [20:54:27.977]                 has_future <- base::requireNamespace("future", 
  [20:54:27.977]                   quietly = TRUE)
  [20:54:27.977]                 version <- if (has_future) 
  [20:54:27.977]                   utils::packageVersion("future")
  [20:54:27.977]                 else NULL
  [20:54:27.977]                 if (!has_future || version < "1.8.0") {
  [20:54:27.977]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:27.977]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:27.977]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:27.977]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:27.977]                       "release", "version")], collapse = " "), 
  [20:54:27.977]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:27.977]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:27.977]                     info)
  [20:54:27.977]                   info <- base::paste(info, collapse = "; ")
  [20:54:27.977]                   if (!has_future) {
  [20:54:27.977]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:27.977]                       info)
  [20:54:27.977]                   }
  [20:54:27.977]                   else {
  [20:54:27.977]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:27.977]                       info, version)
  [20:54:27.977]                   }
  [20:54:27.977]                   base::stop(msg)
  [20:54:27.977]                 }
  [20:54:27.977]             }
  [20:54:27.977]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:27.977]         }
  [20:54:27.977]     }
  [20:54:27.977]     if (base::is.na(TRUE)) {
  [20:54:27.977]     }
  [20:54:27.977]     else {
  [20:54:27.977]         if (TRUE) {
  [20:54:27.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:27.977]                 open = "w")
  [20:54:27.977]         }
  [20:54:27.977]         else {
  [20:54:27.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:27.977]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:27.977]         }
  [20:54:27.977]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:27.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:27.977]             base::sink(type = "output", split = FALSE)
  [20:54:27.977]             base::close(...future.stdout)
  [20:54:27.977]         }, add = TRUE)
  [20:54:27.977]     }
  [20:54:27.977]     ...future.frame <- base::sys.nframe()
  [20:54:27.977]     ...future.conditions <- base::list()
  [20:54:27.977]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:27.977]     ...future.result <- base::tryCatch({
  [20:54:27.977]         base::withCallingHandlers({
  [20:54:27.977]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:27.977]             future::FutureResult(value = ...future.value$value, 
  [20:54:27.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:27.977]                   ...future.rng), started = ...future.startTime, 
  [20:54:27.977]                 version = "1.8")
  [20:54:27.977]         }, condition = base::local({
  [20:54:27.977]             c <- base::c
  [20:54:27.977]             inherits <- base::inherits
  [20:54:27.977]             invokeRestart <- base::invokeRestart
  [20:54:27.977]             length <- base::length
  [20:54:27.977]             list <- base::list
  [20:54:27.977]             seq.int <- base::seq.int
  [20:54:27.977]             signalCondition <- base::signalCondition
  [20:54:27.977]             sys.calls <- base::sys.calls
  [20:54:27.977]             Sys.time <- base::Sys.time
  [20:54:27.977]             `[[` <- base::`[[`
  [20:54:27.977]             `+` <- base::`+`
  [20:54:27.977]             `<<-` <- base::`<<-`
  [20:54:27.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:27.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:27.977]                   3L)]
  [20:54:27.977]             }
  [20:54:27.977]             function(cond) {
  [20:54:27.977]                 if (inherits(cond, "error")) {
  [20:54:27.977]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:27.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:27.977]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:27.977]                   signalCondition(cond)
  [20:54:27.977]                 }
  [20:54:27.977]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:27.977]                 ))) {
  [20:54:27.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:27.977]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:27.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:27.977]                   if (!signal) {
  [20:54:27.977]                     muffleCondition <- function (cond) 
  [20:54:27.977]                     {
  [20:54:27.977]                       inherits <- base::inherits
  [20:54:27.977]                       invokeRestart <- base::invokeRestart
  [20:54:27.977]                       muffled <- FALSE
  [20:54:27.977]                       if (inherits(cond, "message")) {
  [20:54:27.977]                         invokeRestart("muffleMessage")
  [20:54:27.977]                         muffled <- TRUE
  [20:54:27.977]                       }
  [20:54:27.977]                       else if (inherits(cond, "warning")) {
  [20:54:27.977]                         invokeRestart("muffleWarning")
  [20:54:27.977]                         muffled <- TRUE
  [20:54:27.977]                       }
  [20:54:27.977]                       else if (inherits(cond, "condition")) {
  [20:54:27.977]                         computeRestarts <- base::computeRestarts
  [20:54:27.977]                         grepl <- base::grepl
  [20:54:27.977]                         is.null <- base::is.null
  [20:54:27.977]                         restarts <- computeRestarts(cond)
  [20:54:27.977]                         for (restart in restarts) {
  [20:54:27.977]                           name <- restart$name
  [20:54:27.977]                           if (is.null(name)) 
  [20:54:27.977]                             next
  [20:54:27.977]                           if (!grepl("^muffle", name)) 
  [20:54:27.977]                             next
  [20:54:27.977]                           invokeRestart(restart)
  [20:54:27.977]                           muffled <- TRUE
  [20:54:27.977]                           break
  [20:54:27.977]                         }
  [20:54:27.977]                       }
  [20:54:27.977]                       invisible(muffled)
  [20:54:27.977]                     }
  [20:54:27.977]                     muffleCondition(cond)
  [20:54:27.977]                   }
  [20:54:27.977]                 }
  [20:54:27.977]             }
  [20:54:27.977]         }))
  [20:54:27.977]     }, error = function(ex) {
  [20:54:27.977]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:27.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:27.977]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:27.977]     }, finally = {
  [20:54:27.977]         {
  [20:54:27.977]             NULL
  [20:54:27.977]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:27.977]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:27.977]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:27.977]                 label = NULL, ...) 
  [20:54:27.977]             {
  [20:54:27.977]                 if (substitute) 
  [20:54:27.977]                   expr <- substitute(expr)
  [20:54:27.977]                 local <- as.logical(local)
  [20:54:27.977]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:27.977]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:27.977]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:27.977]                   label = label, ...)
  [20:54:27.977]                 if (!future$lazy) 
  [20:54:27.977]                   future <- run(future)
  [20:54:27.977]                 invisible(future)
  [20:54:27.977]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:27.977]         }
  [20:54:27.977]         base::options(...future.oldOptions)
  [20:54:27.977]     })
  [20:54:27.977]     Sys.time
  [20:54:27.977]     if (base::is.na(TRUE)) {
  [20:54:27.977]     }
  [20:54:27.977]     else {
  [20:54:27.977]         base::sink(type = "output", split = FALSE)
  [20:54:27.977]         if (TRUE) {
  [20:54:27.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:27.977]         }
  [20:54:27.977]         else {
  [20:54:27.977]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:27.977]         }
  [20:54:27.977]         base::close(...future.stdout)
  [20:54:27.977]         ...future.stdout <- NULL
  [20:54:27.977]     }
  [20:54:27.977]     ...future.result$conditions <- ...future.conditions
  [20:54:27.977]     ...future.result
  [20:54:27.977] }
  [20:54:27.982] plan(): Setting new future strategy stack:
  [20:54:27.983] List of future strategies:
  [20:54:27.983] 1. sequential:
  [20:54:27.983]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.983]    - tweaked: FALSE
  [20:54:27.983]    - call: NULL
  [20:54:27.983] plan(): nbrOfWorkers() = 1
  [20:54:27.984] plan(): Setting new future strategy stack:
  [20:54:27.985] List of future strategies:
  [20:54:27.985] 1. sequential:
  [20:54:27.985]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:27.985]    - tweaked: FALSE
  [20:54:27.985]    - call: plan(strategy)
  [20:54:27.986] plan(): nbrOfWorkers() = 1
  [20:54:27.986] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b116cc7b8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11a25438> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b116cc7b8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11a25438> 
   $  : NULL
   $  : NULL
   $  : num 6
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [20:54:28.008] resolve() on list ...
  [20:54:28.008]  recursive: 0
  [20:54:28.009]  length: 6
  [20:54:28.009]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:28.009] signalConditionsASAP(numeric, pos=1) ...
  [20:54:28.009] - nx: 6
  [20:54:28.010] - relay: TRUE
  [20:54:28.010] - stdout: TRUE
  [20:54:28.010] - signal: TRUE
  [20:54:28.010] - resignal: FALSE
  [20:54:28.011] - force: TRUE
  [20:54:28.011] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.011] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.011]  - until=2
  [20:54:28.012]  - relaying element #2
  [20:54:28.012] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.012] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.012] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:28.013]  length: 5 (resolved future 1)
  [20:54:28.013] Future #2
  [20:54:28.014] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:28.014] - nx: 6
  [20:54:28.014] - relay: TRUE
  [20:54:28.014] - stdout: TRUE
  [20:54:28.015] - signal: TRUE
  [20:54:28.015] - resignal: FALSE
  [20:54:28.015] - force: TRUE
  [20:54:28.015] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.015] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.016]  - until=2
  [20:54:28.016]  - relaying element #2
  [20:54:28.016] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.017] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.017] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:28.017]  length: 4 (resolved future 2)
  [20:54:28.018] Future #3
  [20:54:28.018] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:28.018] - nx: 6
  [20:54:28.019] - relay: TRUE
  [20:54:28.019] - stdout: TRUE
  [20:54:28.019] - signal: TRUE
  [20:54:28.019] - resignal: FALSE
  [20:54:28.019] - force: TRUE
  [20:54:28.020] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.020] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.020]  - until=3
  [20:54:28.020]  - relaying element #3
  [20:54:28.021] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.021] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.021] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:28.022]  length: 3 (resolved future 3)
  [20:54:28.022] signalConditionsASAP(NULL, pos=4) ...
  [20:54:28.022] - nx: 6
  [20:54:28.022] - relay: TRUE
  [20:54:28.022] - stdout: TRUE
  [20:54:28.023] - signal: TRUE
  [20:54:28.023] - resignal: FALSE
  [20:54:28.023] - force: TRUE
  [20:54:28.023] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.024] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.024]  - until=5
  [20:54:28.024]  - relaying element #5
  [20:54:28.024] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.025] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.025] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:28.025]  length: 2 (resolved future 4)
  [20:54:28.025] signalConditionsASAP(NULL, pos=5) ...
  [20:54:28.025] - nx: 6
  [20:54:28.026] - relay: TRUE
  [20:54:28.026] - stdout: TRUE
  [20:54:28.026] - signal: TRUE
  [20:54:28.026] - resignal: FALSE
  [20:54:28.027] - force: TRUE
  [20:54:28.027] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.027] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.027]  - until=6
  [20:54:28.027]  - relaying element #6
  [20:54:28.028] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.028] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.028] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:28.028]  length: 1 (resolved future 5)
  [20:54:28.029] signalConditionsASAP(numeric, pos=6) ...
  [20:54:28.029] - nx: 6
  [20:54:28.029] - relay: TRUE
  [20:54:28.029] - stdout: TRUE
  [20:54:28.030] - signal: TRUE
  [20:54:28.030] - resignal: FALSE
  [20:54:28.030] - force: TRUE
  [20:54:28.030] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.030] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.031]  - until=6
  [20:54:28.031] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.031] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.032] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:28.032]  length: 0 (resolved future 6)
  [20:54:28.032] Relaying remaining futures
  [20:54:28.032] signalConditionsASAP(NULL, pos=0) ...
  [20:54:28.032] - nx: 6
  [20:54:28.033] - relay: TRUE
  [20:54:28.033] - stdout: TRUE
  [20:54:28.033] - signal: TRUE
  [20:54:28.033] - resignal: FALSE
  [20:54:28.033] - force: TRUE
  [20:54:28.034] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.034] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:28.034] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.034] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.035] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:28.035] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [20:54:28.040] getGlobalsAndPackages() ...
  [20:54:28.040] Searching for globals...
  [20:54:28.041] 
  [20:54:28.041] Searching for globals ... DONE
  [20:54:28.041] - globals: [0] <none>
  [20:54:28.042] getGlobalsAndPackages() ... DONE
  [20:54:28.043] Packages needed by the future expression (n = 0): <none>
  [20:54:28.043] Packages needed by future strategies (n = 0): <none>
  [20:54:28.047] {
  [20:54:28.047]     {
  [20:54:28.047]         ...future.startTime <- base::Sys.time()
  [20:54:28.047]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.047]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.047]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.047]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.047]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.047]         {
  [20:54:28.047]             {
  [20:54:28.047]                 has_future <- base::requireNamespace("future", 
  [20:54:28.047]                   quietly = TRUE)
  [20:54:28.047]                 version <- if (has_future) 
  [20:54:28.047]                   utils::packageVersion("future")
  [20:54:28.047]                 else NULL
  [20:54:28.047]                 if (!has_future || version < "1.8.0") {
  [20:54:28.047]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.047]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.047]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.047]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.047]                       "release", "version")], collapse = " "), 
  [20:54:28.047]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.047]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.047]                     info)
  [20:54:28.047]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.047]                   if (!has_future) {
  [20:54:28.047]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.047]                       info)
  [20:54:28.047]                   }
  [20:54:28.047]                   else {
  [20:54:28.047]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.047]                       info, version)
  [20:54:28.047]                   }
  [20:54:28.047]                   base::stop(msg)
  [20:54:28.047]                 }
  [20:54:28.047]             }
  [20:54:28.047]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.047]         }
  [20:54:28.047]     }
  [20:54:28.047]     if (base::is.na(TRUE)) {
  [20:54:28.047]     }
  [20:54:28.047]     else {
  [20:54:28.047]         if (TRUE) {
  [20:54:28.047]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.047]                 open = "w")
  [20:54:28.047]         }
  [20:54:28.047]         else {
  [20:54:28.047]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.047]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.047]         }
  [20:54:28.047]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.047]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.047]             base::sink(type = "output", split = FALSE)
  [20:54:28.047]             base::close(...future.stdout)
  [20:54:28.047]         }, add = TRUE)
  [20:54:28.047]     }
  [20:54:28.047]     ...future.frame <- base::sys.nframe()
  [20:54:28.047]     ...future.conditions <- base::list()
  [20:54:28.047]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.047]     ...future.result <- base::tryCatch({
  [20:54:28.047]         base::withCallingHandlers({
  [20:54:28.047]             ...future.value <- base::withVisible(base::local(2))
  [20:54:28.047]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.047]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.047]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.047]                 version = "1.8")
  [20:54:28.047]         }, condition = base::local({
  [20:54:28.047]             c <- base::c
  [20:54:28.047]             inherits <- base::inherits
  [20:54:28.047]             invokeRestart <- base::invokeRestart
  [20:54:28.047]             length <- base::length
  [20:54:28.047]             list <- base::list
  [20:54:28.047]             seq.int <- base::seq.int
  [20:54:28.047]             signalCondition <- base::signalCondition
  [20:54:28.047]             sys.calls <- base::sys.calls
  [20:54:28.047]             Sys.time <- base::Sys.time
  [20:54:28.047]             `[[` <- base::`[[`
  [20:54:28.047]             `+` <- base::`+`
  [20:54:28.047]             `<<-` <- base::`<<-`
  [20:54:28.047]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.047]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.047]                   3L)]
  [20:54:28.047]             }
  [20:54:28.047]             function(cond) {
  [20:54:28.047]                 if (inherits(cond, "error")) {
  [20:54:28.047]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.047]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.047]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.047]                   signalCondition(cond)
  [20:54:28.047]                 }
  [20:54:28.047]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.047]                 ))) {
  [20:54:28.047]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.047]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.047]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.047]                   if (!signal) {
  [20:54:28.047]                     muffleCondition <- function (cond) 
  [20:54:28.047]                     {
  [20:54:28.047]                       inherits <- base::inherits
  [20:54:28.047]                       invokeRestart <- base::invokeRestart
  [20:54:28.047]                       muffled <- FALSE
  [20:54:28.047]                       if (inherits(cond, "message")) {
  [20:54:28.047]                         invokeRestart("muffleMessage")
  [20:54:28.047]                         muffled <- TRUE
  [20:54:28.047]                       }
  [20:54:28.047]                       else if (inherits(cond, "warning")) {
  [20:54:28.047]                         invokeRestart("muffleWarning")
  [20:54:28.047]                         muffled <- TRUE
  [20:54:28.047]                       }
  [20:54:28.047]                       else if (inherits(cond, "condition")) {
  [20:54:28.047]                         computeRestarts <- base::computeRestarts
  [20:54:28.047]                         grepl <- base::grepl
  [20:54:28.047]                         is.null <- base::is.null
  [20:54:28.047]                         restarts <- computeRestarts(cond)
  [20:54:28.047]                         for (restart in restarts) {
  [20:54:28.047]                           name <- restart$name
  [20:54:28.047]                           if (is.null(name)) 
  [20:54:28.047]                             next
  [20:54:28.047]                           if (!grepl("^muffle", name)) 
  [20:54:28.047]                             next
  [20:54:28.047]                           invokeRestart(restart)
  [20:54:28.047]                           muffled <- TRUE
  [20:54:28.047]                           break
  [20:54:28.047]                         }
  [20:54:28.047]                       }
  [20:54:28.047]                       invisible(muffled)
  [20:54:28.047]                     }
  [20:54:28.047]                     muffleCondition(cond)
  [20:54:28.047]                   }
  [20:54:28.047]                 }
  [20:54:28.047]             }
  [20:54:28.047]         }))
  [20:54:28.047]     }, error = function(ex) {
  [20:54:28.047]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.047]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.047]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.047]     }, finally = {
  [20:54:28.047]         {
  [20:54:28.047]             NULL
  [20:54:28.047]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.047]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.047]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.047]                 label = NULL, ...) 
  [20:54:28.047]             {
  [20:54:28.047]                 if (substitute) 
  [20:54:28.047]                   expr <- substitute(expr)
  [20:54:28.047]                 local <- as.logical(local)
  [20:54:28.047]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.047]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.047]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.047]                   label = label, ...)
  [20:54:28.047]                 if (!future$lazy) 
  [20:54:28.047]                   future <- run(future)
  [20:54:28.047]                 invisible(future)
  [20:54:28.047]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.047]         }
  [20:54:28.047]         base::options(...future.oldOptions)
  [20:54:28.047]     })
  [20:54:28.047]     Sys.time
  [20:54:28.047]     if (base::is.na(TRUE)) {
  [20:54:28.047]     }
  [20:54:28.047]     else {
  [20:54:28.047]         base::sink(type = "output", split = FALSE)
  [20:54:28.047]         if (TRUE) {
  [20:54:28.047]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.047]         }
  [20:54:28.047]         else {
  [20:54:28.047]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.047]         }
  [20:54:28.047]         base::close(...future.stdout)
  [20:54:28.047]         ...future.stdout <- NULL
  [20:54:28.047]     }
  [20:54:28.047]     ...future.result$conditions <- ...future.conditions
  [20:54:28.047]     ...future.result
  [20:54:28.047] }
  [20:54:28.052] plan(): Setting new future strategy stack:
  [20:54:28.052] List of future strategies:
  [20:54:28.052] 1. sequential:
  [20:54:28.052]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.052]    - tweaked: FALSE
  [20:54:28.052]    - call: NULL
  [20:54:28.053] plan(): nbrOfWorkers() = 1
  [20:54:28.054] plan(): Setting new future strategy stack:
  [20:54:28.054] List of future strategies:
  [20:54:28.054] 1. sequential:
  [20:54:28.054]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.054]    - tweaked: FALSE
  [20:54:28.054]    - call: plan(strategy)
  [20:54:28.055] plan(): nbrOfWorkers() = 1
  [20:54:28.055] SequentialFuture started (and completed)
  [20:54:28.056] getGlobalsAndPackages() ...
  [20:54:28.056] Searching for globals...
  [20:54:28.057] 
  [20:54:28.057] Searching for globals ... DONE
  [20:54:28.057] - globals: [0] <none>
  [20:54:28.057] getGlobalsAndPackages() ... DONE
  [20:54:28.064] Packages needed by the future expression (n = 0): <none>
  [20:54:28.064] Packages needed by future strategies (n = 0): <none>
  [20:54:28.068] {
  [20:54:28.068]     {
  [20:54:28.068]         ...future.startTime <- base::Sys.time()
  [20:54:28.068]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.068]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.068]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.068]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.068]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.068]         {
  [20:54:28.068]             {
  [20:54:28.068]                 has_future <- base::requireNamespace("future", 
  [20:54:28.068]                   quietly = TRUE)
  [20:54:28.068]                 version <- if (has_future) 
  [20:54:28.068]                   utils::packageVersion("future")
  [20:54:28.068]                 else NULL
  [20:54:28.068]                 if (!has_future || version < "1.8.0") {
  [20:54:28.068]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.068]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.068]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.068]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.068]                       "release", "version")], collapse = " "), 
  [20:54:28.068]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.068]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.068]                     info)
  [20:54:28.068]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.068]                   if (!has_future) {
  [20:54:28.068]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.068]                       info)
  [20:54:28.068]                   }
  [20:54:28.068]                   else {
  [20:54:28.068]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.068]                       info, version)
  [20:54:28.068]                   }
  [20:54:28.068]                   base::stop(msg)
  [20:54:28.068]                 }
  [20:54:28.068]             }
  [20:54:28.068]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.068]         }
  [20:54:28.068]     }
  [20:54:28.068]     if (base::is.na(TRUE)) {
  [20:54:28.068]     }
  [20:54:28.068]     else {
  [20:54:28.068]         if (TRUE) {
  [20:54:28.068]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.068]                 open = "w")
  [20:54:28.068]         }
  [20:54:28.068]         else {
  [20:54:28.068]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.068]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.068]         }
  [20:54:28.068]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.068]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.068]             base::sink(type = "output", split = FALSE)
  [20:54:28.068]             base::close(...future.stdout)
  [20:54:28.068]         }, add = TRUE)
  [20:54:28.068]     }
  [20:54:28.068]     ...future.frame <- base::sys.nframe()
  [20:54:28.068]     ...future.conditions <- base::list()
  [20:54:28.068]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.068]     ...future.result <- base::tryCatch({
  [20:54:28.068]         base::withCallingHandlers({
  [20:54:28.068]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:28.068]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.068]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.068]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.068]                 version = "1.8")
  [20:54:28.068]         }, condition = base::local({
  [20:54:28.068]             c <- base::c
  [20:54:28.068]             inherits <- base::inherits
  [20:54:28.068]             invokeRestart <- base::invokeRestart
  [20:54:28.068]             length <- base::length
  [20:54:28.068]             list <- base::list
  [20:54:28.068]             seq.int <- base::seq.int
  [20:54:28.068]             signalCondition <- base::signalCondition
  [20:54:28.068]             sys.calls <- base::sys.calls
  [20:54:28.068]             Sys.time <- base::Sys.time
  [20:54:28.068]             `[[` <- base::`[[`
  [20:54:28.068]             `+` <- base::`+`
  [20:54:28.068]             `<<-` <- base::`<<-`
  [20:54:28.068]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.068]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.068]                   3L)]
  [20:54:28.068]             }
  [20:54:28.068]             function(cond) {
  [20:54:28.068]                 if (inherits(cond, "error")) {
  [20:54:28.068]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.068]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.068]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.068]                   signalCondition(cond)
  [20:54:28.068]                 }
  [20:54:28.068]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.068]                 ))) {
  [20:54:28.068]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.068]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.068]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.068]                   if (!signal) {
  [20:54:28.068]                     muffleCondition <- function (cond) 
  [20:54:28.068]                     {
  [20:54:28.068]                       inherits <- base::inherits
  [20:54:28.068]                       invokeRestart <- base::invokeRestart
  [20:54:28.068]                       muffled <- FALSE
  [20:54:28.068]                       if (inherits(cond, "message")) {
  [20:54:28.068]                         invokeRestart("muffleMessage")
  [20:54:28.068]                         muffled <- TRUE
  [20:54:28.068]                       }
  [20:54:28.068]                       else if (inherits(cond, "warning")) {
  [20:54:28.068]                         invokeRestart("muffleWarning")
  [20:54:28.068]                         muffled <- TRUE
  [20:54:28.068]                       }
  [20:54:28.068]                       else if (inherits(cond, "condition")) {
  [20:54:28.068]                         computeRestarts <- base::computeRestarts
  [20:54:28.068]                         grepl <- base::grepl
  [20:54:28.068]                         is.null <- base::is.null
  [20:54:28.068]                         restarts <- computeRestarts(cond)
  [20:54:28.068]                         for (restart in restarts) {
  [20:54:28.068]                           name <- restart$name
  [20:54:28.068]                           if (is.null(name)) 
  [20:54:28.068]                             next
  [20:54:28.068]                           if (!grepl("^muffle", name)) 
  [20:54:28.068]                             next
  [20:54:28.068]                           invokeRestart(restart)
  [20:54:28.068]                           muffled <- TRUE
  [20:54:28.068]                           break
  [20:54:28.068]                         }
  [20:54:28.068]                       }
  [20:54:28.068]                       invisible(muffled)
  [20:54:28.068]                     }
  [20:54:28.068]                     muffleCondition(cond)
  [20:54:28.068]                   }
  [20:54:28.068]                 }
  [20:54:28.068]             }
  [20:54:28.068]         }))
  [20:54:28.068]     }, error = function(ex) {
  [20:54:28.068]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.068]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.068]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.068]     }, finally = {
  [20:54:28.068]         {
  [20:54:28.068]             NULL
  [20:54:28.068]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.068]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.068]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.068]                 label = NULL, ...) 
  [20:54:28.068]             {
  [20:54:28.068]                 if (substitute) 
  [20:54:28.068]                   expr <- substitute(expr)
  [20:54:28.068]                 local <- as.logical(local)
  [20:54:28.068]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.068]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.068]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.068]                   label = label, ...)
  [20:54:28.068]                 if (!future$lazy) 
  [20:54:28.068]                   future <- run(future)
  [20:54:28.068]                 invisible(future)
  [20:54:28.068]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.068]         }
  [20:54:28.068]         base::options(...future.oldOptions)
  [20:54:28.068]     })
  [20:54:28.068]     Sys.time
  [20:54:28.068]     if (base::is.na(TRUE)) {
  [20:54:28.068]     }
  [20:54:28.068]     else {
  [20:54:28.068]         base::sink(type = "output", split = FALSE)
  [20:54:28.068]         if (TRUE) {
  [20:54:28.068]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.068]         }
  [20:54:28.068]         else {
  [20:54:28.068]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.068]         }
  [20:54:28.068]         base::close(...future.stdout)
  [20:54:28.068]         ...future.stdout <- NULL
  [20:54:28.068]     }
  [20:54:28.068]     ...future.result$conditions <- ...future.conditions
  [20:54:28.068]     ...future.result
  [20:54:28.068] }
  [20:54:28.073] plan(): Setting new future strategy stack:
  [20:54:28.073] List of future strategies:
  [20:54:28.073] 1. sequential:
  [20:54:28.073]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.073]    - tweaked: FALSE
  [20:54:28.073]    - call: NULL
  [20:54:28.074] plan(): nbrOfWorkers() = 1
  [20:54:28.075] plan(): Setting new future strategy stack:
  [20:54:28.075] List of future strategies:
  [20:54:28.075] 1. sequential:
  [20:54:28.075]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.075]    - tweaked: FALSE
  [20:54:28.075]    - call: plan(strategy)
  [20:54:28.076] plan(): nbrOfWorkers() = 1
  [20:54:28.077] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1199e170> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11f49288> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1199e170> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11f49288> 
   $  : 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" "" ...
  [20:54:28.094] resolve() on list ...
  [20:54:28.094]  recursive: 0
  [20:54:28.094]  length: 6
  [20:54:28.094]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:28.095] signalConditionsASAP(numeric, pos=1) ...
  [20:54:28.095] - nx: 6
  [20:54:28.095] - relay: TRUE
  [20:54:28.095] - stdout: TRUE
  [20:54:28.096] - signal: TRUE
  [20:54:28.096] - resignal: FALSE
  [20:54:28.096] - force: TRUE
  [20:54:28.096] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.097] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.097]  - until=2
  [20:54:28.097]  - relaying element #2
  [20:54:28.097] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.098] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.098] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:28.098]  length: 5 (resolved future 1)
  [20:54:28.098] Future #2
  [20:54:28.099] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:28.099] - nx: 6
  [20:54:28.099] - relay: TRUE
  [20:54:28.100] - stdout: TRUE
  [20:54:28.100] - signal: TRUE
  [20:54:28.100] - resignal: FALSE
  [20:54:28.100] - force: TRUE
  [20:54:28.101] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.101] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.101]  - until=2
  [20:54:28.101]  - relaying element #2
  [20:54:28.102] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.102] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.102] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:28.103]  length: 4 (resolved future 2)
  [20:54:28.103] Future #3
  [20:54:28.103] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:28.104] - nx: 6
  [20:54:28.104] - relay: TRUE
  [20:54:28.104] - stdout: TRUE
  [20:54:28.104] - signal: TRUE
  [20:54:28.104] - resignal: FALSE
  [20:54:28.105] - force: TRUE
  [20:54:28.105] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.105] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.105]  - until=3
  [20:54:28.106]  - relaying element #3
  [20:54:28.106] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.106] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.107] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:28.107]  length: 3 (resolved future 3)
  [20:54:28.107] signalConditionsASAP(NULL, pos=4) ...
  [20:54:28.107] - nx: 6
  [20:54:28.108] - relay: TRUE
  [20:54:28.108] - stdout: TRUE
  [20:54:28.108] - signal: TRUE
  [20:54:28.108] - resignal: FALSE
  [20:54:28.109] - force: TRUE
  [20:54:28.109] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.109] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.109]  - until=5
  [20:54:28.110]  - relaying element #5
  [20:54:28.110] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.110] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.110] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:28.111]  length: 2 (resolved future 4)
  [20:54:28.111] signalConditionsASAP(NULL, pos=5) ...
  [20:54:28.111] - nx: 6
  [20:54:28.111] - relay: TRUE
  [20:54:28.111] - stdout: TRUE
  [20:54:28.112] - signal: TRUE
  [20:54:28.112] - resignal: FALSE
  [20:54:28.112] - force: TRUE
  [20:54:28.112] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.112] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.113]  - until=6
  [20:54:28.113]  - relaying element #6
  [20:54:28.113] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.113] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.114] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:28.114]  length: 1 (resolved future 5)
  [20:54:28.114] signalConditionsASAP(numeric, pos=6) ...
  [20:54:28.114] - nx: 6
  [20:54:28.115] - relay: TRUE
  [20:54:28.115] - stdout: TRUE
  [20:54:28.115] - signal: TRUE
  [20:54:28.115] - resignal: FALSE
  [20:54:28.115] - force: TRUE
  [20:54:28.116] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.116] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.116]  - until=6
  [20:54:28.116] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.117] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.117] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:28.117]  length: 0 (resolved future 6)
  [20:54:28.117] Relaying remaining futures
  [20:54:28.118] signalConditionsASAP(NULL, pos=0) ...
  [20:54:28.118] - nx: 6
  [20:54:28.118] - relay: TRUE
  [20:54:28.118] - stdout: TRUE
  [20:54:28.119] - signal: TRUE
  [20:54:28.119] - resignal: FALSE
  [20:54:28.119] - force: TRUE
  [20:54:28.119] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.119] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:28.120] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.120] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.120] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:28.120] 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)
  [20:54:28.132] getGlobalsAndPackages() ...
  [20:54:28.132] Searching for globals...
  [20:54:28.133] 
  [20:54:28.133] Searching for globals ... DONE
  [20:54:28.133] - globals: [0] <none>
  [20:54:28.133] getGlobalsAndPackages() ... DONE
  [20:54:28.135] Packages needed by the future expression (n = 0): <none>
  [20:54:28.136] Packages needed by future strategies (n = 0): <none>
  [20:54:28.139] {
  [20:54:28.139]     {
  [20:54:28.139]         ...future.startTime <- base::Sys.time()
  [20:54:28.139]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.139]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.139]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.139]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.139]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.139]         {
  [20:54:28.139]             {
  [20:54:28.139]                 has_future <- base::requireNamespace("future", 
  [20:54:28.139]                   quietly = TRUE)
  [20:54:28.139]                 version <- if (has_future) 
  [20:54:28.139]                   utils::packageVersion("future")
  [20:54:28.139]                 else NULL
  [20:54:28.139]                 if (!has_future || version < "1.8.0") {
  [20:54:28.139]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.139]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.139]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.139]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.139]                       "release", "version")], collapse = " "), 
  [20:54:28.139]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.139]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.139]                     info)
  [20:54:28.139]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.139]                   if (!has_future) {
  [20:54:28.139]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.139]                       info)
  [20:54:28.139]                   }
  [20:54:28.139]                   else {
  [20:54:28.139]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.139]                       info, version)
  [20:54:28.139]                   }
  [20:54:28.139]                   base::stop(msg)
  [20:54:28.139]                 }
  [20:54:28.139]             }
  [20:54:28.139]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.139]         }
  [20:54:28.139]     }
  [20:54:28.139]     if (base::is.na(TRUE)) {
  [20:54:28.139]     }
  [20:54:28.139]     else {
  [20:54:28.139]         if (TRUE) {
  [20:54:28.139]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.139]                 open = "w")
  [20:54:28.139]         }
  [20:54:28.139]         else {
  [20:54:28.139]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.139]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.139]         }
  [20:54:28.139]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.139]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.139]             base::sink(type = "output", split = FALSE)
  [20:54:28.139]             base::close(...future.stdout)
  [20:54:28.139]         }, add = TRUE)
  [20:54:28.139]     }
  [20:54:28.139]     ...future.frame <- base::sys.nframe()
  [20:54:28.139]     ...future.conditions <- base::list()
  [20:54:28.139]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.139]     ...future.result <- base::tryCatch({
  [20:54:28.139]         base::withCallingHandlers({
  [20:54:28.139]             ...future.value <- base::withVisible(base::local(2))
  [20:54:28.139]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.139]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.139]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.139]                 version = "1.8")
  [20:54:28.139]         }, condition = base::local({
  [20:54:28.139]             c <- base::c
  [20:54:28.139]             inherits <- base::inherits
  [20:54:28.139]             invokeRestart <- base::invokeRestart
  [20:54:28.139]             length <- base::length
  [20:54:28.139]             list <- base::list
  [20:54:28.139]             seq.int <- base::seq.int
  [20:54:28.139]             signalCondition <- base::signalCondition
  [20:54:28.139]             sys.calls <- base::sys.calls
  [20:54:28.139]             Sys.time <- base::Sys.time
  [20:54:28.139]             `[[` <- base::`[[`
  [20:54:28.139]             `+` <- base::`+`
  [20:54:28.139]             `<<-` <- base::`<<-`
  [20:54:28.139]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.139]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.139]                   3L)]
  [20:54:28.139]             }
  [20:54:28.139]             function(cond) {
  [20:54:28.139]                 if (inherits(cond, "error")) {
  [20:54:28.139]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.139]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.139]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.139]                   signalCondition(cond)
  [20:54:28.139]                 }
  [20:54:28.139]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.139]                 ))) {
  [20:54:28.139]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.139]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.139]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.139]                   if (!signal) {
  [20:54:28.139]                     muffleCondition <- function (cond) 
  [20:54:28.139]                     {
  [20:54:28.139]                       inherits <- base::inherits
  [20:54:28.139]                       invokeRestart <- base::invokeRestart
  [20:54:28.139]                       muffled <- FALSE
  [20:54:28.139]                       if (inherits(cond, "message")) {
  [20:54:28.139]                         invokeRestart("muffleMessage")
  [20:54:28.139]                         muffled <- TRUE
  [20:54:28.139]                       }
  [20:54:28.139]                       else if (inherits(cond, "warning")) {
  [20:54:28.139]                         invokeRestart("muffleWarning")
  [20:54:28.139]                         muffled <- TRUE
  [20:54:28.139]                       }
  [20:54:28.139]                       else if (inherits(cond, "condition")) {
  [20:54:28.139]                         computeRestarts <- base::computeRestarts
  [20:54:28.139]                         grepl <- base::grepl
  [20:54:28.139]                         is.null <- base::is.null
  [20:54:28.139]                         restarts <- computeRestarts(cond)
  [20:54:28.139]                         for (restart in restarts) {
  [20:54:28.139]                           name <- restart$name
  [20:54:28.139]                           if (is.null(name)) 
  [20:54:28.139]                             next
  [20:54:28.139]                           if (!grepl("^muffle", name)) 
  [20:54:28.139]                             next
  [20:54:28.139]                           invokeRestart(restart)
  [20:54:28.139]                           muffled <- TRUE
  [20:54:28.139]                           break
  [20:54:28.139]                         }
  [20:54:28.139]                       }
  [20:54:28.139]                       invisible(muffled)
  [20:54:28.139]                     }
  [20:54:28.139]                     muffleCondition(cond)
  [20:54:28.139]                   }
  [20:54:28.139]                 }
  [20:54:28.139]             }
  [20:54:28.139]         }))
  [20:54:28.139]     }, error = function(ex) {
  [20:54:28.139]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.139]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.139]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.139]     }, finally = {
  [20:54:28.139]         {
  [20:54:28.139]             NULL
  [20:54:28.139]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.139]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.139]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.139]                 label = NULL, ...) 
  [20:54:28.139]             {
  [20:54:28.139]                 if (substitute) 
  [20:54:28.139]                   expr <- substitute(expr)
  [20:54:28.139]                 local <- as.logical(local)
  [20:54:28.139]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.139]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.139]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.139]                   label = label, ...)
  [20:54:28.139]                 if (!future$lazy) 
  [20:54:28.139]                   future <- run(future)
  [20:54:28.139]                 invisible(future)
  [20:54:28.139]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.139]         }
  [20:54:28.139]         base::options(...future.oldOptions)
  [20:54:28.139]     })
  [20:54:28.139]     Sys.time
  [20:54:28.139]     if (base::is.na(TRUE)) {
  [20:54:28.139]     }
  [20:54:28.139]     else {
  [20:54:28.139]         base::sink(type = "output", split = FALSE)
  [20:54:28.139]         if (TRUE) {
  [20:54:28.139]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.139]         }
  [20:54:28.139]         else {
  [20:54:28.139]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.139]         }
  [20:54:28.139]         base::close(...future.stdout)
  [20:54:28.139]         ...future.stdout <- NULL
  [20:54:28.139]     }
  [20:54:28.139]     ...future.result$conditions <- ...future.conditions
  [20:54:28.139]     ...future.result
  [20:54:28.139] }
  [20:54:28.144] plan(): Setting new future strategy stack:
  [20:54:28.144] List of future strategies:
  [20:54:28.144] 1. sequential:
  [20:54:28.144]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.144]    - tweaked: FALSE
  [20:54:28.144]    - call: NULL
  [20:54:28.145] plan(): nbrOfWorkers() = 1
  [20:54:28.146] plan(): Setting new future strategy stack:
  [20:54:28.146] List of future strategies:
  [20:54:28.146] 1. sequential:
  [20:54:28.146]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.146]    - tweaked: FALSE
  [20:54:28.146]    - call: plan(strategy)
  [20:54:28.147] plan(): nbrOfWorkers() = 1
  [20:54:28.148] SequentialFuture started (and completed)
  [20:54:28.148] getGlobalsAndPackages() ...
  [20:54:28.148] Searching for globals...
  [20:54:28.149] 
  [20:54:28.149] Searching for globals ... DONE
  [20:54:28.149] - globals: [0] <none>
  [20:54:28.150] getGlobalsAndPackages() ... DONE
  [20:54:28.151] Packages needed by the future expression (n = 0): <none>
  [20:54:28.152] Packages needed by future strategies (n = 0): <none>
  [20:54:28.156] {
  [20:54:28.156]     {
  [20:54:28.156]         ...future.startTime <- base::Sys.time()
  [20:54:28.156]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.156]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.156]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.156]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.156]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.156]         {
  [20:54:28.156]             {
  [20:54:28.156]                 has_future <- base::requireNamespace("future", 
  [20:54:28.156]                   quietly = TRUE)
  [20:54:28.156]                 version <- if (has_future) 
  [20:54:28.156]                   utils::packageVersion("future")
  [20:54:28.156]                 else NULL
  [20:54:28.156]                 if (!has_future || version < "1.8.0") {
  [20:54:28.156]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.156]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.156]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.156]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.156]                       "release", "version")], collapse = " "), 
  [20:54:28.156]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.156]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.156]                     info)
  [20:54:28.156]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.156]                   if (!has_future) {
  [20:54:28.156]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.156]                       info)
  [20:54:28.156]                   }
  [20:54:28.156]                   else {
  [20:54:28.156]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.156]                       info, version)
  [20:54:28.156]                   }
  [20:54:28.156]                   base::stop(msg)
  [20:54:28.156]                 }
  [20:54:28.156]             }
  [20:54:28.156]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.156]         }
  [20:54:28.156]     }
  [20:54:28.156]     if (base::is.na(TRUE)) {
  [20:54:28.156]     }
  [20:54:28.156]     else {
  [20:54:28.156]         if (TRUE) {
  [20:54:28.156]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.156]                 open = "w")
  [20:54:28.156]         }
  [20:54:28.156]         else {
  [20:54:28.156]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.156]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.156]         }
  [20:54:28.156]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.156]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.156]             base::sink(type = "output", split = FALSE)
  [20:54:28.156]             base::close(...future.stdout)
  [20:54:28.156]         }, add = TRUE)
  [20:54:28.156]     }
  [20:54:28.156]     ...future.frame <- base::sys.nframe()
  [20:54:28.156]     ...future.conditions <- base::list()
  [20:54:28.156]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.156]     ...future.result <- base::tryCatch({
  [20:54:28.156]         base::withCallingHandlers({
  [20:54:28.156]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:28.156]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.156]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.156]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.156]                 version = "1.8")
  [20:54:28.156]         }, condition = base::local({
  [20:54:28.156]             c <- base::c
  [20:54:28.156]             inherits <- base::inherits
  [20:54:28.156]             invokeRestart <- base::invokeRestart
  [20:54:28.156]             length <- base::length
  [20:54:28.156]             list <- base::list
  [20:54:28.156]             seq.int <- base::seq.int
  [20:54:28.156]             signalCondition <- base::signalCondition
  [20:54:28.156]             sys.calls <- base::sys.calls
  [20:54:28.156]             Sys.time <- base::Sys.time
  [20:54:28.156]             `[[` <- base::`[[`
  [20:54:28.156]             `+` <- base::`+`
  [20:54:28.156]             `<<-` <- base::`<<-`
  [20:54:28.156]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.156]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.156]                   3L)]
  [20:54:28.156]             }
  [20:54:28.156]             function(cond) {
  [20:54:28.156]                 if (inherits(cond, "error")) {
  [20:54:28.156]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.156]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.156]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.156]                   signalCondition(cond)
  [20:54:28.156]                 }
  [20:54:28.156]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.156]                 ))) {
  [20:54:28.156]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.156]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.156]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.156]                   if (!signal) {
  [20:54:28.156]                     muffleCondition <- function (cond) 
  [20:54:28.156]                     {
  [20:54:28.156]                       inherits <- base::inherits
  [20:54:28.156]                       invokeRestart <- base::invokeRestart
  [20:54:28.156]                       muffled <- FALSE
  [20:54:28.156]                       if (inherits(cond, "message")) {
  [20:54:28.156]                         invokeRestart("muffleMessage")
  [20:54:28.156]                         muffled <- TRUE
  [20:54:28.156]                       }
  [20:54:28.156]                       else if (inherits(cond, "warning")) {
  [20:54:28.156]                         invokeRestart("muffleWarning")
  [20:54:28.156]                         muffled <- TRUE
  [20:54:28.156]                       }
  [20:54:28.156]                       else if (inherits(cond, "condition")) {
  [20:54:28.156]                         computeRestarts <- base::computeRestarts
  [20:54:28.156]                         grepl <- base::grepl
  [20:54:28.156]                         is.null <- base::is.null
  [20:54:28.156]                         restarts <- computeRestarts(cond)
  [20:54:28.156]                         for (restart in restarts) {
  [20:54:28.156]                           name <- restart$name
  [20:54:28.156]                           if (is.null(name)) 
  [20:54:28.156]                             next
  [20:54:28.156]                           if (!grepl("^muffle", name)) 
  [20:54:28.156]                             next
  [20:54:28.156]                           invokeRestart(restart)
  [20:54:28.156]                           muffled <- TRUE
  [20:54:28.156]                           break
  [20:54:28.156]                         }
  [20:54:28.156]                       }
  [20:54:28.156]                       invisible(muffled)
  [20:54:28.156]                     }
  [20:54:28.156]                     muffleCondition(cond)
  [20:54:28.156]                   }
  [20:54:28.156]                 }
  [20:54:28.156]             }
  [20:54:28.156]         }))
  [20:54:28.156]     }, error = function(ex) {
  [20:54:28.156]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.156]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.156]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.156]     }, finally = {
  [20:54:28.156]         {
  [20:54:28.156]             NULL
  [20:54:28.156]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.156]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.156]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.156]                 label = NULL, ...) 
  [20:54:28.156]             {
  [20:54:28.156]                 if (substitute) 
  [20:54:28.156]                   expr <- substitute(expr)
  [20:54:28.156]                 local <- as.logical(local)
  [20:54:28.156]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.156]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.156]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.156]                   label = label, ...)
  [20:54:28.156]                 if (!future$lazy) 
  [20:54:28.156]                   future <- run(future)
  [20:54:28.156]                 invisible(future)
  [20:54:28.156]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.156]         }
  [20:54:28.156]         base::options(...future.oldOptions)
  [20:54:28.156]     })
  [20:54:28.156]     Sys.time
  [20:54:28.156]     if (base::is.na(TRUE)) {
  [20:54:28.156]     }
  [20:54:28.156]     else {
  [20:54:28.156]         base::sink(type = "output", split = FALSE)
  [20:54:28.156]         if (TRUE) {
  [20:54:28.156]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.156]         }
  [20:54:28.156]         else {
  [20:54:28.156]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.156]         }
  [20:54:28.156]         base::close(...future.stdout)
  [20:54:28.156]         ...future.stdout <- NULL
  [20:54:28.156]     }
  [20:54:28.156]     ...future.result$conditions <- ...future.conditions
  [20:54:28.156]     ...future.result
  [20:54:28.156] }
  [20:54:28.160] plan(): Setting new future strategy stack:
  [20:54:28.160] List of future strategies:
  [20:54:28.160] 1. sequential:
  [20:54:28.160]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.160]    - tweaked: FALSE
  [20:54:28.160]    - call: NULL
  [20:54:28.161] plan(): nbrOfWorkers() = 1
  [20:54:28.162] plan(): Setting new future strategy stack:
  [20:54:28.162] List of future strategies:
  [20:54:28.162] 1. sequential:
  [20:54:28.162]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.162]    - tweaked: FALSE
  [20:54:28.162]    - call: plan(strategy)
  [20:54:28.163] plan(): nbrOfWorkers() = 1
  [20:54:28.163] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b0fd68b78> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b106d7078> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b0fd68b78> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b106d7078> 
   $  : 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" "" ...
  [20:54:28.180] resolve() on list ...
  [20:54:28.180]  recursive: 0
  [20:54:28.180]  length: 6
  [20:54:28.181]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:28.181] signalConditionsASAP(numeric, pos=1) ...
  [20:54:28.181] - nx: 6
  [20:54:28.181] - relay: TRUE
  [20:54:28.182] - stdout: TRUE
  [20:54:28.182] - signal: TRUE
  [20:54:28.182] - resignal: FALSE
  [20:54:28.182] - force: TRUE
  [20:54:28.182] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.183] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.183]  - until=2
  [20:54:28.183]  - relaying element #2
  [20:54:28.183] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.184] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.184] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:28.184]  length: 5 (resolved future 1)
  [20:54:28.184] Future #2
  [20:54:28.185] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:28.185] - nx: 6
  [20:54:28.185] - relay: TRUE
  [20:54:28.186] - stdout: TRUE
  [20:54:28.186] - signal: TRUE
  [20:54:28.186] - resignal: FALSE
  [20:54:28.189] - force: TRUE
  [20:54:28.189] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.189] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.190]  - until=2
  [20:54:28.190]  - relaying element #2
  [20:54:28.190] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.191] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.191] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:28.191]  length: 4 (resolved future 2)
  [20:54:28.191] Future #3
  [20:54:28.192] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:28.192] - nx: 6
  [20:54:28.192] - relay: TRUE
  [20:54:28.192] - stdout: TRUE
  [20:54:28.193] - signal: TRUE
  [20:54:28.193] - resignal: FALSE
  [20:54:28.193] - force: TRUE
  [20:54:28.193] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.194] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.194]  - until=3
  [20:54:28.194]  - relaying element #3
  [20:54:28.195] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.195] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.195] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:28.195]  length: 3 (resolved future 3)
  [20:54:28.196] signalConditionsASAP(NULL, pos=4) ...
  [20:54:28.196] - nx: 6
  [20:54:28.196] - relay: TRUE
  [20:54:28.196] - stdout: TRUE
  [20:54:28.197] - signal: TRUE
  [20:54:28.197] - resignal: FALSE
  [20:54:28.197] - force: TRUE
  [20:54:28.197] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.197] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.198]  - until=5
  [20:54:28.198]  - relaying element #5
  [20:54:28.198] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.198] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.199] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:28.199]  length: 2 (resolved future 4)
  [20:54:28.199] signalConditionsASAP(NULL, pos=5) ...
  [20:54:28.199] - nx: 6
  [20:54:28.200] - relay: TRUE
  [20:54:28.200] - stdout: TRUE
  [20:54:28.200] - signal: TRUE
  [20:54:28.200] - resignal: FALSE
  [20:54:28.201] - force: TRUE
  [20:54:28.201] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.201] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.201]  - until=6
  [20:54:28.201]  - relaying element #6
  [20:54:28.202] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.202] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.202] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:28.202]  length: 1 (resolved future 5)
  [20:54:28.203] signalConditionsASAP(numeric, pos=6) ...
  [20:54:28.203] - nx: 6
  [20:54:28.203] - relay: TRUE
  [20:54:28.203] - stdout: TRUE
  [20:54:28.204] - signal: TRUE
  [20:54:28.204] - resignal: FALSE
  [20:54:28.204] - force: TRUE
  [20:54:28.204] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.205] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.205]  - until=6
  [20:54:28.205] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.205] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.206] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:28.206]  length: 0 (resolved future 6)
  [20:54:28.206] Relaying remaining futures
  [20:54:28.206] signalConditionsASAP(NULL, pos=0) ...
  [20:54:28.207] - nx: 6
  [20:54:28.207] - relay: TRUE
  [20:54:28.207] - stdout: TRUE
  [20:54:28.207] - signal: TRUE
  [20:54:28.207] - resignal: FALSE
  [20:54:28.208] - force: TRUE
  [20:54:28.208] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.208] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:28.209] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.209] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.209] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:28.209] 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)
  [20:54:28.218] getGlobalsAndPackages() ...
  [20:54:28.218] Searching for globals...
  [20:54:28.219] 
  [20:54:28.219] Searching for globals ... DONE
  [20:54:28.219] - globals: [0] <none>
  [20:54:28.219] getGlobalsAndPackages() ... DONE
  [20:54:28.221] Packages needed by the future expression (n = 0): <none>
  [20:54:28.221] Packages needed by future strategies (n = 0): <none>
  [20:54:28.225] {
  [20:54:28.225]     {
  [20:54:28.225]         ...future.startTime <- base::Sys.time()
  [20:54:28.225]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.225]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.225]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.225]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.225]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.225]         {
  [20:54:28.225]             {
  [20:54:28.225]                 has_future <- base::requireNamespace("future", 
  [20:54:28.225]                   quietly = TRUE)
  [20:54:28.225]                 version <- if (has_future) 
  [20:54:28.225]                   utils::packageVersion("future")
  [20:54:28.225]                 else NULL
  [20:54:28.225]                 if (!has_future || version < "1.8.0") {
  [20:54:28.225]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.225]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.225]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.225]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.225]                       "release", "version")], collapse = " "), 
  [20:54:28.225]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.225]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.225]                     info)
  [20:54:28.225]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.225]                   if (!has_future) {
  [20:54:28.225]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.225]                       info)
  [20:54:28.225]                   }
  [20:54:28.225]                   else {
  [20:54:28.225]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.225]                       info, version)
  [20:54:28.225]                   }
  [20:54:28.225]                   base::stop(msg)
  [20:54:28.225]                 }
  [20:54:28.225]             }
  [20:54:28.225]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.225]         }
  [20:54:28.225]     }
  [20:54:28.225]     if (base::is.na(TRUE)) {
  [20:54:28.225]     }
  [20:54:28.225]     else {
  [20:54:28.225]         if (TRUE) {
  [20:54:28.225]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.225]                 open = "w")
  [20:54:28.225]         }
  [20:54:28.225]         else {
  [20:54:28.225]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.225]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.225]         }
  [20:54:28.225]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.225]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.225]             base::sink(type = "output", split = FALSE)
  [20:54:28.225]             base::close(...future.stdout)
  [20:54:28.225]         }, add = TRUE)
  [20:54:28.225]     }
  [20:54:28.225]     ...future.frame <- base::sys.nframe()
  [20:54:28.225]     ...future.conditions <- base::list()
  [20:54:28.225]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.225]     ...future.result <- base::tryCatch({
  [20:54:28.225]         base::withCallingHandlers({
  [20:54:28.225]             ...future.value <- base::withVisible(base::local(2))
  [20:54:28.225]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.225]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.225]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.225]                 version = "1.8")
  [20:54:28.225]         }, condition = base::local({
  [20:54:28.225]             c <- base::c
  [20:54:28.225]             inherits <- base::inherits
  [20:54:28.225]             invokeRestart <- base::invokeRestart
  [20:54:28.225]             length <- base::length
  [20:54:28.225]             list <- base::list
  [20:54:28.225]             seq.int <- base::seq.int
  [20:54:28.225]             signalCondition <- base::signalCondition
  [20:54:28.225]             sys.calls <- base::sys.calls
  [20:54:28.225]             Sys.time <- base::Sys.time
  [20:54:28.225]             `[[` <- base::`[[`
  [20:54:28.225]             `+` <- base::`+`
  [20:54:28.225]             `<<-` <- base::`<<-`
  [20:54:28.225]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.225]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.225]                   3L)]
  [20:54:28.225]             }
  [20:54:28.225]             function(cond) {
  [20:54:28.225]                 if (inherits(cond, "error")) {
  [20:54:28.225]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.225]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.225]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.225]                   signalCondition(cond)
  [20:54:28.225]                 }
  [20:54:28.225]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.225]                 ))) {
  [20:54:28.225]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.225]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.225]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.225]                   if (!signal) {
  [20:54:28.225]                     muffleCondition <- function (cond) 
  [20:54:28.225]                     {
  [20:54:28.225]                       inherits <- base::inherits
  [20:54:28.225]                       invokeRestart <- base::invokeRestart
  [20:54:28.225]                       muffled <- FALSE
  [20:54:28.225]                       if (inherits(cond, "message")) {
  [20:54:28.225]                         invokeRestart("muffleMessage")
  [20:54:28.225]                         muffled <- TRUE
  [20:54:28.225]                       }
  [20:54:28.225]                       else if (inherits(cond, "warning")) {
  [20:54:28.225]                         invokeRestart("muffleWarning")
  [20:54:28.225]                         muffled <- TRUE
  [20:54:28.225]                       }
  [20:54:28.225]                       else if (inherits(cond, "condition")) {
  [20:54:28.225]                         computeRestarts <- base::computeRestarts
  [20:54:28.225]                         grepl <- base::grepl
  [20:54:28.225]                         is.null <- base::is.null
  [20:54:28.225]                         restarts <- computeRestarts(cond)
  [20:54:28.225]                         for (restart in restarts) {
  [20:54:28.225]                           name <- restart$name
  [20:54:28.225]                           if (is.null(name)) 
  [20:54:28.225]                             next
  [20:54:28.225]                           if (!grepl("^muffle", name)) 
  [20:54:28.225]                             next
  [20:54:28.225]                           invokeRestart(restart)
  [20:54:28.225]                           muffled <- TRUE
  [20:54:28.225]                           break
  [20:54:28.225]                         }
  [20:54:28.225]                       }
  [20:54:28.225]                       invisible(muffled)
  [20:54:28.225]                     }
  [20:54:28.225]                     muffleCondition(cond)
  [20:54:28.225]                   }
  [20:54:28.225]                 }
  [20:54:28.225]             }
  [20:54:28.225]         }))
  [20:54:28.225]     }, error = function(ex) {
  [20:54:28.225]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.225]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.225]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.225]     }, finally = {
  [20:54:28.225]         {
  [20:54:28.225]             NULL
  [20:54:28.225]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.225]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.225]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.225]                 label = NULL, ...) 
  [20:54:28.225]             {
  [20:54:28.225]                 if (substitute) 
  [20:54:28.225]                   expr <- substitute(expr)
  [20:54:28.225]                 local <- as.logical(local)
  [20:54:28.225]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.225]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.225]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.225]                   label = label, ...)
  [20:54:28.225]                 if (!future$lazy) 
  [20:54:28.225]                   future <- run(future)
  [20:54:28.225]                 invisible(future)
  [20:54:28.225]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.225]         }
  [20:54:28.225]         base::options(...future.oldOptions)
  [20:54:28.225]     })
  [20:54:28.225]     Sys.time
  [20:54:28.225]     if (base::is.na(TRUE)) {
  [20:54:28.225]     }
  [20:54:28.225]     else {
  [20:54:28.225]         base::sink(type = "output", split = FALSE)
  [20:54:28.225]         if (TRUE) {
  [20:54:28.225]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.225]         }
  [20:54:28.225]         else {
  [20:54:28.225]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.225]         }
  [20:54:28.225]         base::close(...future.stdout)
  [20:54:28.225]         ...future.stdout <- NULL
  [20:54:28.225]     }
  [20:54:28.225]     ...future.result$conditions <- ...future.conditions
  [20:54:28.225]     ...future.result
  [20:54:28.225] }
  [20:54:28.230] plan(): Setting new future strategy stack:
  [20:54:28.230] List of future strategies:
  [20:54:28.230] 1. sequential:
  [20:54:28.230]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.230]    - tweaked: FALSE
  [20:54:28.230]    - call: NULL
  [20:54:28.231] plan(): nbrOfWorkers() = 1
  [20:54:28.232] plan(): Setting new future strategy stack:
  [20:54:28.232] List of future strategies:
  [20:54:28.232] 1. sequential:
  [20:54:28.232]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.232]    - tweaked: FALSE
  [20:54:28.232]    - call: plan(strategy)
  [20:54:28.233] plan(): nbrOfWorkers() = 1
  [20:54:28.233] SequentialFuture started (and completed)
  [20:54:28.234] getGlobalsAndPackages() ...
  [20:54:28.234] Searching for globals...
  [20:54:28.235] 
  [20:54:28.235] Searching for globals ... DONE
  [20:54:28.235] - globals: [0] <none>
  [20:54:28.235] getGlobalsAndPackages() ... DONE
  [20:54:28.237] Packages needed by the future expression (n = 0): <none>
  [20:54:28.237] Packages needed by future strategies (n = 0): <none>
  [20:54:28.241] {
  [20:54:28.241]     {
  [20:54:28.241]         ...future.startTime <- base::Sys.time()
  [20:54:28.241]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.241]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.241]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.241]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.241]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.241]         {
  [20:54:28.241]             {
  [20:54:28.241]                 has_future <- base::requireNamespace("future", 
  [20:54:28.241]                   quietly = TRUE)
  [20:54:28.241]                 version <- if (has_future) 
  [20:54:28.241]                   utils::packageVersion("future")
  [20:54:28.241]                 else NULL
  [20:54:28.241]                 if (!has_future || version < "1.8.0") {
  [20:54:28.241]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.241]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.241]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.241]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.241]                       "release", "version")], collapse = " "), 
  [20:54:28.241]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.241]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.241]                     info)
  [20:54:28.241]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.241]                   if (!has_future) {
  [20:54:28.241]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.241]                       info)
  [20:54:28.241]                   }
  [20:54:28.241]                   else {
  [20:54:28.241]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.241]                       info, version)
  [20:54:28.241]                   }
  [20:54:28.241]                   base::stop(msg)
  [20:54:28.241]                 }
  [20:54:28.241]             }
  [20:54:28.241]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.241]         }
  [20:54:28.241]     }
  [20:54:28.241]     if (base::is.na(TRUE)) {
  [20:54:28.241]     }
  [20:54:28.241]     else {
  [20:54:28.241]         if (TRUE) {
  [20:54:28.241]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.241]                 open = "w")
  [20:54:28.241]         }
  [20:54:28.241]         else {
  [20:54:28.241]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.241]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.241]         }
  [20:54:28.241]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.241]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.241]             base::sink(type = "output", split = FALSE)
  [20:54:28.241]             base::close(...future.stdout)
  [20:54:28.241]         }, add = TRUE)
  [20:54:28.241]     }
  [20:54:28.241]     ...future.frame <- base::sys.nframe()
  [20:54:28.241]     ...future.conditions <- base::list()
  [20:54:28.241]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.241]     ...future.result <- base::tryCatch({
  [20:54:28.241]         base::withCallingHandlers({
  [20:54:28.241]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:28.241]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.241]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.241]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.241]                 version = "1.8")
  [20:54:28.241]         }, condition = base::local({
  [20:54:28.241]             c <- base::c
  [20:54:28.241]             inherits <- base::inherits
  [20:54:28.241]             invokeRestart <- base::invokeRestart
  [20:54:28.241]             length <- base::length
  [20:54:28.241]             list <- base::list
  [20:54:28.241]             seq.int <- base::seq.int
  [20:54:28.241]             signalCondition <- base::signalCondition
  [20:54:28.241]             sys.calls <- base::sys.calls
  [20:54:28.241]             Sys.time <- base::Sys.time
  [20:54:28.241]             `[[` <- base::`[[`
  [20:54:28.241]             `+` <- base::`+`
  [20:54:28.241]             `<<-` <- base::`<<-`
  [20:54:28.241]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.241]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.241]                   3L)]
  [20:54:28.241]             }
  [20:54:28.241]             function(cond) {
  [20:54:28.241]                 if (inherits(cond, "error")) {
  [20:54:28.241]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.241]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.241]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.241]                   signalCondition(cond)
  [20:54:28.241]                 }
  [20:54:28.241]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.241]                 ))) {
  [20:54:28.241]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.241]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.241]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.241]                   if (!signal) {
  [20:54:28.241]                     muffleCondition <- function (cond) 
  [20:54:28.241]                     {
  [20:54:28.241]                       inherits <- base::inherits
  [20:54:28.241]                       invokeRestart <- base::invokeRestart
  [20:54:28.241]                       muffled <- FALSE
  [20:54:28.241]                       if (inherits(cond, "message")) {
  [20:54:28.241]                         invokeRestart("muffleMessage")
  [20:54:28.241]                         muffled <- TRUE
  [20:54:28.241]                       }
  [20:54:28.241]                       else if (inherits(cond, "warning")) {
  [20:54:28.241]                         invokeRestart("muffleWarning")
  [20:54:28.241]                         muffled <- TRUE
  [20:54:28.241]                       }
  [20:54:28.241]                       else if (inherits(cond, "condition")) {
  [20:54:28.241]                         computeRestarts <- base::computeRestarts
  [20:54:28.241]                         grepl <- base::grepl
  [20:54:28.241]                         is.null <- base::is.null
  [20:54:28.241]                         restarts <- computeRestarts(cond)
  [20:54:28.241]                         for (restart in restarts) {
  [20:54:28.241]                           name <- restart$name
  [20:54:28.241]                           if (is.null(name)) 
  [20:54:28.241]                             next
  [20:54:28.241]                           if (!grepl("^muffle", name)) 
  [20:54:28.241]                             next
  [20:54:28.241]                           invokeRestart(restart)
  [20:54:28.241]                           muffled <- TRUE
  [20:54:28.241]                           break
  [20:54:28.241]                         }
  [20:54:28.241]                       }
  [20:54:28.241]                       invisible(muffled)
  [20:54:28.241]                     }
  [20:54:28.241]                     muffleCondition(cond)
  [20:54:28.241]                   }
  [20:54:28.241]                 }
  [20:54:28.241]             }
  [20:54:28.241]         }))
  [20:54:28.241]     }, error = function(ex) {
  [20:54:28.241]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.241]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.241]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.241]     }, finally = {
  [20:54:28.241]         {
  [20:54:28.241]             NULL
  [20:54:28.241]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.241]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.241]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.241]                 label = NULL, ...) 
  [20:54:28.241]             {
  [20:54:28.241]                 if (substitute) 
  [20:54:28.241]                   expr <- substitute(expr)
  [20:54:28.241]                 local <- as.logical(local)
  [20:54:28.241]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.241]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.241]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.241]                   label = label, ...)
  [20:54:28.241]                 if (!future$lazy) 
  [20:54:28.241]                   future <- run(future)
  [20:54:28.241]                 invisible(future)
  [20:54:28.241]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.241]         }
  [20:54:28.241]         base::options(...future.oldOptions)
  [20:54:28.241]     })
  [20:54:28.241]     Sys.time
  [20:54:28.241]     if (base::is.na(TRUE)) {
  [20:54:28.241]     }
  [20:54:28.241]     else {
  [20:54:28.241]         base::sink(type = "output", split = FALSE)
  [20:54:28.241]         if (TRUE) {
  [20:54:28.241]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.241]         }
  [20:54:28.241]         else {
  [20:54:28.241]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.241]         }
  [20:54:28.241]         base::close(...future.stdout)
  [20:54:28.241]         ...future.stdout <- NULL
  [20:54:28.241]     }
  [20:54:28.241]     ...future.result$conditions <- ...future.conditions
  [20:54:28.241]     ...future.result
  [20:54:28.241] }
  [20:54:28.246] plan(): Setting new future strategy stack:
  [20:54:28.246] List of future strategies:
  [20:54:28.246] 1. sequential:
  [20:54:28.246]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.246]    - tweaked: FALSE
  [20:54:28.246]    - call: NULL
  [20:54:28.247] plan(): nbrOfWorkers() = 1
  [20:54:28.248] plan(): Setting new future strategy stack:
  [20:54:28.248] List of future strategies:
  [20:54:28.248] 1. sequential:
  [20:54:28.248]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.248]    - tweaked: FALSE
  [20:54:28.248]    - call: plan(strategy)
  [20:54:28.249] plan(): nbrOfWorkers() = 1
  [20:54:28.250] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1155e890> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1196b520> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1155e890> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b1196b520> 
   $  : 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" "" ...
  [20:54:28.271] resolve() on list ...
  [20:54:28.271]  recursive: 0
  [20:54:28.271]  length: 6
  [20:54:28.271]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:28.272] signalConditionsASAP(numeric, pos=1) ...
  [20:54:28.272] - nx: 6
  [20:54:28.272] - relay: TRUE
  [20:54:28.272] - stdout: TRUE
  [20:54:28.273] - signal: TRUE
  [20:54:28.273] - resignal: FALSE
  [20:54:28.273] - force: TRUE
  [20:54:28.273] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.273] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.274]  - until=2
  [20:54:28.274]  - relaying element #2
  [20:54:28.274] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.274] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.275] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:28.275]  length: 5 (resolved future 1)
  [20:54:28.275] Future #2
  [20:54:28.276] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:28.276] - nx: 6
  [20:54:28.276] - relay: TRUE
  [20:54:28.276] - stdout: TRUE
  [20:54:28.276] - signal: TRUE
  [20:54:28.277] - resignal: FALSE
  [20:54:28.277] - force: TRUE
  [20:54:28.277] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.277] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.278]  - until=2
  [20:54:28.278]  - relaying element #2
  [20:54:28.278] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.279] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.279] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:28.279]  length: 4 (resolved future 2)
  [20:54:28.279] Future #3
  [20:54:28.280] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:28.280] - nx: 6
  [20:54:28.280] - relay: TRUE
  [20:54:28.280] - stdout: TRUE
  [20:54:28.281] - signal: TRUE
  [20:54:28.281] - resignal: FALSE
  [20:54:28.281] - force: TRUE
  [20:54:28.281] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.281] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.282]  - until=3
  [20:54:28.282]  - relaying element #3
  [20:54:28.282] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.283] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.283] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:28.283]  length: 3 (resolved future 3)
  [20:54:28.283] signalConditionsASAP(NULL, pos=4) ...
  [20:54:28.284] - nx: 6
  [20:54:28.284] - relay: TRUE
  [20:54:28.284] - stdout: TRUE
  [20:54:28.284] - signal: TRUE
  [20:54:28.285] - resignal: FALSE
  [20:54:28.285] - force: TRUE
  [20:54:28.285] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.285] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.285]  - until=5
  [20:54:28.302]  - relaying element #5
  [20:54:28.302] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.302] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.303] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:28.303]  length: 2 (resolved future 4)
  [20:54:28.303] signalConditionsASAP(NULL, pos=5) ...
  [20:54:28.303] - nx: 6
  [20:54:28.304] - relay: TRUE
  [20:54:28.304] - stdout: TRUE
  [20:54:28.304] - signal: TRUE
  [20:54:28.304] - resignal: FALSE
  [20:54:28.305] - force: TRUE
  [20:54:28.305] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.305] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.305]  - until=6
  [20:54:28.305]  - relaying element #6
  [20:54:28.306] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.306] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.306] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:28.306]  length: 1 (resolved future 5)
  [20:54:28.307] signalConditionsASAP(numeric, pos=6) ...
  [20:54:28.307] - nx: 6
  [20:54:28.307] - relay: TRUE
  [20:54:28.307] - stdout: TRUE
  [20:54:28.308] - signal: TRUE
  [20:54:28.308] - resignal: FALSE
  [20:54:28.308] - force: TRUE
  [20:54:28.308] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.308] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.309]  - until=6
  [20:54:28.309] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.309] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.309] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:28.310]  length: 0 (resolved future 6)
  [20:54:28.310] Relaying remaining futures
  [20:54:28.310] signalConditionsASAP(NULL, pos=0) ...
  [20:54:28.310] - nx: 6
  [20:54:28.311] - relay: TRUE
  [20:54:28.311] - stdout: TRUE
  [20:54:28.311] - signal: TRUE
  [20:54:28.311] - resignal: FALSE
  [20:54:28.311] - force: TRUE
  [20:54:28.312] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.312] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:28.312] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.313] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.313] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:28.313] 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)
  [20:54:28.338] getGlobalsAndPackages() ...
  [20:54:28.338] Searching for globals...
  [20:54:28.339] 
  [20:54:28.339] Searching for globals ... DONE
  [20:54:28.339] - globals: [0] <none>
  [20:54:28.340] getGlobalsAndPackages() ... DONE
  [20:54:28.341] Packages needed by the future expression (n = 0): <none>
  [20:54:28.342] Packages needed by future strategies (n = 0): <none>
  [20:54:28.365] {
  [20:54:28.365]     {
  [20:54:28.365]         ...future.startTime <- base::Sys.time()
  [20:54:28.365]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.365]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.365]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.365]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.365]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.365]         {
  [20:54:28.365]             {
  [20:54:28.365]                 has_future <- base::requireNamespace("future", 
  [20:54:28.365]                   quietly = TRUE)
  [20:54:28.365]                 version <- if (has_future) 
  [20:54:28.365]                   utils::packageVersion("future")
  [20:54:28.365]                 else NULL
  [20:54:28.365]                 if (!has_future || version < "1.8.0") {
  [20:54:28.365]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.365]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.365]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.365]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.365]                       "release", "version")], collapse = " "), 
  [20:54:28.365]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.365]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.365]                     info)
  [20:54:28.365]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.365]                   if (!has_future) {
  [20:54:28.365]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.365]                       info)
  [20:54:28.365]                   }
  [20:54:28.365]                   else {
  [20:54:28.365]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.365]                       info, version)
  [20:54:28.365]                   }
  [20:54:28.365]                   base::stop(msg)
  [20:54:28.365]                 }
  [20:54:28.365]             }
  [20:54:28.365]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.365]         }
  [20:54:28.365]     }
  [20:54:28.365]     if (base::is.na(TRUE)) {
  [20:54:28.365]     }
  [20:54:28.365]     else {
  [20:54:28.365]         if (TRUE) {
  [20:54:28.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.365]                 open = "w")
  [20:54:28.365]         }
  [20:54:28.365]         else {
  [20:54:28.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.365]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.365]         }
  [20:54:28.365]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.365]             base::sink(type = "output", split = FALSE)
  [20:54:28.365]             base::close(...future.stdout)
  [20:54:28.365]         }, add = TRUE)
  [20:54:28.365]     }
  [20:54:28.365]     ...future.frame <- base::sys.nframe()
  [20:54:28.365]     ...future.conditions <- base::list()
  [20:54:28.365]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.365]     ...future.result <- base::tryCatch({
  [20:54:28.365]         base::withCallingHandlers({
  [20:54:28.365]             ...future.value <- base::withVisible(base::local(2))
  [20:54:28.365]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.365]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.365]                 version = "1.8")
  [20:54:28.365]         }, condition = base::local({
  [20:54:28.365]             c <- base::c
  [20:54:28.365]             inherits <- base::inherits
  [20:54:28.365]             invokeRestart <- base::invokeRestart
  [20:54:28.365]             length <- base::length
  [20:54:28.365]             list <- base::list
  [20:54:28.365]             seq.int <- base::seq.int
  [20:54:28.365]             signalCondition <- base::signalCondition
  [20:54:28.365]             sys.calls <- base::sys.calls
  [20:54:28.365]             Sys.time <- base::Sys.time
  [20:54:28.365]             `[[` <- base::`[[`
  [20:54:28.365]             `+` <- base::`+`
  [20:54:28.365]             `<<-` <- base::`<<-`
  [20:54:28.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.365]                   3L)]
  [20:54:28.365]             }
  [20:54:28.365]             function(cond) {
  [20:54:28.365]                 if (inherits(cond, "error")) {
  [20:54:28.365]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.365]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.365]                   signalCondition(cond)
  [20:54:28.365]                 }
  [20:54:28.365]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.365]                 ))) {
  [20:54:28.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.365]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.365]                   if (!signal) {
  [20:54:28.365]                     muffleCondition <- function (cond) 
  [20:54:28.365]                     {
  [20:54:28.365]                       inherits <- base::inherits
  [20:54:28.365]                       invokeRestart <- base::invokeRestart
  [20:54:28.365]                       muffled <- FALSE
  [20:54:28.365]                       if (inherits(cond, "message")) {
  [20:54:28.365]                         invokeRestart("muffleMessage")
  [20:54:28.365]                         muffled <- TRUE
  [20:54:28.365]                       }
  [20:54:28.365]                       else if (inherits(cond, "warning")) {
  [20:54:28.365]                         invokeRestart("muffleWarning")
  [20:54:28.365]                         muffled <- TRUE
  [20:54:28.365]                       }
  [20:54:28.365]                       else if (inherits(cond, "condition")) {
  [20:54:28.365]                         computeRestarts <- base::computeRestarts
  [20:54:28.365]                         grepl <- base::grepl
  [20:54:28.365]                         is.null <- base::is.null
  [20:54:28.365]                         restarts <- computeRestarts(cond)
  [20:54:28.365]                         for (restart in restarts) {
  [20:54:28.365]                           name <- restart$name
  [20:54:28.365]                           if (is.null(name)) 
  [20:54:28.365]                             next
  [20:54:28.365]                           if (!grepl("^muffle", name)) 
  [20:54:28.365]                             next
  [20:54:28.365]                           invokeRestart(restart)
  [20:54:28.365]                           muffled <- TRUE
  [20:54:28.365]                           break
  [20:54:28.365]                         }
  [20:54:28.365]                       }
  [20:54:28.365]                       invisible(muffled)
  [20:54:28.365]                     }
  [20:54:28.365]                     muffleCondition(cond)
  [20:54:28.365]                   }
  [20:54:28.365]                 }
  [20:54:28.365]             }
  [20:54:28.365]         }))
  [20:54:28.365]     }, error = function(ex) {
  [20:54:28.365]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.365]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.365]     }, finally = {
  [20:54:28.365]         {
  [20:54:28.365]             NULL
  [20:54:28.365]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.365]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.365]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.365]                 label = NULL, ...) 
  [20:54:28.365]             {
  [20:54:28.365]                 if (substitute) 
  [20:54:28.365]                   expr <- substitute(expr)
  [20:54:28.365]                 local <- as.logical(local)
  [20:54:28.365]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.365]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.365]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.365]                   label = label, ...)
  [20:54:28.365]                 if (!future$lazy) 
  [20:54:28.365]                   future <- run(future)
  [20:54:28.365]                 invisible(future)
  [20:54:28.365]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.365]         }
  [20:54:28.365]         base::options(...future.oldOptions)
  [20:54:28.365]     })
  [20:54:28.365]     Sys.time
  [20:54:28.365]     if (base::is.na(TRUE)) {
  [20:54:28.365]     }
  [20:54:28.365]     else {
  [20:54:28.365]         base::sink(type = "output", split = FALSE)
  [20:54:28.365]         if (TRUE) {
  [20:54:28.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.365]         }
  [20:54:28.365]         else {
  [20:54:28.365]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.365]         }
  [20:54:28.365]         base::close(...future.stdout)
  [20:54:28.365]         ...future.stdout <- NULL
  [20:54:28.365]     }
  [20:54:28.365]     ...future.result$conditions <- ...future.conditions
  [20:54:28.365]     ...future.result
  [20:54:28.365] }
  [20:54:28.369] plan(): Setting new future strategy stack:
  [20:54:28.369] List of future strategies:
  [20:54:28.369] 1. sequential:
  [20:54:28.369]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.369]    - tweaked: FALSE
  [20:54:28.369]    - call: NULL
  [20:54:28.370] plan(): nbrOfWorkers() = 1
  [20:54:28.371] plan(): Setting new future strategy stack:
  [20:54:28.371] List of future strategies:
  [20:54:28.371] 1. sequential:
  [20:54:28.371]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.371]    - tweaked: FALSE
  [20:54:28.371]    - call: plan(strategy)
  [20:54:28.372] plan(): nbrOfWorkers() = 1
  [20:54:28.373] SequentialFuture started (and completed)
  [20:54:28.373] getGlobalsAndPackages() ...
  [20:54:28.373] Searching for globals...
  [20:54:28.374] 
  [20:54:28.374] Searching for globals ... DONE
  [20:54:28.374] - globals: [0] <none>
  [20:54:28.375] getGlobalsAndPackages() ... DONE
  [20:54:28.376] Packages needed by the future expression (n = 0): <none>
  [20:54:28.376] Packages needed by future strategies (n = 0): <none>
  [20:54:28.396] {
  [20:54:28.396]     {
  [20:54:28.396]         ...future.startTime <- base::Sys.time()
  [20:54:28.396]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:28.396]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:28.396]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:28.396]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:28.396]             future.resolve.recursive = NULL, width = 80L)
  [20:54:28.396]         {
  [20:54:28.396]             {
  [20:54:28.396]                 has_future <- base::requireNamespace("future", 
  [20:54:28.396]                   quietly = TRUE)
  [20:54:28.396]                 version <- if (has_future) 
  [20:54:28.396]                   utils::packageVersion("future")
  [20:54:28.396]                 else NULL
  [20:54:28.396]                 if (!has_future || version < "1.8.0") {
  [20:54:28.396]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:28.396]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:28.396]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:28.396]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:28.396]                       "release", "version")], collapse = " "), 
  [20:54:28.396]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:28.396]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:28.396]                     info)
  [20:54:28.396]                   info <- base::paste(info, collapse = "; ")
  [20:54:28.396]                   if (!has_future) {
  [20:54:28.396]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:28.396]                       info)
  [20:54:28.396]                   }
  [20:54:28.396]                   else {
  [20:54:28.396]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:28.396]                       info, version)
  [20:54:28.396]                   }
  [20:54:28.396]                   base::stop(msg)
  [20:54:28.396]                 }
  [20:54:28.396]             }
  [20:54:28.396]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:28.396]         }
  [20:54:28.396]     }
  [20:54:28.396]     if (base::is.na(TRUE)) {
  [20:54:28.396]     }
  [20:54:28.396]     else {
  [20:54:28.396]         if (TRUE) {
  [20:54:28.396]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:28.396]                 open = "w")
  [20:54:28.396]         }
  [20:54:28.396]         else {
  [20:54:28.396]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:28.396]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:28.396]         }
  [20:54:28.396]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:28.396]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:28.396]             base::sink(type = "output", split = FALSE)
  [20:54:28.396]             base::close(...future.stdout)
  [20:54:28.396]         }, add = TRUE)
  [20:54:28.396]     }
  [20:54:28.396]     ...future.frame <- base::sys.nframe()
  [20:54:28.396]     ...future.conditions <- base::list()
  [20:54:28.396]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:28.396]     ...future.result <- base::tryCatch({
  [20:54:28.396]         base::withCallingHandlers({
  [20:54:28.396]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:28.396]             future::FutureResult(value = ...future.value$value, 
  [20:54:28.396]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.396]                   ...future.rng), started = ...future.startTime, 
  [20:54:28.396]                 version = "1.8")
  [20:54:28.396]         }, condition = base::local({
  [20:54:28.396]             c <- base::c
  [20:54:28.396]             inherits <- base::inherits
  [20:54:28.396]             invokeRestart <- base::invokeRestart
  [20:54:28.396]             length <- base::length
  [20:54:28.396]             list <- base::list
  [20:54:28.396]             seq.int <- base::seq.int
  [20:54:28.396]             signalCondition <- base::signalCondition
  [20:54:28.396]             sys.calls <- base::sys.calls
  [20:54:28.396]             Sys.time <- base::Sys.time
  [20:54:28.396]             `[[` <- base::`[[`
  [20:54:28.396]             `+` <- base::`+`
  [20:54:28.396]             `<<-` <- base::`<<-`
  [20:54:28.396]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:28.396]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:28.396]                   3L)]
  [20:54:28.396]             }
  [20:54:28.396]             function(cond) {
  [20:54:28.396]                 if (inherits(cond, "error")) {
  [20:54:28.396]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.396]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:28.396]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:28.396]                   signalCondition(cond)
  [20:54:28.396]                 }
  [20:54:28.396]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:28.396]                 ))) {
  [20:54:28.396]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:28.396]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:28.396]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:28.396]                   if (!signal) {
  [20:54:28.396]                     muffleCondition <- function (cond) 
  [20:54:28.396]                     {
  [20:54:28.396]                       inherits <- base::inherits
  [20:54:28.396]                       invokeRestart <- base::invokeRestart
  [20:54:28.396]                       muffled <- FALSE
  [20:54:28.396]                       if (inherits(cond, "message")) {
  [20:54:28.396]                         invokeRestart("muffleMessage")
  [20:54:28.396]                         muffled <- TRUE
  [20:54:28.396]                       }
  [20:54:28.396]                       else if (inherits(cond, "warning")) {
  [20:54:28.396]                         invokeRestart("muffleWarning")
  [20:54:28.396]                         muffled <- TRUE
  [20:54:28.396]                       }
  [20:54:28.396]                       else if (inherits(cond, "condition")) {
  [20:54:28.396]                         computeRestarts <- base::computeRestarts
  [20:54:28.396]                         grepl <- base::grepl
  [20:54:28.396]                         is.null <- base::is.null
  [20:54:28.396]                         restarts <- computeRestarts(cond)
  [20:54:28.396]                         for (restart in restarts) {
  [20:54:28.396]                           name <- restart$name
  [20:54:28.396]                           if (is.null(name)) 
  [20:54:28.396]                             next
  [20:54:28.396]                           if (!grepl("^muffle", name)) 
  [20:54:28.396]                             next
  [20:54:28.396]                           invokeRestart(restart)
  [20:54:28.396]                           muffled <- TRUE
  [20:54:28.396]                           break
  [20:54:28.396]                         }
  [20:54:28.396]                       }
  [20:54:28.396]                       invisible(muffled)
  [20:54:28.396]                     }
  [20:54:28.396]                     muffleCondition(cond)
  [20:54:28.396]                   }
  [20:54:28.396]                 }
  [20:54:28.396]             }
  [20:54:28.396]         }))
  [20:54:28.396]     }, error = function(ex) {
  [20:54:28.396]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:28.396]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:28.396]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:28.396]     }, finally = {
  [20:54:28.396]         {
  [20:54:28.396]             NULL
  [20:54:28.396]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:28.396]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:28.396]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:28.396]                 label = NULL, ...) 
  [20:54:28.396]             {
  [20:54:28.396]                 if (substitute) 
  [20:54:28.396]                   expr <- substitute(expr)
  [20:54:28.396]                 local <- as.logical(local)
  [20:54:28.396]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:28.396]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:28.396]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:28.396]                   label = label, ...)
  [20:54:28.396]                 if (!future$lazy) 
  [20:54:28.396]                   future <- run(future)
  [20:54:28.396]                 invisible(future)
  [20:54:28.396]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:28.396]         }
  [20:54:28.396]         base::options(...future.oldOptions)
  [20:54:28.396]     })
  [20:54:28.396]     Sys.time
  [20:54:28.396]     if (base::is.na(TRUE)) {
  [20:54:28.396]     }
  [20:54:28.396]     else {
  [20:54:28.396]         base::sink(type = "output", split = FALSE)
  [20:54:28.396]         if (TRUE) {
  [20:54:28.396]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:28.396]         }
  [20:54:28.396]         else {
  [20:54:28.396]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:28.396]         }
  [20:54:28.396]         base::close(...future.stdout)
  [20:54:28.396]         ...future.stdout <- NULL
  [20:54:28.396]     }
  [20:54:28.396]     ...future.result$conditions <- ...future.conditions
  [20:54:28.396]     ...future.result
  [20:54:28.396] }
  [20:54:28.400] plan(): Setting new future strategy stack:
  [20:54:28.400] List of future strategies:
  [20:54:28.400] 1. sequential:
  [20:54:28.400]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.400]    - tweaked: FALSE
  [20:54:28.400]    - call: NULL
  [20:54:28.401] plan(): nbrOfWorkers() = 1
  [20:54:28.402] plan(): Setting new future strategy stack:
  [20:54:28.402] List of future strategies:
  [20:54:28.402] 1. sequential:
  [20:54:28.402]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:28.402]    - tweaked: FALSE
  [20:54:28.402]    - call: plan(strategy)
  [20:54:28.403] plan(): nbrOfWorkers() = 1
  [20:54:28.403] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11ed1380> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b109adfd8> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b11ed1380> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x556b109adfd8> 
   $  : 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" "" ...
  [20:54:28.443] resolve() on list ...
  [20:54:28.443]  recursive: 0
  [20:54:28.444]  length: 6
  [20:54:28.444]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:28.444] signalConditionsASAP(numeric, pos=1) ...
  [20:54:28.444] - nx: 6
  [20:54:28.445] - relay: TRUE
  [20:54:28.445] - stdout: TRUE
  [20:54:28.445] - signal: TRUE
  [20:54:28.445] - resignal: FALSE
  [20:54:28.445] - force: TRUE
  [20:54:28.462] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.462] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.462]  - until=2
  [20:54:28.463]  - relaying element #2
  [20:54:28.463] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.463] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.464] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:28.464]  length: 5 (resolved future 1)
  [20:54:28.464] Future #2
  [20:54:28.464] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:28.465] - nx: 6
  [20:54:28.465] - relay: TRUE
  [20:54:28.465] - stdout: TRUE
  [20:54:28.465] - signal: TRUE
  [20:54:28.466] - resignal: FALSE
  [20:54:28.466] - force: TRUE
  [20:54:28.466] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.466] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.467]  - until=2
  [20:54:28.467]  - relaying element #2
  [20:54:28.467] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.468] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.468] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:28.468]  length: 4 (resolved future 2)
  [20:54:28.469] Future #3
  [20:54:28.469] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:28.469] - nx: 6
  [20:54:28.469] - relay: TRUE
  [20:54:28.470] - stdout: TRUE
  [20:54:28.470] - signal: TRUE
  [20:54:28.470] - resignal: FALSE
  [20:54:28.470] - force: TRUE
  [20:54:28.471] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.471] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:28.489]  - until=3
  [20:54:28.489]  - relaying element #3
  [20:54:28.490] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.490] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.490] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:28.491]  length: 3 (resolved future 3)
  [20:54:28.491] signalConditionsASAP(NULL, pos=4) ...
  [20:54:28.491] - nx: 6
  [20:54:28.491] - relay: TRUE
  [20:54:28.494] - stdout: TRUE
  [20:54:28.495] - signal: TRUE
  [20:54:28.495] - resignal: FALSE
  [20:54:28.495] - force: TRUE
  [20:54:28.495] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.496] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.496]  - until=5
  [20:54:28.496]  - relaying element #5
  [20:54:28.496] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.497] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.497] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:28.497]  length: 2 (resolved future 4)
  [20:54:28.497] signalConditionsASAP(NULL, pos=5) ...
  [20:54:28.517] - nx: 6
  [20:54:28.517] - relay: TRUE
  [20:54:28.517] - stdout: TRUE
  [20:54:28.517] - signal: TRUE
  [20:54:28.518] - resignal: FALSE
  [20:54:28.518] - force: TRUE
  [20:54:28.518] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:28.518] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.518]  - until=6
  [20:54:28.519]  - relaying element #6
  [20:54:28.519] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.519] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.519] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:28.520]  length: 1 (resolved future 5)
  [20:54:28.520] signalConditionsASAP(numeric, pos=6) ...
  [20:54:28.520] - nx: 6
  [20:54:28.520] - relay: TRUE
  [20:54:28.520] - stdout: TRUE
  [20:54:28.521] - signal: TRUE
  [20:54:28.521] - resignal: FALSE
  [20:54:28.521] - force: TRUE
  [20:54:28.521] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:28.521] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.522]  - until=6
  [20:54:28.522] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.522] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.522] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:28.523]  length: 0 (resolved future 6)
  [20:54:28.523] Relaying remaining futures
  [20:54:28.523] signalConditionsASAP(NULL, pos=0) ...
  [20:54:28.523] - nx: 6
  [20:54:28.523] - relay: TRUE
  [20:54:28.524] - stdout: TRUE
  [20:54:28.524] - signal: TRUE
  [20:54:28.524] - resignal: FALSE
  [20:54:28.524] - force: TRUE
  [20:54:28.524] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.525] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:28.525] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:28.525] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:28.525] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:28.526] 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
  [20:54:28.552] plan(): Setting new future strategy stack:
  [20:54:28.552] List of future strategies:
  [20:54:28.552] 1. cluster:
  [20:54:28.552]    - 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, ...)
  [20:54:28.552]    - tweaked: FALSE
  [20:54:28.552]    - call: plan(strategy)
  [20:54:28.553] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [20:54:28.553] cluster:
  [20:54:28.553] - 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, ...)
  [20:54:28.553] - tweaked: FALSE
  [20:54:28.553] - call: plan(strategy)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 27134
  [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/RtmpmXdcvf/future.parent=13459.34933d4a79d2.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmXdcvf/future.parent=13459.34933d4a79d2.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:13459' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmXdcvf/future.parent=13459.34933d4a79d2.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27134 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
  [20:54:37.912] getGlobalsAndPackages() ...
  [20:54:37.913] Not searching for globals
  [20:54:37.913] - globals: [0] <none>
  [20:54:37.913] getGlobalsAndPackages() ... DONE
  [20:54:37.917] Packages needed by the future expression (n = 0): <none>
  [20:54:37.917] Packages needed by future strategies (n = 0): <none>
  [20:54:37.937] {
  [20:54:37.937]     {
  [20:54:37.937]         ...future.startTime <- base::Sys.time()
  [20:54:37.937]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:37.937]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:37.937]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:37.937]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:37.937]             future.resolve.recursive = NULL, width = 80L)
  [20:54:37.937]         {
  [20:54:37.937]             {
  [20:54:37.937]                 has_future <- base::requireNamespace("future", 
  [20:54:37.937]                   quietly = TRUE)
  [20:54:37.937]                 version <- if (has_future) 
  [20:54:37.937]                   utils::packageVersion("future")
  [20:54:37.937]                 else NULL
  [20:54:37.937]                 if (!has_future || version < "1.8.0") {
  [20:54:37.937]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:37.937]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:37.937]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:37.937]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:37.937]                       "release", "version")], collapse = " "), 
  [20:54:37.937]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:37.937]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:37.937]                     info)
  [20:54:37.937]                   info <- base::paste(info, collapse = "; ")
  [20:54:37.937]                   if (!has_future) {
  [20:54:37.937]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:37.937]                       info)
  [20:54:37.937]                   }
  [20:54:37.937]                   else {
  [20:54:37.937]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:37.937]                       info, version)
  [20:54:37.937]                   }
  [20:54:37.937]                   base::stop(msg)
  [20:54:37.937]                 }
  [20:54:37.937]             }
  [20:54:37.937]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:37.937]         }
  [20:54:37.937]     }
  [20:54:37.937]     if (base::is.na(TRUE)) {
  [20:54:37.937]     }
  [20:54:37.937]     else {
  [20:54:37.937]         if (TRUE) {
  [20:54:37.937]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:37.937]                 open = "w")
  [20:54:37.937]         }
  [20:54:37.937]         else {
  [20:54:37.937]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:37.937]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:37.937]         }
  [20:54:37.937]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:37.937]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:37.937]             base::sink(type = "output", split = FALSE)
  [20:54:37.937]             base::close(...future.stdout)
  [20:54:37.937]         }, add = TRUE)
  [20:54:37.937]     }
  [20:54:37.937]     ...future.frame <- base::sys.nframe()
  [20:54:37.937]     ...future.conditions <- base::list()
  [20:54:37.937]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:37.937]     ...future.result <- base::tryCatch({
  [20:54:37.937]         base::withCallingHandlers({
  [20:54:37.937]             ...future.value <- base::withVisible(base::local({
  [20:54:37.937]                 ...future.sendCondition <- local({
  [20:54:37.937]                   sendCondition <- NULL
  [20:54:37.937]                   function(frame = 1L) {
  [20:54:37.937]                     if (is.function(sendCondition)) 
  [20:54:37.937]                       return(sendCondition)
  [20:54:37.937]                     ns <- getNamespace("parallel")
  [20:54:37.937]                     if (exists("sendData", mode = "function", 
  [20:54:37.937]                       envir = ns)) {
  [20:54:37.937]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:37.937]                         envir = ns)
  [20:54:37.937]                       envir <- sys.frame(frame)
  [20:54:37.937]                       master <- NULL
  [20:54:37.937]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:37.937]                         !identical(envir, emptyenv())) {
  [20:54:37.937]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:37.937]                           inherits = FALSE)) {
  [20:54:37.937]                           master <- get("master", mode = "list", 
  [20:54:37.937]                             envir = envir, inherits = FALSE)
  [20:54:37.937]                           if (inherits(master, "SOCKnode")) {
  [20:54:37.937]                             sendCondition <<- function(cond) {
  [20:54:37.937]                               data <- list(type = "VALUE", value = cond, 
  [20:54:37.937]                                 success = TRUE)
  [20:54:37.937]                               parallel_sendData(master, data)
  [20:54:37.937]                             }
  [20:54:37.937]                             return(sendCondition)
  [20:54:37.937]                           }
  [20:54:37.937]                         }
  [20:54:37.937]                         frame <- frame + 1L
  [20:54:37.937]                         envir <- sys.frame(frame)
  [20:54:37.937]                       }
  [20:54:37.937]                     }
  [20:54:37.937]                     sendCondition <<- function(cond) NULL
  [20:54:37.937]                   }
  [20:54:37.937]                 })
  [20:54:37.937]                 withCallingHandlers({
  [20:54:37.937]                   NA
  [20:54:37.937]                 }, immediateCondition = function(cond) {
  [20:54:37.937]                   sendCondition <- ...future.sendCondition()
  [20:54:37.937]                   sendCondition(cond)
  [20:54:37.937]                   muffleCondition <- function (cond) 
  [20:54:37.937]                   {
  [20:54:37.937]                     inherits <- base::inherits
  [20:54:37.937]                     invokeRestart <- base::invokeRestart
  [20:54:37.937]                     muffled <- FALSE
  [20:54:37.937]                     if (inherits(cond, "message")) {
  [20:54:37.937]                       invokeRestart("muffleMessage")
  [20:54:37.937]                       muffled <- TRUE
  [20:54:37.937]                     }
  [20:54:37.937]                     else if (inherits(cond, "warning")) {
  [20:54:37.937]                       invokeRestart("muffleWarning")
  [20:54:37.937]                       muffled <- TRUE
  [20:54:37.937]                     }
  [20:54:37.937]                     else if (inherits(cond, "condition")) {
  [20:54:37.937]                       computeRestarts <- base::computeRestarts
  [20:54:37.937]                       grepl <- base::grepl
  [20:54:37.937]                       is.null <- base::is.null
  [20:54:37.937]                       restarts <- computeRestarts(cond)
  [20:54:37.937]                       for (restart in restarts) {
  [20:54:37.937]                         name <- restart$name
  [20:54:37.937]                         if (is.null(name)) 
  [20:54:37.937]                           next
  [20:54:37.937]                         if (!grepl("^muffle", name)) 
  [20:54:37.937]                           next
  [20:54:37.937]                         invokeRestart(restart)
  [20:54:37.937]                         muffled <- TRUE
  [20:54:37.937]                         break
  [20:54:37.937]                       }
  [20:54:37.937]                     }
  [20:54:37.937]                     invisible(muffled)
  [20:54:37.937]                   }
  [20:54:37.937]                   muffleCondition(cond)
  [20:54:37.937]                 })
  [20:54:37.937]             }))
  [20:54:37.937]             future::FutureResult(value = ...future.value$value, 
  [20:54:37.937]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:37.937]                   ...future.rng), started = ...future.startTime, 
  [20:54:37.937]                 version = "1.8")
  [20:54:37.937]         }, condition = base::local({
  [20:54:37.937]             c <- base::c
  [20:54:37.937]             inherits <- base::inherits
  [20:54:37.937]             invokeRestart <- base::invokeRestart
  [20:54:37.937]             length <- base::length
  [20:54:37.937]             list <- base::list
  [20:54:37.937]             seq.int <- base::seq.int
  [20:54:37.937]             signalCondition <- base::signalCondition
  [20:54:37.937]             sys.calls <- base::sys.calls
  [20:54:37.937]             Sys.time <- base::Sys.time
  [20:54:37.937]             `[[` <- base::`[[`
  [20:54:37.937]             `+` <- base::`+`
  [20:54:37.937]             `<<-` <- base::`<<-`
  [20:54:37.937]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:37.937]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:37.937]                   3L)]
  [20:54:37.937]             }
  [20:54:37.937]             function(cond) {
  [20:54:37.937]                 if (inherits(cond, "error")) {
  [20:54:37.937]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:37.937]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:37.937]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:37.937]                   signalCondition(cond)
  [20:54:37.937]                 }
  [20:54:37.937]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:37.937]                 ))) {
  [20:54:37.937]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:37.937]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:37.937]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:37.937]                   if (!signal) {
  [20:54:37.937]                     muffleCondition <- function (cond) 
  [20:54:37.937]                     {
  [20:54:37.937]                       inherits <- base::inherits
  [20:54:37.937]                       invokeRestart <- base::invokeRestart
  [20:54:37.937]                       muffled <- FALSE
  [20:54:37.937]                       if (inherits(cond, "message")) {
  [20:54:37.937]                         invokeRestart("muffleMessage")
  [20:54:37.937]                         muffled <- TRUE
  [20:54:37.937]                       }
  [20:54:37.937]                       else if (inherits(cond, "warning")) {
  [20:54:37.937]                         invokeRestart("muffleWarning")
  [20:54:37.937]                         muffled <- TRUE
  [20:54:37.937]                       }
  [20:54:37.937]                       else if (inherits(cond, "condition")) {
  [20:54:37.937]                         computeRestarts <- base::computeRestarts
  [20:54:37.937]                         grepl <- base::grepl
  [20:54:37.937]                         is.null <- base::is.null
  [20:54:37.937]                         restarts <- computeRestarts(cond)
  [20:54:37.937]                         for (restart in restarts) {
  [20:54:37.937]                           name <- restart$name
  [20:54:37.937]                           if (is.null(name)) 
  [20:54:37.937]                             next
  [20:54:37.937]                           if (!grepl("^muffle", name)) 
  [20:54:37.937]                             next
  [20:54:37.937]                           invokeRestart(restart)
  [20:54:37.937]                           muffled <- TRUE
  [20:54:37.937]                           break
  [20:54:37.937]                         }
  [20:54:37.937]                       }
  [20:54:37.937]                       invisible(muffled)
  [20:54:37.937]                     }
  [20:54:37.937]                     muffleCondition(cond)
  [20:54:37.937]                   }
  [20:54:37.937]                 }
  [20:54:37.937]             }
  [20:54:37.937]         }))
  [20:54:37.937]     }, error = function(ex) {
  [20:54:37.937]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:37.937]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:37.937]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:37.937]     }, finally = {
  [20:54:37.937]         {
  [20:54:37.937]             NULL
  [20:54:37.937]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:37.937]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:37.937]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:37.937]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:37.937]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:37.937]                 ...) 
  [20:54:37.937]             {
  [20:54:37.937]                 if (substitute) 
  [20:54:37.937]                   expr <- substitute(expr)
  [20:54:37.937]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:37.937]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:37.937]                   globals = globals, persistent = persistent, 
  [20:54:37.937]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:37.937]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:37.937]                   label = label, ...)
  [20:54:37.937]                 if (!future$lazy) 
  [20:54:37.937]                   future <- run(future)
  [20:54:37.937]                 invisible(future)
  [20:54:37.937]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:37.937]         }
  [20:54:37.937]         base::options(...future.oldOptions)
  [20:54:37.937]     })
  [20:54:37.937]     Sys.time
  [20:54:37.937]     if (base::is.na(TRUE)) {
  [20:54:37.937]     }
  [20:54:37.937]     else {
  [20:54:37.937]         base::sink(type = "output", split = FALSE)
  [20:54:37.937]         if (TRUE) {
  [20:54:37.937]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:37.937]         }
  [20:54:37.937]         else {
  [20:54:37.937]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:37.937]         }
  [20:54:37.937]         base::close(...future.stdout)
  [20:54:37.937]         ...future.stdout <- NULL
  [20:54:37.937]     }
  [20:54:37.937]     ...future.result$conditions <- ...future.conditions
  [20:54:37.937]     ...future.result
  [20:54:37.937] }
  [20:54:37.944] ClusterFuture started
  [20:54:37.944] result() for ClusterFuture ...
  [20:54:37.945] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:37.946] - Validating connection of ClusterFuture
  [20:54:38.149] - received message: FutureResult
  [20:54:38.150] - Received FutureResult
  [20:54:38.156] - Erased future from FutureRegistry
  [20:54:38.156] result() for ClusterFuture ...
  [20:54:38.161] - result already collected: FutureResult
  [20:54:38.162] result() for ClusterFuture ... done
  [20:54:38.163] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:38.163] result() for ClusterFuture ... done
  [20:54:38.163] result() for ClusterFuture ...
  [20:54:38.163] - result already collected: FutureResult
  [20:54:38.164] result() for ClusterFuture ... done
  [20:54:38.164] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:54:38.165] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [20:54:38.170] getGlobalsAndPackages() ...
  [20:54:38.170] Searching for globals...
  [20:54:38.171] 
  [20:54:38.171] Searching for globals ... DONE
  [20:54:38.171] - globals: [0] <none>
  [20:54:38.172] getGlobalsAndPackages() ... DONE
  [20:54:38.190] Packages needed by the future expression (n = 0): <none>
  [20:54:38.191] Packages needed by future strategies (n = 0): <none>
  [20:54:38.194] {
  [20:54:38.194]     {
  [20:54:38.194]         ...future.startTime <- base::Sys.time()
  [20:54:38.194]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.194]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.194]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.194]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.194]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.194]         {
  [20:54:38.194]             {
  [20:54:38.194]                 has_future <- base::requireNamespace("future", 
  [20:54:38.194]                   quietly = TRUE)
  [20:54:38.194]                 version <- if (has_future) 
  [20:54:38.194]                   utils::packageVersion("future")
  [20:54:38.194]                 else NULL
  [20:54:38.194]                 if (!has_future || version < "1.8.0") {
  [20:54:38.194]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.194]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.194]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.194]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.194]                       "release", "version")], collapse = " "), 
  [20:54:38.194]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.194]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.194]                     info)
  [20:54:38.194]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.194]                   if (!has_future) {
  [20:54:38.194]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.194]                       info)
  [20:54:38.194]                   }
  [20:54:38.194]                   else {
  [20:54:38.194]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.194]                       info, version)
  [20:54:38.194]                   }
  [20:54:38.194]                   base::stop(msg)
  [20:54:38.194]                 }
  [20:54:38.194]             }
  [20:54:38.194]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.194]         }
  [20:54:38.194]     }
  [20:54:38.194]     if (base::is.na(TRUE)) {
  [20:54:38.194]     }
  [20:54:38.194]     else {
  [20:54:38.194]         if (TRUE) {
  [20:54:38.194]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.194]                 open = "w")
  [20:54:38.194]         }
  [20:54:38.194]         else {
  [20:54:38.194]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.194]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.194]         }
  [20:54:38.194]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.194]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.194]             base::sink(type = "output", split = FALSE)
  [20:54:38.194]             base::close(...future.stdout)
  [20:54:38.194]         }, add = TRUE)
  [20:54:38.194]     }
  [20:54:38.194]     ...future.frame <- base::sys.nframe()
  [20:54:38.194]     ...future.conditions <- base::list()
  [20:54:38.194]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.194]     ...future.result <- base::tryCatch({
  [20:54:38.194]         base::withCallingHandlers({
  [20:54:38.194]             ...future.value <- base::withVisible(base::local({
  [20:54:38.194]                 ...future.sendCondition <- local({
  [20:54:38.194]                   sendCondition <- NULL
  [20:54:38.194]                   function(frame = 1L) {
  [20:54:38.194]                     if (is.function(sendCondition)) 
  [20:54:38.194]                       return(sendCondition)
  [20:54:38.194]                     ns <- getNamespace("parallel")
  [20:54:38.194]                     if (exists("sendData", mode = "function", 
  [20:54:38.194]                       envir = ns)) {
  [20:54:38.194]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.194]                         envir = ns)
  [20:54:38.194]                       envir <- sys.frame(frame)
  [20:54:38.194]                       master <- NULL
  [20:54:38.194]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.194]                         !identical(envir, emptyenv())) {
  [20:54:38.194]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.194]                           inherits = FALSE)) {
  [20:54:38.194]                           master <- get("master", mode = "list", 
  [20:54:38.194]                             envir = envir, inherits = FALSE)
  [20:54:38.194]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.194]                             sendCondition <<- function(cond) {
  [20:54:38.194]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.194]                                 success = TRUE)
  [20:54:38.194]                               parallel_sendData(master, data)
  [20:54:38.194]                             }
  [20:54:38.194]                             return(sendCondition)
  [20:54:38.194]                           }
  [20:54:38.194]                         }
  [20:54:38.194]                         frame <- frame + 1L
  [20:54:38.194]                         envir <- sys.frame(frame)
  [20:54:38.194]                       }
  [20:54:38.194]                     }
  [20:54:38.194]                     sendCondition <<- function(cond) NULL
  [20:54:38.194]                   }
  [20:54:38.194]                 })
  [20:54:38.194]                 withCallingHandlers({
  [20:54:38.194]                   2
  [20:54:38.194]                 }, immediateCondition = function(cond) {
  [20:54:38.194]                   sendCondition <- ...future.sendCondition()
  [20:54:38.194]                   sendCondition(cond)
  [20:54:38.194]                   muffleCondition <- function (cond) 
  [20:54:38.194]                   {
  [20:54:38.194]                     inherits <- base::inherits
  [20:54:38.194]                     invokeRestart <- base::invokeRestart
  [20:54:38.194]                     muffled <- FALSE
  [20:54:38.194]                     if (inherits(cond, "message")) {
  [20:54:38.194]                       invokeRestart("muffleMessage")
  [20:54:38.194]                       muffled <- TRUE
  [20:54:38.194]                     }
  [20:54:38.194]                     else if (inherits(cond, "warning")) {
  [20:54:38.194]                       invokeRestart("muffleWarning")
  [20:54:38.194]                       muffled <- TRUE
  [20:54:38.194]                     }
  [20:54:38.194]                     else if (inherits(cond, "condition")) {
  [20:54:38.194]                       computeRestarts <- base::computeRestarts
  [20:54:38.194]                       grepl <- base::grepl
  [20:54:38.194]                       is.null <- base::is.null
  [20:54:38.194]                       restarts <- computeRestarts(cond)
  [20:54:38.194]                       for (restart in restarts) {
  [20:54:38.194]                         name <- restart$name
  [20:54:38.194]                         if (is.null(name)) 
  [20:54:38.194]                           next
  [20:54:38.194]                         if (!grepl("^muffle", name)) 
  [20:54:38.194]                           next
  [20:54:38.194]                         invokeRestart(restart)
  [20:54:38.194]                         muffled <- TRUE
  [20:54:38.194]                         break
  [20:54:38.194]                       }
  [20:54:38.194]                     }
  [20:54:38.194]                     invisible(muffled)
  [20:54:38.194]                   }
  [20:54:38.194]                   muffleCondition(cond)
  [20:54:38.194]                 })
  [20:54:38.194]             }))
  [20:54:38.194]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.194]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.194]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.194]                 version = "1.8")
  [20:54:38.194]         }, condition = base::local({
  [20:54:38.194]             c <- base::c
  [20:54:38.194]             inherits <- base::inherits
  [20:54:38.194]             invokeRestart <- base::invokeRestart
  [20:54:38.194]             length <- base::length
  [20:54:38.194]             list <- base::list
  [20:54:38.194]             seq.int <- base::seq.int
  [20:54:38.194]             signalCondition <- base::signalCondition
  [20:54:38.194]             sys.calls <- base::sys.calls
  [20:54:38.194]             Sys.time <- base::Sys.time
  [20:54:38.194]             `[[` <- base::`[[`
  [20:54:38.194]             `+` <- base::`+`
  [20:54:38.194]             `<<-` <- base::`<<-`
  [20:54:38.194]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.194]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.194]                   3L)]
  [20:54:38.194]             }
  [20:54:38.194]             function(cond) {
  [20:54:38.194]                 if (inherits(cond, "error")) {
  [20:54:38.194]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.194]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.194]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.194]                   signalCondition(cond)
  [20:54:38.194]                 }
  [20:54:38.194]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.194]                 ))) {
  [20:54:38.194]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.194]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.194]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.194]                   if (!signal) {
  [20:54:38.194]                     muffleCondition <- function (cond) 
  [20:54:38.194]                     {
  [20:54:38.194]                       inherits <- base::inherits
  [20:54:38.194]                       invokeRestart <- base::invokeRestart
  [20:54:38.194]                       muffled <- FALSE
  [20:54:38.194]                       if (inherits(cond, "message")) {
  [20:54:38.194]                         invokeRestart("muffleMessage")
  [20:54:38.194]                         muffled <- TRUE
  [20:54:38.194]                       }
  [20:54:38.194]                       else if (inherits(cond, "warning")) {
  [20:54:38.194]                         invokeRestart("muffleWarning")
  [20:54:38.194]                         muffled <- TRUE
  [20:54:38.194]                       }
  [20:54:38.194]                       else if (inherits(cond, "condition")) {
  [20:54:38.194]                         computeRestarts <- base::computeRestarts
  [20:54:38.194]                         grepl <- base::grepl
  [20:54:38.194]                         is.null <- base::is.null
  [20:54:38.194]                         restarts <- computeRestarts(cond)
  [20:54:38.194]                         for (restart in restarts) {
  [20:54:38.194]                           name <- restart$name
  [20:54:38.194]                           if (is.null(name)) 
  [20:54:38.194]                             next
  [20:54:38.194]                           if (!grepl("^muffle", name)) 
  [20:54:38.194]                             next
  [20:54:38.194]                           invokeRestart(restart)
  [20:54:38.194]                           muffled <- TRUE
  [20:54:38.194]                           break
  [20:54:38.194]                         }
  [20:54:38.194]                       }
  [20:54:38.194]                       invisible(muffled)
  [20:54:38.194]                     }
  [20:54:38.194]                     muffleCondition(cond)
  [20:54:38.194]                   }
  [20:54:38.194]                 }
  [20:54:38.194]             }
  [20:54:38.194]         }))
  [20:54:38.194]     }, error = function(ex) {
  [20:54:38.194]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.194]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.194]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.194]     }, finally = {
  [20:54:38.194]         {
  [20:54:38.194]             NULL
  [20:54:38.194]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.194]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.194]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.194]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.194]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.194]                 ...) 
  [20:54:38.194]             {
  [20:54:38.194]                 if (substitute) 
  [20:54:38.194]                   expr <- substitute(expr)
  [20:54:38.194]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.194]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.194]                   globals = globals, persistent = persistent, 
  [20:54:38.194]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.194]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.194]                   label = label, ...)
  [20:54:38.194]                 if (!future$lazy) 
  [20:54:38.194]                   future <- run(future)
  [20:54:38.194]                 invisible(future)
  [20:54:38.194]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.194]         }
  [20:54:38.194]         base::options(...future.oldOptions)
  [20:54:38.194]     })
  [20:54:38.194]     Sys.time
  [20:54:38.194]     if (base::is.na(TRUE)) {
  [20:54:38.194]     }
  [20:54:38.194]     else {
  [20:54:38.194]         base::sink(type = "output", split = FALSE)
  [20:54:38.194]         if (TRUE) {
  [20:54:38.194]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.194]         }
  [20:54:38.194]         else {
  [20:54:38.194]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.194]         }
  [20:54:38.194]         base::close(...future.stdout)
  [20:54:38.194]         ...future.stdout <- NULL
  [20:54:38.194]     }
  [20:54:38.194]     ...future.result$conditions <- ...future.conditions
  [20:54:38.194]     ...future.result
  [20:54:38.194] }
  [20:54:38.211] ClusterFuture started
  [20:54:38.215] getGlobalsAndPackages() ...
  [20:54:38.216] Searching for globals...
  [20:54:38.216] 
  [20:54:38.217] Searching for globals ... DONE
  [20:54:38.217] - globals: [0] <none>
  [20:54:38.217] getGlobalsAndPackages() ... DONE
  [20:54:38.220] Packages needed by the future expression (n = 0): <none>
  [20:54:38.220] Packages needed by future strategies (n = 0): <none>
  [20:54:38.224] {
  [20:54:38.224]     {
  [20:54:38.224]         ...future.startTime <- base::Sys.time()
  [20:54:38.224]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.224]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.224]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.224]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.224]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.224]         {
  [20:54:38.224]             {
  [20:54:38.224]                 has_future <- base::requireNamespace("future", 
  [20:54:38.224]                   quietly = TRUE)
  [20:54:38.224]                 version <- if (has_future) 
  [20:54:38.224]                   utils::packageVersion("future")
  [20:54:38.224]                 else NULL
  [20:54:38.224]                 if (!has_future || version < "1.8.0") {
  [20:54:38.224]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.224]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.224]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.224]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.224]                       "release", "version")], collapse = " "), 
  [20:54:38.224]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.224]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.224]                     info)
  [20:54:38.224]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.224]                   if (!has_future) {
  [20:54:38.224]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.224]                       info)
  [20:54:38.224]                   }
  [20:54:38.224]                   else {
  [20:54:38.224]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.224]                       info, version)
  [20:54:38.224]                   }
  [20:54:38.224]                   base::stop(msg)
  [20:54:38.224]                 }
  [20:54:38.224]             }
  [20:54:38.224]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.224]         }
  [20:54:38.224]     }
  [20:54:38.224]     if (base::is.na(TRUE)) {
  [20:54:38.224]     }
  [20:54:38.224]     else {
  [20:54:38.224]         if (TRUE) {
  [20:54:38.224]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.224]                 open = "w")
  [20:54:38.224]         }
  [20:54:38.224]         else {
  [20:54:38.224]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.224]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.224]         }
  [20:54:38.224]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.224]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.224]             base::sink(type = "output", split = FALSE)
  [20:54:38.224]             base::close(...future.stdout)
  [20:54:38.224]         }, add = TRUE)
  [20:54:38.224]     }
  [20:54:38.224]     ...future.frame <- base::sys.nframe()
  [20:54:38.224]     ...future.conditions <- base::list()
  [20:54:38.224]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.224]     ...future.result <- base::tryCatch({
  [20:54:38.224]         base::withCallingHandlers({
  [20:54:38.224]             ...future.value <- base::withVisible(base::local({
  [20:54:38.224]                 ...future.sendCondition <- local({
  [20:54:38.224]                   sendCondition <- NULL
  [20:54:38.224]                   function(frame = 1L) {
  [20:54:38.224]                     if (is.function(sendCondition)) 
  [20:54:38.224]                       return(sendCondition)
  [20:54:38.224]                     ns <- getNamespace("parallel")
  [20:54:38.224]                     if (exists("sendData", mode = "function", 
  [20:54:38.224]                       envir = ns)) {
  [20:54:38.224]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.224]                         envir = ns)
  [20:54:38.224]                       envir <- sys.frame(frame)
  [20:54:38.224]                       master <- NULL
  [20:54:38.224]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.224]                         !identical(envir, emptyenv())) {
  [20:54:38.224]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.224]                           inherits = FALSE)) {
  [20:54:38.224]                           master <- get("master", mode = "list", 
  [20:54:38.224]                             envir = envir, inherits = FALSE)
  [20:54:38.224]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.224]                             sendCondition <<- function(cond) {
  [20:54:38.224]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.224]                                 success = TRUE)
  [20:54:38.224]                               parallel_sendData(master, data)
  [20:54:38.224]                             }
  [20:54:38.224]                             return(sendCondition)
  [20:54:38.224]                           }
  [20:54:38.224]                         }
  [20:54:38.224]                         frame <- frame + 1L
  [20:54:38.224]                         envir <- sys.frame(frame)
  [20:54:38.224]                       }
  [20:54:38.224]                     }
  [20:54:38.224]                     sendCondition <<- function(cond) NULL
  [20:54:38.224]                   }
  [20:54:38.224]                 })
  [20:54:38.224]                 withCallingHandlers({
  [20:54:38.224]                   NULL
  [20:54:38.224]                 }, immediateCondition = function(cond) {
  [20:54:38.224]                   sendCondition <- ...future.sendCondition()
  [20:54:38.224]                   sendCondition(cond)
  [20:54:38.224]                   muffleCondition <- function (cond) 
  [20:54:38.224]                   {
  [20:54:38.224]                     inherits <- base::inherits
  [20:54:38.224]                     invokeRestart <- base::invokeRestart
  [20:54:38.224]                     muffled <- FALSE
  [20:54:38.224]                     if (inherits(cond, "message")) {
  [20:54:38.224]                       invokeRestart("muffleMessage")
  [20:54:38.224]                       muffled <- TRUE
  [20:54:38.224]                     }
  [20:54:38.224]                     else if (inherits(cond, "warning")) {
  [20:54:38.224]                       invokeRestart("muffleWarning")
  [20:54:38.224]                       muffled <- TRUE
  [20:54:38.224]                     }
  [20:54:38.224]                     else if (inherits(cond, "condition")) {
  [20:54:38.224]                       computeRestarts <- base::computeRestarts
  [20:54:38.224]                       grepl <- base::grepl
  [20:54:38.224]                       is.null <- base::is.null
  [20:54:38.224]                       restarts <- computeRestarts(cond)
  [20:54:38.224]                       for (restart in restarts) {
  [20:54:38.224]                         name <- restart$name
  [20:54:38.224]                         if (is.null(name)) 
  [20:54:38.224]                           next
  [20:54:38.224]                         if (!grepl("^muffle", name)) 
  [20:54:38.224]                           next
  [20:54:38.224]                         invokeRestart(restart)
  [20:54:38.224]                         muffled <- TRUE
  [20:54:38.224]                         break
  [20:54:38.224]                       }
  [20:54:38.224]                     }
  [20:54:38.224]                     invisible(muffled)
  [20:54:38.224]                   }
  [20:54:38.224]                   muffleCondition(cond)
  [20:54:38.224]                 })
  [20:54:38.224]             }))
  [20:54:38.224]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.224]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.224]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.224]                 version = "1.8")
  [20:54:38.224]         }, condition = base::local({
  [20:54:38.224]             c <- base::c
  [20:54:38.224]             inherits <- base::inherits
  [20:54:38.224]             invokeRestart <- base::invokeRestart
  [20:54:38.224]             length <- base::length
  [20:54:38.224]             list <- base::list
  [20:54:38.224]             seq.int <- base::seq.int
  [20:54:38.224]             signalCondition <- base::signalCondition
  [20:54:38.224]             sys.calls <- base::sys.calls
  [20:54:38.224]             Sys.time <- base::Sys.time
  [20:54:38.224]             `[[` <- base::`[[`
  [20:54:38.224]             `+` <- base::`+`
  [20:54:38.224]             `<<-` <- base::`<<-`
  [20:54:38.224]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.224]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.224]                   3L)]
  [20:54:38.224]             }
  [20:54:38.224]             function(cond) {
  [20:54:38.224]                 if (inherits(cond, "error")) {
  [20:54:38.224]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.224]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.224]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.224]                   signalCondition(cond)
  [20:54:38.224]                 }
  [20:54:38.224]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.224]                 ))) {
  [20:54:38.224]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.224]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.224]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.224]                   if (!signal) {
  [20:54:38.224]                     muffleCondition <- function (cond) 
  [20:54:38.224]                     {
  [20:54:38.224]                       inherits <- base::inherits
  [20:54:38.224]                       invokeRestart <- base::invokeRestart
  [20:54:38.224]                       muffled <- FALSE
  [20:54:38.224]                       if (inherits(cond, "message")) {
  [20:54:38.224]                         invokeRestart("muffleMessage")
  [20:54:38.224]                         muffled <- TRUE
  [20:54:38.224]                       }
  [20:54:38.224]                       else if (inherits(cond, "warning")) {
  [20:54:38.224]                         invokeRestart("muffleWarning")
  [20:54:38.224]                         muffled <- TRUE
  [20:54:38.224]                       }
  [20:54:38.224]                       else if (inherits(cond, "condition")) {
  [20:54:38.224]                         computeRestarts <- base::computeRestarts
  [20:54:38.224]                         grepl <- base::grepl
  [20:54:38.224]                         is.null <- base::is.null
  [20:54:38.224]                         restarts <- computeRestarts(cond)
  [20:54:38.224]                         for (restart in restarts) {
  [20:54:38.224]                           name <- restart$name
  [20:54:38.224]                           if (is.null(name)) 
  [20:54:38.224]                             next
  [20:54:38.224]                           if (!grepl("^muffle", name)) 
  [20:54:38.224]                             next
  [20:54:38.224]                           invokeRestart(restart)
  [20:54:38.224]                           muffled <- TRUE
  [20:54:38.224]                           break
  [20:54:38.224]                         }
  [20:54:38.224]                       }
  [20:54:38.224]                       invisible(muffled)
  [20:54:38.224]                     }
  [20:54:38.224]                     muffleCondition(cond)
  [20:54:38.224]                   }
  [20:54:38.224]                 }
  [20:54:38.224]             }
  [20:54:38.224]         }))
  [20:54:38.224]     }, error = function(ex) {
  [20:54:38.224]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.224]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.224]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.224]     }, finally = {
  [20:54:38.224]         {
  [20:54:38.224]             NULL
  [20:54:38.224]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.224]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.224]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.224]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.224]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.224]                 ...) 
  [20:54:38.224]             {
  [20:54:38.224]                 if (substitute) 
  [20:54:38.224]                   expr <- substitute(expr)
  [20:54:38.224]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.224]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.224]                   globals = globals, persistent = persistent, 
  [20:54:38.224]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.224]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.224]                   label = label, ...)
  [20:54:38.224]                 if (!future$lazy) 
  [20:54:38.224]                   future <- run(future)
  [20:54:38.224]                 invisible(future)
  [20:54:38.224]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.224]         }
  [20:54:38.224]         base::options(...future.oldOptions)
  [20:54:38.224]     })
  [20:54:38.224]     Sys.time
  [20:54:38.224]     if (base::is.na(TRUE)) {
  [20:54:38.224]     }
  [20:54:38.224]     else {
  [20:54:38.224]         base::sink(type = "output", split = FALSE)
  [20:54:38.224]         if (TRUE) {
  [20:54:38.224]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.224]         }
  [20:54:38.224]         else {
  [20:54:38.224]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.224]         }
  [20:54:38.224]         base::close(...future.stdout)
  [20:54:38.224]         ...future.stdout <- NULL
  [20:54:38.224]     }
  [20:54:38.224]     ...future.result$conditions <- ...future.conditions
  [20:54:38.224]     ...future.result
  [20:54:38.224] }
  [20:54:38.245] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:38.260] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.260] - Validating connection of ClusterFuture
  [20:54:38.260] - received message: FutureResult
  [20:54:38.261] - Received FutureResult
  [20:54:38.261] - Erased future from FutureRegistry
  [20:54:38.261] result() for ClusterFuture ...
  [20:54:38.262] - result already collected: FutureResult
  [20:54:38.262] result() for ClusterFuture ... done
  [20:54:38.262] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:38.262] result() for ClusterFuture ...
  [20:54:38.263] - result already collected: FutureResult
  [20:54:38.263] result() for ClusterFuture ... done
  [20:54:38.263] result() for ClusterFuture ...
  [20:54:38.263] - result already collected: FutureResult
  [20:54:38.264] result() for ClusterFuture ... done
  [20:54:38.266] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b0fe06f98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b10af3b38> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b0fe06f98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b10af3b38> 
   $  : NULL
   $  : NULL
   $  : num 6
  [20:54:38.310] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.310] - Validating connection of ClusterFuture
  [20:54:38.310] - received message: FutureResult
  [20:54:38.311] - Received FutureResult
  [20:54:38.311] - Erased future from FutureRegistry
  [20:54:38.316] result() for ClusterFuture ...
  [20:54:38.316] - result already collected: FutureResult
  [20:54:38.316] result() for ClusterFuture ... done
  [20:54:38.317] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [20:54:38.318] resolve() on list ...
  [20:54:38.319]  recursive: 0
  [20:54:38.319]  length: 6
  [20:54:38.319]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:38.319] signalConditionsASAP(numeric, pos=1) ...
  [20:54:38.320] - nx: 6
  [20:54:38.320] - relay: TRUE
  [20:54:38.320] - stdout: TRUE
  [20:54:38.320] - signal: TRUE
  [20:54:38.320] - resignal: FALSE
  [20:54:38.321] - force: TRUE
  [20:54:38.321] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.321] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.321]  - until=2
  [20:54:38.346]  - relaying element #2
  [20:54:38.346] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.346] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.347] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:38.347]  length: 5 (resolved future 1)
  [20:54:38.347] Future #2
  [20:54:38.347] result() for ClusterFuture ...
  [20:54:38.348] - result already collected: FutureResult
  [20:54:38.348] result() for ClusterFuture ... done
  [20:54:38.348] result() for ClusterFuture ...
  [20:54:38.348] - result already collected: FutureResult
  [20:54:38.349] result() for ClusterFuture ... done
  [20:54:38.349] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:38.349] - nx: 6
  [20:54:38.349] - relay: TRUE
  [20:54:38.349] - stdout: TRUE
  [20:54:38.350] - signal: TRUE
  [20:54:38.350] - resignal: FALSE
  [20:54:38.350] - force: TRUE
  [20:54:38.350] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.351] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.351]  - until=2
  [20:54:38.351]  - relaying element #2
  [20:54:38.351] result() for ClusterFuture ...
  [20:54:38.351] - result already collected: FutureResult
  [20:54:38.352] result() for ClusterFuture ... done
  [20:54:38.352] result() for ClusterFuture ...
  [20:54:38.352] - result already collected: FutureResult
  [20:54:38.352] result() for ClusterFuture ... done
  [20:54:38.353] result() for ClusterFuture ...
  [20:54:38.353] - result already collected: FutureResult
  [20:54:38.353] result() for ClusterFuture ... done
  [20:54:38.353] result() for ClusterFuture ...
  [20:54:38.354] - result already collected: FutureResult
  [20:54:38.354] result() for ClusterFuture ... done
  [20:54:38.354] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.354] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.355] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:38.355]  length: 4 (resolved future 2)
  [20:54:38.355] Future #3
  [20:54:38.355] result() for ClusterFuture ...
  [20:54:38.356] - result already collected: FutureResult
  [20:54:38.356] result() for ClusterFuture ... done
  [20:54:38.356] result() for ClusterFuture ...
  [20:54:38.356] - result already collected: FutureResult
  [20:54:38.357] result() for ClusterFuture ... done
  [20:54:38.357] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:38.357] - nx: 6
  [20:54:38.357] - relay: TRUE
  [20:54:38.382] - stdout: TRUE
  [20:54:38.382] - signal: TRUE
  [20:54:38.382] - resignal: FALSE
  [20:54:38.383] - force: TRUE
  [20:54:38.383] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.383] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.383]  - until=3
  [20:54:38.384]  - relaying element #3
  [20:54:38.384] result() for ClusterFuture ...
  [20:54:38.384] - result already collected: FutureResult
  [20:54:38.384] result() for ClusterFuture ... done
  [20:54:38.385] result() for ClusterFuture ...
  [20:54:38.385] - result already collected: FutureResult
  [20:54:38.385] result() for ClusterFuture ... done
  [20:54:38.386] result() for ClusterFuture ...
  [20:54:38.386] - result already collected: FutureResult
  [20:54:38.386] result() for ClusterFuture ... done
  [20:54:38.387] result() for ClusterFuture ...
  [20:54:38.387] - result already collected: FutureResult
  [20:54:38.387] result() for ClusterFuture ... done
  [20:54:38.387] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.388] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.388] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:38.388]  length: 3 (resolved future 3)
  [20:54:38.388] signalConditionsASAP(NULL, pos=4) ...
  [20:54:38.389] - nx: 6
  [20:54:38.389] - relay: TRUE
  [20:54:38.389] - stdout: TRUE
  [20:54:38.389] - signal: TRUE
  [20:54:38.390] - resignal: FALSE
  [20:54:38.390] - force: TRUE
  [20:54:38.390] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.390] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.391]  - until=5
  [20:54:38.391]  - relaying element #5
  [20:54:38.391] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.391] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.392] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:38.392]  length: 2 (resolved future 4)
  [20:54:38.392] signalConditionsASAP(NULL, pos=5) ...
  [20:54:38.393] - nx: 6
  [20:54:38.393] - relay: TRUE
  [20:54:38.393] - stdout: TRUE
  [20:54:38.393] - signal: TRUE
  [20:54:38.393] - resignal: FALSE
  [20:54:38.394] - force: TRUE
  [20:54:38.394] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.394] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.395]  - until=6
  [20:54:38.395]  - relaying element #6
  [20:54:38.395] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:38.395] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.396] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:38.396]  length: 1 (resolved future 5)
  [20:54:38.396] signalConditionsASAP(numeric, pos=6) ...
  [20:54:38.396] - nx: 6
  [20:54:38.397] - relay: TRUE
  [20:54:38.397] - stdout: TRUE
  [20:54:38.397] - signal: TRUE
  [20:54:38.397] - resignal: FALSE
  [20:54:38.414] - force: TRUE
  [20:54:38.414] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:38.414] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.415]  - until=6
  [20:54:38.415] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.415] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.415] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:38.416]  length: 0 (resolved future 6)
  [20:54:38.416] Relaying remaining futures
  [20:54:38.416] signalConditionsASAP(NULL, pos=0) ...
  [20:54:38.416] - nx: 6
  [20:54:38.416] - relay: TRUE
  [20:54:38.417] - stdout: TRUE
  [20:54:38.417] - signal: TRUE
  [20:54:38.417] - resignal: FALSE
  [20:54:38.417] - force: TRUE
  [20:54:38.418] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.418] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:38.418] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.418] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.419] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:38.419] resolve() on list ... DONE
  [20:54:38.419] result() for ClusterFuture ...
  [20:54:38.420] - result already collected: FutureResult
  [20:54:38.420] result() for ClusterFuture ... done
  [20:54:38.420] result() for ClusterFuture ...
  [20:54:38.420] - result already collected: FutureResult
  [20:54:38.421] result() for ClusterFuture ... done
  [20:54:38.421] result() for ClusterFuture ...
  [20:54:38.421] - result already collected: FutureResult
  [20:54:38.421] result() for ClusterFuture ... done
  [20:54:38.422] result() for ClusterFuture ...
  [20:54:38.422] - result already collected: FutureResult
  [20:54:38.422] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [20:54:38.448] getGlobalsAndPackages() ...
  [20:54:38.448] Searching for globals...
  [20:54:38.449] 
  [20:54:38.449] Searching for globals ... DONE
  [20:54:38.450] - globals: [0] <none>
  [20:54:38.450] getGlobalsAndPackages() ... DONE
  [20:54:38.457] Packages needed by the future expression (n = 0): <none>
  [20:54:38.458] Packages needed by future strategies (n = 0): <none>
  [20:54:38.461] {
  [20:54:38.461]     {
  [20:54:38.461]         ...future.startTime <- base::Sys.time()
  [20:54:38.461]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.461]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.461]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.461]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.461]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.461]         {
  [20:54:38.461]             {
  [20:54:38.461]                 has_future <- base::requireNamespace("future", 
  [20:54:38.461]                   quietly = TRUE)
  [20:54:38.461]                 version <- if (has_future) 
  [20:54:38.461]                   utils::packageVersion("future")
  [20:54:38.461]                 else NULL
  [20:54:38.461]                 if (!has_future || version < "1.8.0") {
  [20:54:38.461]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.461]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.461]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.461]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.461]                       "release", "version")], collapse = " "), 
  [20:54:38.461]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.461]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.461]                     info)
  [20:54:38.461]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.461]                   if (!has_future) {
  [20:54:38.461]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.461]                       info)
  [20:54:38.461]                   }
  [20:54:38.461]                   else {
  [20:54:38.461]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.461]                       info, version)
  [20:54:38.461]                   }
  [20:54:38.461]                   base::stop(msg)
  [20:54:38.461]                 }
  [20:54:38.461]             }
  [20:54:38.461]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.461]         }
  [20:54:38.461]     }
  [20:54:38.461]     if (base::is.na(TRUE)) {
  [20:54:38.461]     }
  [20:54:38.461]     else {
  [20:54:38.461]         if (TRUE) {
  [20:54:38.461]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.461]                 open = "w")
  [20:54:38.461]         }
  [20:54:38.461]         else {
  [20:54:38.461]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.461]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.461]         }
  [20:54:38.461]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.461]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.461]             base::sink(type = "output", split = FALSE)
  [20:54:38.461]             base::close(...future.stdout)
  [20:54:38.461]         }, add = TRUE)
  [20:54:38.461]     }
  [20:54:38.461]     ...future.frame <- base::sys.nframe()
  [20:54:38.461]     ...future.conditions <- base::list()
  [20:54:38.461]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.461]     ...future.result <- base::tryCatch({
  [20:54:38.461]         base::withCallingHandlers({
  [20:54:38.461]             ...future.value <- base::withVisible(base::local({
  [20:54:38.461]                 ...future.sendCondition <- local({
  [20:54:38.461]                   sendCondition <- NULL
  [20:54:38.461]                   function(frame = 1L) {
  [20:54:38.461]                     if (is.function(sendCondition)) 
  [20:54:38.461]                       return(sendCondition)
  [20:54:38.461]                     ns <- getNamespace("parallel")
  [20:54:38.461]                     if (exists("sendData", mode = "function", 
  [20:54:38.461]                       envir = ns)) {
  [20:54:38.461]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.461]                         envir = ns)
  [20:54:38.461]                       envir <- sys.frame(frame)
  [20:54:38.461]                       master <- NULL
  [20:54:38.461]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.461]                         !identical(envir, emptyenv())) {
  [20:54:38.461]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.461]                           inherits = FALSE)) {
  [20:54:38.461]                           master <- get("master", mode = "list", 
  [20:54:38.461]                             envir = envir, inherits = FALSE)
  [20:54:38.461]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.461]                             sendCondition <<- function(cond) {
  [20:54:38.461]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.461]                                 success = TRUE)
  [20:54:38.461]                               parallel_sendData(master, data)
  [20:54:38.461]                             }
  [20:54:38.461]                             return(sendCondition)
  [20:54:38.461]                           }
  [20:54:38.461]                         }
  [20:54:38.461]                         frame <- frame + 1L
  [20:54:38.461]                         envir <- sys.frame(frame)
  [20:54:38.461]                       }
  [20:54:38.461]                     }
  [20:54:38.461]                     sendCondition <<- function(cond) NULL
  [20:54:38.461]                   }
  [20:54:38.461]                 })
  [20:54:38.461]                 withCallingHandlers({
  [20:54:38.461]                   2
  [20:54:38.461]                 }, immediateCondition = function(cond) {
  [20:54:38.461]                   sendCondition <- ...future.sendCondition()
  [20:54:38.461]                   sendCondition(cond)
  [20:54:38.461]                   muffleCondition <- function (cond) 
  [20:54:38.461]                   {
  [20:54:38.461]                     inherits <- base::inherits
  [20:54:38.461]                     invokeRestart <- base::invokeRestart
  [20:54:38.461]                     muffled <- FALSE
  [20:54:38.461]                     if (inherits(cond, "message")) {
  [20:54:38.461]                       invokeRestart("muffleMessage")
  [20:54:38.461]                       muffled <- TRUE
  [20:54:38.461]                     }
  [20:54:38.461]                     else if (inherits(cond, "warning")) {
  [20:54:38.461]                       invokeRestart("muffleWarning")
  [20:54:38.461]                       muffled <- TRUE
  [20:54:38.461]                     }
  [20:54:38.461]                     else if (inherits(cond, "condition")) {
  [20:54:38.461]                       computeRestarts <- base::computeRestarts
  [20:54:38.461]                       grepl <- base::grepl
  [20:54:38.461]                       is.null <- base::is.null
  [20:54:38.461]                       restarts <- computeRestarts(cond)
  [20:54:38.461]                       for (restart in restarts) {
  [20:54:38.461]                         name <- restart$name
  [20:54:38.461]                         if (is.null(name)) 
  [20:54:38.461]                           next
  [20:54:38.461]                         if (!grepl("^muffle", name)) 
  [20:54:38.461]                           next
  [20:54:38.461]                         invokeRestart(restart)
  [20:54:38.461]                         muffled <- TRUE
  [20:54:38.461]                         break
  [20:54:38.461]                       }
  [20:54:38.461]                     }
  [20:54:38.461]                     invisible(muffled)
  [20:54:38.461]                   }
  [20:54:38.461]                   muffleCondition(cond)
  [20:54:38.461]                 })
  [20:54:38.461]             }))
  [20:54:38.461]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.461]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.461]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.461]                 version = "1.8")
  [20:54:38.461]         }, condition = base::local({
  [20:54:38.461]             c <- base::c
  [20:54:38.461]             inherits <- base::inherits
  [20:54:38.461]             invokeRestart <- base::invokeRestart
  [20:54:38.461]             length <- base::length
  [20:54:38.461]             list <- base::list
  [20:54:38.461]             seq.int <- base::seq.int
  [20:54:38.461]             signalCondition <- base::signalCondition
  [20:54:38.461]             sys.calls <- base::sys.calls
  [20:54:38.461]             Sys.time <- base::Sys.time
  [20:54:38.461]             `[[` <- base::`[[`
  [20:54:38.461]             `+` <- base::`+`
  [20:54:38.461]             `<<-` <- base::`<<-`
  [20:54:38.461]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.461]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.461]                   3L)]
  [20:54:38.461]             }
  [20:54:38.461]             function(cond) {
  [20:54:38.461]                 if (inherits(cond, "error")) {
  [20:54:38.461]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.461]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.461]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.461]                   signalCondition(cond)
  [20:54:38.461]                 }
  [20:54:38.461]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.461]                 ))) {
  [20:54:38.461]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.461]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.461]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.461]                   if (!signal) {
  [20:54:38.461]                     muffleCondition <- function (cond) 
  [20:54:38.461]                     {
  [20:54:38.461]                       inherits <- base::inherits
  [20:54:38.461]                       invokeRestart <- base::invokeRestart
  [20:54:38.461]                       muffled <- FALSE
  [20:54:38.461]                       if (inherits(cond, "message")) {
  [20:54:38.461]                         invokeRestart("muffleMessage")
  [20:54:38.461]                         muffled <- TRUE
  [20:54:38.461]                       }
  [20:54:38.461]                       else if (inherits(cond, "warning")) {
  [20:54:38.461]                         invokeRestart("muffleWarning")
  [20:54:38.461]                         muffled <- TRUE
  [20:54:38.461]                       }
  [20:54:38.461]                       else if (inherits(cond, "condition")) {
  [20:54:38.461]                         computeRestarts <- base::computeRestarts
  [20:54:38.461]                         grepl <- base::grepl
  [20:54:38.461]                         is.null <- base::is.null
  [20:54:38.461]                         restarts <- computeRestarts(cond)
  [20:54:38.461]                         for (restart in restarts) {
  [20:54:38.461]                           name <- restart$name
  [20:54:38.461]                           if (is.null(name)) 
  [20:54:38.461]                             next
  [20:54:38.461]                           if (!grepl("^muffle", name)) 
  [20:54:38.461]                             next
  [20:54:38.461]                           invokeRestart(restart)
  [20:54:38.461]                           muffled <- TRUE
  [20:54:38.461]                           break
  [20:54:38.461]                         }
  [20:54:38.461]                       }
  [20:54:38.461]                       invisible(muffled)
  [20:54:38.461]                     }
  [20:54:38.461]                     muffleCondition(cond)
  [20:54:38.461]                   }
  [20:54:38.461]                 }
  [20:54:38.461]             }
  [20:54:38.461]         }))
  [20:54:38.461]     }, error = function(ex) {
  [20:54:38.461]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.461]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.461]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.461]     }, finally = {
  [20:54:38.461]         {
  [20:54:38.461]             NULL
  [20:54:38.461]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.461]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.461]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.461]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.461]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.461]                 ...) 
  [20:54:38.461]             {
  [20:54:38.461]                 if (substitute) 
  [20:54:38.461]                   expr <- substitute(expr)
  [20:54:38.461]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.461]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.461]                   globals = globals, persistent = persistent, 
  [20:54:38.461]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.461]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.461]                   label = label, ...)
  [20:54:38.461]                 if (!future$lazy) 
  [20:54:38.461]                   future <- run(future)
  [20:54:38.461]                 invisible(future)
  [20:54:38.461]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.461]         }
  [20:54:38.461]         base::options(...future.oldOptions)
  [20:54:38.461]     })
  [20:54:38.461]     Sys.time
  [20:54:38.461]     if (base::is.na(TRUE)) {
  [20:54:38.461]     }
  [20:54:38.461]     else {
  [20:54:38.461]         base::sink(type = "output", split = FALSE)
  [20:54:38.461]         if (TRUE) {
  [20:54:38.461]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.461]         }
  [20:54:38.461]         else {
  [20:54:38.461]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.461]         }
  [20:54:38.461]         base::close(...future.stdout)
  [20:54:38.461]         ...future.stdout <- NULL
  [20:54:38.461]     }
  [20:54:38.461]     ...future.result$conditions <- ...future.conditions
  [20:54:38.461]     ...future.result
  [20:54:38.461] }
  [20:54:38.484] ClusterFuture started
  [20:54:38.488] getGlobalsAndPackages() ...
  [20:54:38.489] Searching for globals...
  [20:54:38.489] 
  [20:54:38.490] Searching for globals ... DONE
  [20:54:38.490] - globals: [0] <none>
  [20:54:38.490] getGlobalsAndPackages() ... DONE
  [20:54:38.493] Packages needed by the future expression (n = 0): <none>
  [20:54:38.493] Packages needed by future strategies (n = 0): <none>
  [20:54:38.514] {
  [20:54:38.514]     {
  [20:54:38.514]         ...future.startTime <- base::Sys.time()
  [20:54:38.514]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.514]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.514]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.514]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.514]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.514]         {
  [20:54:38.514]             {
  [20:54:38.514]                 has_future <- base::requireNamespace("future", 
  [20:54:38.514]                   quietly = TRUE)
  [20:54:38.514]                 version <- if (has_future) 
  [20:54:38.514]                   utils::packageVersion("future")
  [20:54:38.514]                 else NULL
  [20:54:38.514]                 if (!has_future || version < "1.8.0") {
  [20:54:38.514]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.514]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.514]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.514]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.514]                       "release", "version")], collapse = " "), 
  [20:54:38.514]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.514]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.514]                     info)
  [20:54:38.514]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.514]                   if (!has_future) {
  [20:54:38.514]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.514]                       info)
  [20:54:38.514]                   }
  [20:54:38.514]                   else {
  [20:54:38.514]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.514]                       info, version)
  [20:54:38.514]                   }
  [20:54:38.514]                   base::stop(msg)
  [20:54:38.514]                 }
  [20:54:38.514]             }
  [20:54:38.514]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.514]         }
  [20:54:38.514]     }
  [20:54:38.514]     if (base::is.na(TRUE)) {
  [20:54:38.514]     }
  [20:54:38.514]     else {
  [20:54:38.514]         if (TRUE) {
  [20:54:38.514]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.514]                 open = "w")
  [20:54:38.514]         }
  [20:54:38.514]         else {
  [20:54:38.514]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.514]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.514]         }
  [20:54:38.514]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.514]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.514]             base::sink(type = "output", split = FALSE)
  [20:54:38.514]             base::close(...future.stdout)
  [20:54:38.514]         }, add = TRUE)
  [20:54:38.514]     }
  [20:54:38.514]     ...future.frame <- base::sys.nframe()
  [20:54:38.514]     ...future.conditions <- base::list()
  [20:54:38.514]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.514]     ...future.result <- base::tryCatch({
  [20:54:38.514]         base::withCallingHandlers({
  [20:54:38.514]             ...future.value <- base::withVisible(base::local({
  [20:54:38.514]                 ...future.sendCondition <- local({
  [20:54:38.514]                   sendCondition <- NULL
  [20:54:38.514]                   function(frame = 1L) {
  [20:54:38.514]                     if (is.function(sendCondition)) 
  [20:54:38.514]                       return(sendCondition)
  [20:54:38.514]                     ns <- getNamespace("parallel")
  [20:54:38.514]                     if (exists("sendData", mode = "function", 
  [20:54:38.514]                       envir = ns)) {
  [20:54:38.514]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.514]                         envir = ns)
  [20:54:38.514]                       envir <- sys.frame(frame)
  [20:54:38.514]                       master <- NULL
  [20:54:38.514]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.514]                         !identical(envir, emptyenv())) {
  [20:54:38.514]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.514]                           inherits = FALSE)) {
  [20:54:38.514]                           master <- get("master", mode = "list", 
  [20:54:38.514]                             envir = envir, inherits = FALSE)
  [20:54:38.514]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.514]                             sendCondition <<- function(cond) {
  [20:54:38.514]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.514]                                 success = TRUE)
  [20:54:38.514]                               parallel_sendData(master, data)
  [20:54:38.514]                             }
  [20:54:38.514]                             return(sendCondition)
  [20:54:38.514]                           }
  [20:54:38.514]                         }
  [20:54:38.514]                         frame <- frame + 1L
  [20:54:38.514]                         envir <- sys.frame(frame)
  [20:54:38.514]                       }
  [20:54:38.514]                     }
  [20:54:38.514]                     sendCondition <<- function(cond) NULL
  [20:54:38.514]                   }
  [20:54:38.514]                 })
  [20:54:38.514]                 withCallingHandlers({
  [20:54:38.514]                   NULL
  [20:54:38.514]                 }, immediateCondition = function(cond) {
  [20:54:38.514]                   sendCondition <- ...future.sendCondition()
  [20:54:38.514]                   sendCondition(cond)
  [20:54:38.514]                   muffleCondition <- function (cond) 
  [20:54:38.514]                   {
  [20:54:38.514]                     inherits <- base::inherits
  [20:54:38.514]                     invokeRestart <- base::invokeRestart
  [20:54:38.514]                     muffled <- FALSE
  [20:54:38.514]                     if (inherits(cond, "message")) {
  [20:54:38.514]                       invokeRestart("muffleMessage")
  [20:54:38.514]                       muffled <- TRUE
  [20:54:38.514]                     }
  [20:54:38.514]                     else if (inherits(cond, "warning")) {
  [20:54:38.514]                       invokeRestart("muffleWarning")
  [20:54:38.514]                       muffled <- TRUE
  [20:54:38.514]                     }
  [20:54:38.514]                     else if (inherits(cond, "condition")) {
  [20:54:38.514]                       computeRestarts <- base::computeRestarts
  [20:54:38.514]                       grepl <- base::grepl
  [20:54:38.514]                       is.null <- base::is.null
  [20:54:38.514]                       restarts <- computeRestarts(cond)
  [20:54:38.514]                       for (restart in restarts) {
  [20:54:38.514]                         name <- restart$name
  [20:54:38.514]                         if (is.null(name)) 
  [20:54:38.514]                           next
  [20:54:38.514]                         if (!grepl("^muffle", name)) 
  [20:54:38.514]                           next
  [20:54:38.514]                         invokeRestart(restart)
  [20:54:38.514]                         muffled <- TRUE
  [20:54:38.514]                         break
  [20:54:38.514]                       }
  [20:54:38.514]                     }
  [20:54:38.514]                     invisible(muffled)
  [20:54:38.514]                   }
  [20:54:38.514]                   muffleCondition(cond)
  [20:54:38.514]                 })
  [20:54:38.514]             }))
  [20:54:38.514]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.514]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.514]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.514]                 version = "1.8")
  [20:54:38.514]         }, condition = base::local({
  [20:54:38.514]             c <- base::c
  [20:54:38.514]             inherits <- base::inherits
  [20:54:38.514]             invokeRestart <- base::invokeRestart
  [20:54:38.514]             length <- base::length
  [20:54:38.514]             list <- base::list
  [20:54:38.514]             seq.int <- base::seq.int
  [20:54:38.514]             signalCondition <- base::signalCondition
  [20:54:38.514]             sys.calls <- base::sys.calls
  [20:54:38.514]             Sys.time <- base::Sys.time
  [20:54:38.514]             `[[` <- base::`[[`
  [20:54:38.514]             `+` <- base::`+`
  [20:54:38.514]             `<<-` <- base::`<<-`
  [20:54:38.514]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.514]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.514]                   3L)]
  [20:54:38.514]             }
  [20:54:38.514]             function(cond) {
  [20:54:38.514]                 if (inherits(cond, "error")) {
  [20:54:38.514]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.514]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.514]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.514]                   signalCondition(cond)
  [20:54:38.514]                 }
  [20:54:38.514]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.514]                 ))) {
  [20:54:38.514]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.514]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.514]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.514]                   if (!signal) {
  [20:54:38.514]                     muffleCondition <- function (cond) 
  [20:54:38.514]                     {
  [20:54:38.514]                       inherits <- base::inherits
  [20:54:38.514]                       invokeRestart <- base::invokeRestart
  [20:54:38.514]                       muffled <- FALSE
  [20:54:38.514]                       if (inherits(cond, "message")) {
  [20:54:38.514]                         invokeRestart("muffleMessage")
  [20:54:38.514]                         muffled <- TRUE
  [20:54:38.514]                       }
  [20:54:38.514]                       else if (inherits(cond, "warning")) {
  [20:54:38.514]                         invokeRestart("muffleWarning")
  [20:54:38.514]                         muffled <- TRUE
  [20:54:38.514]                       }
  [20:54:38.514]                       else if (inherits(cond, "condition")) {
  [20:54:38.514]                         computeRestarts <- base::computeRestarts
  [20:54:38.514]                         grepl <- base::grepl
  [20:54:38.514]                         is.null <- base::is.null
  [20:54:38.514]                         restarts <- computeRestarts(cond)
  [20:54:38.514]                         for (restart in restarts) {
  [20:54:38.514]                           name <- restart$name
  [20:54:38.514]                           if (is.null(name)) 
  [20:54:38.514]                             next
  [20:54:38.514]                           if (!grepl("^muffle", name)) 
  [20:54:38.514]                             next
  [20:54:38.514]                           invokeRestart(restart)
  [20:54:38.514]                           muffled <- TRUE
  [20:54:38.514]                           break
  [20:54:38.514]                         }
  [20:54:38.514]                       }
  [20:54:38.514]                       invisible(muffled)
  [20:54:38.514]                     }
  [20:54:38.514]                     muffleCondition(cond)
  [20:54:38.514]                   }
  [20:54:38.514]                 }
  [20:54:38.514]             }
  [20:54:38.514]         }))
  [20:54:38.514]     }, error = function(ex) {
  [20:54:38.514]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.514]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.514]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.514]     }, finally = {
  [20:54:38.514]         {
  [20:54:38.514]             NULL
  [20:54:38.514]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.514]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.514]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.514]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.514]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.514]                 ...) 
  [20:54:38.514]             {
  [20:54:38.514]                 if (substitute) 
  [20:54:38.514]                   expr <- substitute(expr)
  [20:54:38.514]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.514]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.514]                   globals = globals, persistent = persistent, 
  [20:54:38.514]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.514]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.514]                   label = label, ...)
  [20:54:38.514]                 if (!future$lazy) 
  [20:54:38.514]                   future <- run(future)
  [20:54:38.514]                 invisible(future)
  [20:54:38.514]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.514]         }
  [20:54:38.514]         base::options(...future.oldOptions)
  [20:54:38.514]     })
  [20:54:38.514]     Sys.time
  [20:54:38.514]     if (base::is.na(TRUE)) {
  [20:54:38.514]     }
  [20:54:38.514]     else {
  [20:54:38.514]         base::sink(type = "output", split = FALSE)
  [20:54:38.514]         if (TRUE) {
  [20:54:38.514]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.514]         }
  [20:54:38.514]         else {
  [20:54:38.514]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.514]         }
  [20:54:38.514]         base::close(...future.stdout)
  [20:54:38.514]         ...future.stdout <- NULL
  [20:54:38.514]     }
  [20:54:38.514]     ...future.result$conditions <- ...future.conditions
  [20:54:38.514]     ...future.result
  [20:54:38.514] }
  [20:54:38.519] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:38.581] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.581] - Validating connection of ClusterFuture
  [20:54:38.582] - received message: FutureResult
  [20:54:38.582] - Received FutureResult
  [20:54:38.582] - Erased future from FutureRegistry
  [20:54:38.582] result() for ClusterFuture ...
  [20:54:38.583] - result already collected: FutureResult
  [20:54:38.583] result() for ClusterFuture ... done
  [20:54:38.583] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:38.583] result() for ClusterFuture ...
  [20:54:38.584] - result already collected: FutureResult
  [20:54:38.584] result() for ClusterFuture ... done
  [20:54:38.584] result() for ClusterFuture ...
  [20:54:38.584] - result already collected: FutureResult
  [20:54:38.585] result() for ClusterFuture ... done
  [20:54:38.607] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11a83c38> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b0fe91c38> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11a83c38> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b0fe91c38> 
   $  : 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" ...
  [20:54:38.654] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.654] - Validating connection of ClusterFuture
  [20:54:38.655] - received message: FutureResult
  [20:54:38.655] - Received FutureResult
  [20:54:38.655] - Erased future from FutureRegistry
  [20:54:38.655] result() for ClusterFuture ...
  [20:54:38.656] - result already collected: FutureResult
  [20:54:38.656] result() for ClusterFuture ... done
  [20:54:38.656] 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" "" ...
  [20:54:38.660] resolve() on list ...
  [20:54:38.661]  recursive: 0
  [20:54:38.661]  length: 6
  [20:54:38.661]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:38.661] signalConditionsASAP(numeric, pos=1) ...
  [20:54:38.662] - nx: 6
  [20:54:38.662] - relay: TRUE
  [20:54:38.662] - stdout: TRUE
  [20:54:38.662] - signal: TRUE
  [20:54:38.663] - resignal: FALSE
  [20:54:38.663] - force: TRUE
  [20:54:38.663] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.663] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.664]  - until=2
  [20:54:38.664]  - relaying element #2
  [20:54:38.664] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.664] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.665] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:38.665]  length: 5 (resolved future 1)
  [20:54:38.665] Future #2
  [20:54:38.665] result() for ClusterFuture ...
  [20:54:38.682] - result already collected: FutureResult
  [20:54:38.682] result() for ClusterFuture ... done
  [20:54:38.682] result() for ClusterFuture ...
  [20:54:38.683] - result already collected: FutureResult
  [20:54:38.683] result() for ClusterFuture ... done
  [20:54:38.683] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:38.684] - nx: 6
  [20:54:38.684] - relay: TRUE
  [20:54:38.684] - stdout: TRUE
  [20:54:38.684] - signal: TRUE
  [20:54:38.684] - resignal: FALSE
  [20:54:38.685] - force: TRUE
  [20:54:38.685] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.685] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.686]  - until=2
  [20:54:38.686]  - relaying element #2
  [20:54:38.686] result() for ClusterFuture ...
  [20:54:38.686] - result already collected: FutureResult
  [20:54:38.687] result() for ClusterFuture ... done
  [20:54:38.687] result() for ClusterFuture ...
  [20:54:38.687] - result already collected: FutureResult
  [20:54:38.687] result() for ClusterFuture ... done
  [20:54:38.688] result() for ClusterFuture ...
  [20:54:38.688] - result already collected: FutureResult
  [20:54:38.688] result() for ClusterFuture ... done
  [20:54:38.689] result() for ClusterFuture ...
  [20:54:38.689] - result already collected: FutureResult
  [20:54:38.689] result() for ClusterFuture ... done
  [20:54:38.689] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.690] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.690] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:38.690]  length: 4 (resolved future 2)
  [20:54:38.691] Future #3
  [20:54:38.691] result() for ClusterFuture ...
  [20:54:38.691] - result already collected: FutureResult
  [20:54:38.691] result() for ClusterFuture ... done
  [20:54:38.692] result() for ClusterFuture ...
  [20:54:38.692] - result already collected: FutureResult
  [20:54:38.692] result() for ClusterFuture ... done
  [20:54:38.692] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:38.693] - nx: 6
  [20:54:38.693] - relay: TRUE
  [20:54:38.693] - stdout: TRUE
  [20:54:38.693] - signal: TRUE
  [20:54:38.703] - resignal: FALSE
  [20:54:38.703] - force: TRUE
  [20:54:38.703] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.704] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.704]  - until=3
  [20:54:38.704]  - relaying element #3
  [20:54:38.705] result() for ClusterFuture ...
  [20:54:38.705] - result already collected: FutureResult
  [20:54:38.705] result() for ClusterFuture ... done
  [20:54:38.705] result() for ClusterFuture ...
  [20:54:38.706] - result already collected: FutureResult
  [20:54:38.706] result() for ClusterFuture ... done
  [20:54:38.706] result() for ClusterFuture ...
  [20:54:38.706] - result already collected: FutureResult
  [20:54:38.707] result() for ClusterFuture ... done
  [20:54:38.707] result() for ClusterFuture ...
  [20:54:38.707] - result already collected: FutureResult
  [20:54:38.707] result() for ClusterFuture ... done
  [20:54:38.708] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.708] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.708] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:38.709]  length: 3 (resolved future 3)
  [20:54:38.709] signalConditionsASAP(NULL, pos=4) ...
  [20:54:38.709] - nx: 6
  [20:54:38.709] - relay: TRUE
  [20:54:38.710] - stdout: TRUE
  [20:54:38.710] - signal: TRUE
  [20:54:38.710] - resignal: FALSE
  [20:54:38.710] - force: TRUE
  [20:54:38.710] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.711] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.711]  - until=5
  [20:54:38.711]  - relaying element #5
  [20:54:38.712] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.712] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.712] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:38.712]  length: 2 (resolved future 4)
  [20:54:38.713] signalConditionsASAP(NULL, pos=5) ...
  [20:54:38.713] - nx: 6
  [20:54:38.713] - relay: TRUE
  [20:54:38.713] - stdout: TRUE
  [20:54:38.713] - signal: TRUE
  [20:54:38.714] - resignal: FALSE
  [20:54:38.714] - force: TRUE
  [20:54:38.714] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.714] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.715]  - until=6
  [20:54:38.715]  - relaying element #6
  [20:54:38.715] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:38.715] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.716] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:38.740]  length: 1 (resolved future 5)
  [20:54:38.741] signalConditionsASAP(numeric, pos=6) ...
  [20:54:38.741] - nx: 6
  [20:54:38.741] - relay: TRUE
  [20:54:38.741] - stdout: TRUE
  [20:54:38.742] - signal: TRUE
  [20:54:38.742] - resignal: FALSE
  [20:54:38.742] - force: TRUE
  [20:54:38.742] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:38.743] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.762]  - until=6
  [20:54:38.762] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.762] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.763] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:38.763]  length: 0 (resolved future 6)
  [20:54:38.763] Relaying remaining futures
  [20:54:38.763] signalConditionsASAP(NULL, pos=0) ...
  [20:54:38.764] - nx: 6
  [20:54:38.764] - relay: TRUE
  [20:54:38.764] - stdout: TRUE
  [20:54:38.764] - signal: TRUE
  [20:54:38.764] - resignal: FALSE
  [20:54:38.765] - force: TRUE
  [20:54:38.765] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.765] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:38.765] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:38.766] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.766] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:38.766] resolve() on list ... DONE
  [20:54:38.767] result() for ClusterFuture ...
  [20:54:38.767] - result already collected: FutureResult
  [20:54:38.767] result() for ClusterFuture ... done
  [20:54:38.767] result() for ClusterFuture ...
  [20:54:38.767] - result already collected: FutureResult
  [20:54:38.768] result() for ClusterFuture ... done
  [20:54:38.768] result() for ClusterFuture ...
  [20:54:38.768] - result already collected: FutureResult
  [20:54:38.768] result() for ClusterFuture ... done
  [20:54:38.769] result() for ClusterFuture ...
  [20:54:38.769] - result already collected: FutureResult
  [20:54:38.769] 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)
  [20:54:38.797] getGlobalsAndPackages() ...
  [20:54:38.798] Searching for globals...
  [20:54:38.798] 
  [20:54:38.798] Searching for globals ... DONE
  [20:54:38.799] - globals: [0] <none>
  [20:54:38.799] getGlobalsAndPackages() ... DONE
  [20:54:38.802] Packages needed by the future expression (n = 0): <none>
  [20:54:38.802] Packages needed by future strategies (n = 0): <none>
  [20:54:38.822] {
  [20:54:38.822]     {
  [20:54:38.822]         ...future.startTime <- base::Sys.time()
  [20:54:38.822]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.822]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.822]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.822]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.822]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.822]         {
  [20:54:38.822]             {
  [20:54:38.822]                 has_future <- base::requireNamespace("future", 
  [20:54:38.822]                   quietly = TRUE)
  [20:54:38.822]                 version <- if (has_future) 
  [20:54:38.822]                   utils::packageVersion("future")
  [20:54:38.822]                 else NULL
  [20:54:38.822]                 if (!has_future || version < "1.8.0") {
  [20:54:38.822]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.822]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.822]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.822]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.822]                       "release", "version")], collapse = " "), 
  [20:54:38.822]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.822]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.822]                     info)
  [20:54:38.822]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.822]                   if (!has_future) {
  [20:54:38.822]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.822]                       info)
  [20:54:38.822]                   }
  [20:54:38.822]                   else {
  [20:54:38.822]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.822]                       info, version)
  [20:54:38.822]                   }
  [20:54:38.822]                   base::stop(msg)
  [20:54:38.822]                 }
  [20:54:38.822]             }
  [20:54:38.822]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.822]         }
  [20:54:38.822]     }
  [20:54:38.822]     if (base::is.na(TRUE)) {
  [20:54:38.822]     }
  [20:54:38.822]     else {
  [20:54:38.822]         if (TRUE) {
  [20:54:38.822]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.822]                 open = "w")
  [20:54:38.822]         }
  [20:54:38.822]         else {
  [20:54:38.822]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.822]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.822]         }
  [20:54:38.822]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.822]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.822]             base::sink(type = "output", split = FALSE)
  [20:54:38.822]             base::close(...future.stdout)
  [20:54:38.822]         }, add = TRUE)
  [20:54:38.822]     }
  [20:54:38.822]     ...future.frame <- base::sys.nframe()
  [20:54:38.822]     ...future.conditions <- base::list()
  [20:54:38.822]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.822]     ...future.result <- base::tryCatch({
  [20:54:38.822]         base::withCallingHandlers({
  [20:54:38.822]             ...future.value <- base::withVisible(base::local({
  [20:54:38.822]                 ...future.sendCondition <- local({
  [20:54:38.822]                   sendCondition <- NULL
  [20:54:38.822]                   function(frame = 1L) {
  [20:54:38.822]                     if (is.function(sendCondition)) 
  [20:54:38.822]                       return(sendCondition)
  [20:54:38.822]                     ns <- getNamespace("parallel")
  [20:54:38.822]                     if (exists("sendData", mode = "function", 
  [20:54:38.822]                       envir = ns)) {
  [20:54:38.822]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.822]                         envir = ns)
  [20:54:38.822]                       envir <- sys.frame(frame)
  [20:54:38.822]                       master <- NULL
  [20:54:38.822]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.822]                         !identical(envir, emptyenv())) {
  [20:54:38.822]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.822]                           inherits = FALSE)) {
  [20:54:38.822]                           master <- get("master", mode = "list", 
  [20:54:38.822]                             envir = envir, inherits = FALSE)
  [20:54:38.822]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.822]                             sendCondition <<- function(cond) {
  [20:54:38.822]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.822]                                 success = TRUE)
  [20:54:38.822]                               parallel_sendData(master, data)
  [20:54:38.822]                             }
  [20:54:38.822]                             return(sendCondition)
  [20:54:38.822]                           }
  [20:54:38.822]                         }
  [20:54:38.822]                         frame <- frame + 1L
  [20:54:38.822]                         envir <- sys.frame(frame)
  [20:54:38.822]                       }
  [20:54:38.822]                     }
  [20:54:38.822]                     sendCondition <<- function(cond) NULL
  [20:54:38.822]                   }
  [20:54:38.822]                 })
  [20:54:38.822]                 withCallingHandlers({
  [20:54:38.822]                   2
  [20:54:38.822]                 }, immediateCondition = function(cond) {
  [20:54:38.822]                   sendCondition <- ...future.sendCondition()
  [20:54:38.822]                   sendCondition(cond)
  [20:54:38.822]                   muffleCondition <- function (cond) 
  [20:54:38.822]                   {
  [20:54:38.822]                     inherits <- base::inherits
  [20:54:38.822]                     invokeRestart <- base::invokeRestart
  [20:54:38.822]                     muffled <- FALSE
  [20:54:38.822]                     if (inherits(cond, "message")) {
  [20:54:38.822]                       invokeRestart("muffleMessage")
  [20:54:38.822]                       muffled <- TRUE
  [20:54:38.822]                     }
  [20:54:38.822]                     else if (inherits(cond, "warning")) {
  [20:54:38.822]                       invokeRestart("muffleWarning")
  [20:54:38.822]                       muffled <- TRUE
  [20:54:38.822]                     }
  [20:54:38.822]                     else if (inherits(cond, "condition")) {
  [20:54:38.822]                       computeRestarts <- base::computeRestarts
  [20:54:38.822]                       grepl <- base::grepl
  [20:54:38.822]                       is.null <- base::is.null
  [20:54:38.822]                       restarts <- computeRestarts(cond)
  [20:54:38.822]                       for (restart in restarts) {
  [20:54:38.822]                         name <- restart$name
  [20:54:38.822]                         if (is.null(name)) 
  [20:54:38.822]                           next
  [20:54:38.822]                         if (!grepl("^muffle", name)) 
  [20:54:38.822]                           next
  [20:54:38.822]                         invokeRestart(restart)
  [20:54:38.822]                         muffled <- TRUE
  [20:54:38.822]                         break
  [20:54:38.822]                       }
  [20:54:38.822]                     }
  [20:54:38.822]                     invisible(muffled)
  [20:54:38.822]                   }
  [20:54:38.822]                   muffleCondition(cond)
  [20:54:38.822]                 })
  [20:54:38.822]             }))
  [20:54:38.822]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.822]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.822]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.822]                 version = "1.8")
  [20:54:38.822]         }, condition = base::local({
  [20:54:38.822]             c <- base::c
  [20:54:38.822]             inherits <- base::inherits
  [20:54:38.822]             invokeRestart <- base::invokeRestart
  [20:54:38.822]             length <- base::length
  [20:54:38.822]             list <- base::list
  [20:54:38.822]             seq.int <- base::seq.int
  [20:54:38.822]             signalCondition <- base::signalCondition
  [20:54:38.822]             sys.calls <- base::sys.calls
  [20:54:38.822]             Sys.time <- base::Sys.time
  [20:54:38.822]             `[[` <- base::`[[`
  [20:54:38.822]             `+` <- base::`+`
  [20:54:38.822]             `<<-` <- base::`<<-`
  [20:54:38.822]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.822]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.822]                   3L)]
  [20:54:38.822]             }
  [20:54:38.822]             function(cond) {
  [20:54:38.822]                 if (inherits(cond, "error")) {
  [20:54:38.822]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.822]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.822]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.822]                   signalCondition(cond)
  [20:54:38.822]                 }
  [20:54:38.822]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.822]                 ))) {
  [20:54:38.822]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.822]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.822]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.822]                   if (!signal) {
  [20:54:38.822]                     muffleCondition <- function (cond) 
  [20:54:38.822]                     {
  [20:54:38.822]                       inherits <- base::inherits
  [20:54:38.822]                       invokeRestart <- base::invokeRestart
  [20:54:38.822]                       muffled <- FALSE
  [20:54:38.822]                       if (inherits(cond, "message")) {
  [20:54:38.822]                         invokeRestart("muffleMessage")
  [20:54:38.822]                         muffled <- TRUE
  [20:54:38.822]                       }
  [20:54:38.822]                       else if (inherits(cond, "warning")) {
  [20:54:38.822]                         invokeRestart("muffleWarning")
  [20:54:38.822]                         muffled <- TRUE
  [20:54:38.822]                       }
  [20:54:38.822]                       else if (inherits(cond, "condition")) {
  [20:54:38.822]                         computeRestarts <- base::computeRestarts
  [20:54:38.822]                         grepl <- base::grepl
  [20:54:38.822]                         is.null <- base::is.null
  [20:54:38.822]                         restarts <- computeRestarts(cond)
  [20:54:38.822]                         for (restart in restarts) {
  [20:54:38.822]                           name <- restart$name
  [20:54:38.822]                           if (is.null(name)) 
  [20:54:38.822]                             next
  [20:54:38.822]                           if (!grepl("^muffle", name)) 
  [20:54:38.822]                             next
  [20:54:38.822]                           invokeRestart(restart)
  [20:54:38.822]                           muffled <- TRUE
  [20:54:38.822]                           break
  [20:54:38.822]                         }
  [20:54:38.822]                       }
  [20:54:38.822]                       invisible(muffled)
  [20:54:38.822]                     }
  [20:54:38.822]                     muffleCondition(cond)
  [20:54:38.822]                   }
  [20:54:38.822]                 }
  [20:54:38.822]             }
  [20:54:38.822]         }))
  [20:54:38.822]     }, error = function(ex) {
  [20:54:38.822]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.822]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.822]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.822]     }, finally = {
  [20:54:38.822]         {
  [20:54:38.822]             NULL
  [20:54:38.822]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.822]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.822]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.822]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.822]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.822]                 ...) 
  [20:54:38.822]             {
  [20:54:38.822]                 if (substitute) 
  [20:54:38.822]                   expr <- substitute(expr)
  [20:54:38.822]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.822]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.822]                   globals = globals, persistent = persistent, 
  [20:54:38.822]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.822]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.822]                   label = label, ...)
  [20:54:38.822]                 if (!future$lazy) 
  [20:54:38.822]                   future <- run(future)
  [20:54:38.822]                 invisible(future)
  [20:54:38.822]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.822]         }
  [20:54:38.822]         base::options(...future.oldOptions)
  [20:54:38.822]     })
  [20:54:38.822]     Sys.time
  [20:54:38.822]     if (base::is.na(TRUE)) {
  [20:54:38.822]     }
  [20:54:38.822]     else {
  [20:54:38.822]         base::sink(type = "output", split = FALSE)
  [20:54:38.822]         if (TRUE) {
  [20:54:38.822]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.822]         }
  [20:54:38.822]         else {
  [20:54:38.822]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.822]         }
  [20:54:38.822]         base::close(...future.stdout)
  [20:54:38.822]         ...future.stdout <- NULL
  [20:54:38.822]     }
  [20:54:38.822]     ...future.result$conditions <- ...future.conditions
  [20:54:38.822]     ...future.result
  [20:54:38.822] }
  [20:54:38.829] ClusterFuture started
  [20:54:38.833] getGlobalsAndPackages() ...
  [20:54:38.833] Searching for globals...
  [20:54:38.834] 
  [20:54:38.834] Searching for globals ... DONE
  [20:54:38.835] - globals: [0] <none>
  [20:54:38.835] getGlobalsAndPackages() ... DONE
  [20:54:38.838] Packages needed by the future expression (n = 0): <none>
  [20:54:38.838] Packages needed by future strategies (n = 0): <none>
  [20:54:38.842] {
  [20:54:38.842]     {
  [20:54:38.842]         ...future.startTime <- base::Sys.time()
  [20:54:38.842]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:38.842]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:38.842]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:38.842]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:38.842]             future.resolve.recursive = NULL, width = 80L)
  [20:54:38.842]         {
  [20:54:38.842]             {
  [20:54:38.842]                 has_future <- base::requireNamespace("future", 
  [20:54:38.842]                   quietly = TRUE)
  [20:54:38.842]                 version <- if (has_future) 
  [20:54:38.842]                   utils::packageVersion("future")
  [20:54:38.842]                 else NULL
  [20:54:38.842]                 if (!has_future || version < "1.8.0") {
  [20:54:38.842]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:38.842]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:38.842]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:38.842]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:38.842]                       "release", "version")], collapse = " "), 
  [20:54:38.842]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:38.842]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:38.842]                     info)
  [20:54:38.842]                   info <- base::paste(info, collapse = "; ")
  [20:54:38.842]                   if (!has_future) {
  [20:54:38.842]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:38.842]                       info)
  [20:54:38.842]                   }
  [20:54:38.842]                   else {
  [20:54:38.842]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:38.842]                       info, version)
  [20:54:38.842]                   }
  [20:54:38.842]                   base::stop(msg)
  [20:54:38.842]                 }
  [20:54:38.842]             }
  [20:54:38.842]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:38.842]         }
  [20:54:38.842]     }
  [20:54:38.842]     if (base::is.na(TRUE)) {
  [20:54:38.842]     }
  [20:54:38.842]     else {
  [20:54:38.842]         if (TRUE) {
  [20:54:38.842]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:38.842]                 open = "w")
  [20:54:38.842]         }
  [20:54:38.842]         else {
  [20:54:38.842]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:38.842]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:38.842]         }
  [20:54:38.842]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:38.842]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:38.842]             base::sink(type = "output", split = FALSE)
  [20:54:38.842]             base::close(...future.stdout)
  [20:54:38.842]         }, add = TRUE)
  [20:54:38.842]     }
  [20:54:38.842]     ...future.frame <- base::sys.nframe()
  [20:54:38.842]     ...future.conditions <- base::list()
  [20:54:38.842]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:38.842]     ...future.result <- base::tryCatch({
  [20:54:38.842]         base::withCallingHandlers({
  [20:54:38.842]             ...future.value <- base::withVisible(base::local({
  [20:54:38.842]                 ...future.sendCondition <- local({
  [20:54:38.842]                   sendCondition <- NULL
  [20:54:38.842]                   function(frame = 1L) {
  [20:54:38.842]                     if (is.function(sendCondition)) 
  [20:54:38.842]                       return(sendCondition)
  [20:54:38.842]                     ns <- getNamespace("parallel")
  [20:54:38.842]                     if (exists("sendData", mode = "function", 
  [20:54:38.842]                       envir = ns)) {
  [20:54:38.842]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:38.842]                         envir = ns)
  [20:54:38.842]                       envir <- sys.frame(frame)
  [20:54:38.842]                       master <- NULL
  [20:54:38.842]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:38.842]                         !identical(envir, emptyenv())) {
  [20:54:38.842]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:38.842]                           inherits = FALSE)) {
  [20:54:38.842]                           master <- get("master", mode = "list", 
  [20:54:38.842]                             envir = envir, inherits = FALSE)
  [20:54:38.842]                           if (inherits(master, "SOCKnode")) {
  [20:54:38.842]                             sendCondition <<- function(cond) {
  [20:54:38.842]                               data <- list(type = "VALUE", value = cond, 
  [20:54:38.842]                                 success = TRUE)
  [20:54:38.842]                               parallel_sendData(master, data)
  [20:54:38.842]                             }
  [20:54:38.842]                             return(sendCondition)
  [20:54:38.842]                           }
  [20:54:38.842]                         }
  [20:54:38.842]                         frame <- frame + 1L
  [20:54:38.842]                         envir <- sys.frame(frame)
  [20:54:38.842]                       }
  [20:54:38.842]                     }
  [20:54:38.842]                     sendCondition <<- function(cond) NULL
  [20:54:38.842]                   }
  [20:54:38.842]                 })
  [20:54:38.842]                 withCallingHandlers({
  [20:54:38.842]                   NULL
  [20:54:38.842]                 }, immediateCondition = function(cond) {
  [20:54:38.842]                   sendCondition <- ...future.sendCondition()
  [20:54:38.842]                   sendCondition(cond)
  [20:54:38.842]                   muffleCondition <- function (cond) 
  [20:54:38.842]                   {
  [20:54:38.842]                     inherits <- base::inherits
  [20:54:38.842]                     invokeRestart <- base::invokeRestart
  [20:54:38.842]                     muffled <- FALSE
  [20:54:38.842]                     if (inherits(cond, "message")) {
  [20:54:38.842]                       invokeRestart("muffleMessage")
  [20:54:38.842]                       muffled <- TRUE
  [20:54:38.842]                     }
  [20:54:38.842]                     else if (inherits(cond, "warning")) {
  [20:54:38.842]                       invokeRestart("muffleWarning")
  [20:54:38.842]                       muffled <- TRUE
  [20:54:38.842]                     }
  [20:54:38.842]                     else if (inherits(cond, "condition")) {
  [20:54:38.842]                       computeRestarts <- base::computeRestarts
  [20:54:38.842]                       grepl <- base::grepl
  [20:54:38.842]                       is.null <- base::is.null
  [20:54:38.842]                       restarts <- computeRestarts(cond)
  [20:54:38.842]                       for (restart in restarts) {
  [20:54:38.842]                         name <- restart$name
  [20:54:38.842]                         if (is.null(name)) 
  [20:54:38.842]                           next
  [20:54:38.842]                         if (!grepl("^muffle", name)) 
  [20:54:38.842]                           next
  [20:54:38.842]                         invokeRestart(restart)
  [20:54:38.842]                         muffled <- TRUE
  [20:54:38.842]                         break
  [20:54:38.842]                       }
  [20:54:38.842]                     }
  [20:54:38.842]                     invisible(muffled)
  [20:54:38.842]                   }
  [20:54:38.842]                   muffleCondition(cond)
  [20:54:38.842]                 })
  [20:54:38.842]             }))
  [20:54:38.842]             future::FutureResult(value = ...future.value$value, 
  [20:54:38.842]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.842]                   ...future.rng), started = ...future.startTime, 
  [20:54:38.842]                 version = "1.8")
  [20:54:38.842]         }, condition = base::local({
  [20:54:38.842]             c <- base::c
  [20:54:38.842]             inherits <- base::inherits
  [20:54:38.842]             invokeRestart <- base::invokeRestart
  [20:54:38.842]             length <- base::length
  [20:54:38.842]             list <- base::list
  [20:54:38.842]             seq.int <- base::seq.int
  [20:54:38.842]             signalCondition <- base::signalCondition
  [20:54:38.842]             sys.calls <- base::sys.calls
  [20:54:38.842]             Sys.time <- base::Sys.time
  [20:54:38.842]             `[[` <- base::`[[`
  [20:54:38.842]             `+` <- base::`+`
  [20:54:38.842]             `<<-` <- base::`<<-`
  [20:54:38.842]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:38.842]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:38.842]                   3L)]
  [20:54:38.842]             }
  [20:54:38.842]             function(cond) {
  [20:54:38.842]                 if (inherits(cond, "error")) {
  [20:54:38.842]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.842]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:38.842]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:38.842]                   signalCondition(cond)
  [20:54:38.842]                 }
  [20:54:38.842]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:38.842]                 ))) {
  [20:54:38.842]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:38.842]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:38.842]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:38.842]                   if (!signal) {
  [20:54:38.842]                     muffleCondition <- function (cond) 
  [20:54:38.842]                     {
  [20:54:38.842]                       inherits <- base::inherits
  [20:54:38.842]                       invokeRestart <- base::invokeRestart
  [20:54:38.842]                       muffled <- FALSE
  [20:54:38.842]                       if (inherits(cond, "message")) {
  [20:54:38.842]                         invokeRestart("muffleMessage")
  [20:54:38.842]                         muffled <- TRUE
  [20:54:38.842]                       }
  [20:54:38.842]                       else if (inherits(cond, "warning")) {
  [20:54:38.842]                         invokeRestart("muffleWarning")
  [20:54:38.842]                         muffled <- TRUE
  [20:54:38.842]                       }
  [20:54:38.842]                       else if (inherits(cond, "condition")) {
  [20:54:38.842]                         computeRestarts <- base::computeRestarts
  [20:54:38.842]                         grepl <- base::grepl
  [20:54:38.842]                         is.null <- base::is.null
  [20:54:38.842]                         restarts <- computeRestarts(cond)
  [20:54:38.842]                         for (restart in restarts) {
  [20:54:38.842]                           name <- restart$name
  [20:54:38.842]                           if (is.null(name)) 
  [20:54:38.842]                             next
  [20:54:38.842]                           if (!grepl("^muffle", name)) 
  [20:54:38.842]                             next
  [20:54:38.842]                           invokeRestart(restart)
  [20:54:38.842]                           muffled <- TRUE
  [20:54:38.842]                           break
  [20:54:38.842]                         }
  [20:54:38.842]                       }
  [20:54:38.842]                       invisible(muffled)
  [20:54:38.842]                     }
  [20:54:38.842]                     muffleCondition(cond)
  [20:54:38.842]                   }
  [20:54:38.842]                 }
  [20:54:38.842]             }
  [20:54:38.842]         }))
  [20:54:38.842]     }, error = function(ex) {
  [20:54:38.842]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:38.842]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:38.842]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:38.842]     }, finally = {
  [20:54:38.842]         {
  [20:54:38.842]             NULL
  [20:54:38.842]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:38.842]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:38.842]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:38.842]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:38.842]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:38.842]                 ...) 
  [20:54:38.842]             {
  [20:54:38.842]                 if (substitute) 
  [20:54:38.842]                   expr <- substitute(expr)
  [20:54:38.842]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:38.842]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:38.842]                   globals = globals, persistent = persistent, 
  [20:54:38.842]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:38.842]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:38.842]                   label = label, ...)
  [20:54:38.842]                 if (!future$lazy) 
  [20:54:38.842]                   future <- run(future)
  [20:54:38.842]                 invisible(future)
  [20:54:38.842]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:38.842]         }
  [20:54:38.842]         base::options(...future.oldOptions)
  [20:54:38.842]     })
  [20:54:38.842]     Sys.time
  [20:54:38.842]     if (base::is.na(TRUE)) {
  [20:54:38.842]     }
  [20:54:38.842]     else {
  [20:54:38.842]         base::sink(type = "output", split = FALSE)
  [20:54:38.842]         if (TRUE) {
  [20:54:38.842]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:38.842]         }
  [20:54:38.842]         else {
  [20:54:38.842]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:38.842]         }
  [20:54:38.842]         base::close(...future.stdout)
  [20:54:38.842]         ...future.stdout <- NULL
  [20:54:38.842]     }
  [20:54:38.842]     ...future.result$conditions <- ...future.conditions
  [20:54:38.842]     ...future.result
  [20:54:38.842] }
  [20:54:38.846] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:38.874] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.874] - Validating connection of ClusterFuture
  [20:54:38.879] - received message: FutureResult
  [20:54:38.879] - Received FutureResult
  [20:54:38.879] - Erased future from FutureRegistry
  [20:54:38.879] result() for ClusterFuture ...
  [20:54:38.880] - result already collected: FutureResult
  [20:54:38.880] result() for ClusterFuture ... done
  [20:54:38.880] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:38.881] result() for ClusterFuture ...
  [20:54:38.881] - result already collected: FutureResult
  [20:54:38.881] result() for ClusterFuture ... done
  [20:54:38.882] result() for ClusterFuture ...
  [20:54:38.882] - result already collected: FutureResult
  [20:54:38.882] result() for ClusterFuture ... done
  [20:54:38.884] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b112dc240> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11878818> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b112dc240> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11878818> 
   $  : 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"
  [20:54:38.930] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:38.930] - Validating connection of ClusterFuture
  [20:54:38.930] - received message: FutureResult
  [20:54:38.931] - Received FutureResult
  [20:54:38.931] - Erased future from FutureRegistry
  [20:54:38.931] result() for ClusterFuture ...
  [20:54:38.932] - result already collected: FutureResult
  [20:54:38.932] result() for ClusterFuture ... done
  [20:54:38.932] 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" "" ...
  [20:54:38.936] resolve() on list ...
  [20:54:38.936]  recursive: 0
  [20:54:38.937]  length: 6
  [20:54:38.937]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:38.937] signalConditionsASAP(numeric, pos=1) ...
  [20:54:38.937] - nx: 6
  [20:54:38.937] - relay: TRUE
  [20:54:38.938] - stdout: TRUE
  [20:54:38.938] - signal: TRUE
  [20:54:38.938] - resignal: FALSE
  [20:54:38.938] - force: TRUE
  [20:54:38.939] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.939] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.939]  - until=2
  [20:54:38.939]  - relaying element #2
  [20:54:38.940] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.940] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.940] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:38.940]  length: 5 (resolved future 1)
  [20:54:38.941] Future #2
  [20:54:38.941] result() for ClusterFuture ...
  [20:54:38.941] - result already collected: FutureResult
  [20:54:38.941] result() for ClusterFuture ... done
  [20:54:38.958] result() for ClusterFuture ...
  [20:54:38.958] - result already collected: FutureResult
  [20:54:38.958] result() for ClusterFuture ... done
  [20:54:38.959] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:38.959] - nx: 6
  [20:54:38.959] - relay: TRUE
  [20:54:38.959] - stdout: TRUE
  [20:54:38.960] - signal: TRUE
  [20:54:38.960] - resignal: FALSE
  [20:54:38.960] - force: TRUE
  [20:54:38.960] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.960] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.961]  - until=2
  [20:54:38.961]  - relaying element #2
  [20:54:38.961] result() for ClusterFuture ...
  [20:54:38.961] - result already collected: FutureResult
  [20:54:38.962] result() for ClusterFuture ... done
  [20:54:38.962] result() for ClusterFuture ...
  [20:54:38.962] - result already collected: FutureResult
  [20:54:38.962] result() for ClusterFuture ... done
  [20:54:38.963] result() for ClusterFuture ...
  [20:54:38.963] - result already collected: FutureResult
  [20:54:38.963] result() for ClusterFuture ... done
  [20:54:38.963] result() for ClusterFuture ...
  [20:54:38.964] - result already collected: FutureResult
  [20:54:38.964] result() for ClusterFuture ... done
  [20:54:38.964] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.964] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.965] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:38.965]  length: 4 (resolved future 2)
  [20:54:38.965] Future #3
  [20:54:38.965] result() for ClusterFuture ...
  [20:54:38.966] - result already collected: FutureResult
  [20:54:38.966] result() for ClusterFuture ... done
  [20:54:38.966] result() for ClusterFuture ...
  [20:54:38.966] - result already collected: FutureResult
  [20:54:38.967] result() for ClusterFuture ... done
  [20:54:38.967] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:38.967] - nx: 6
  [20:54:38.967] - relay: TRUE
  [20:54:38.968] - stdout: TRUE
  [20:54:38.968] - signal: TRUE
  [20:54:38.968] - resignal: FALSE
  [20:54:38.968] - force: TRUE
  [20:54:38.968] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.969] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:38.969]  - until=3
  [20:54:38.969]  - relaying element #3
  [20:54:38.969] result() for ClusterFuture ...
  [20:54:38.970] - result already collected: FutureResult
  [20:54:38.970] result() for ClusterFuture ... done
  [20:54:38.970] result() for ClusterFuture ...
  [20:54:38.970] - result already collected: FutureResult
  [20:54:38.971] result() for ClusterFuture ... done
  [20:54:38.971] result() for ClusterFuture ...
  [20:54:38.971] - result already collected: FutureResult
  [20:54:38.972] result() for ClusterFuture ... done
  [20:54:38.972] result() for ClusterFuture ...
  [20:54:38.972] - result already collected: FutureResult
  [20:54:38.972] result() for ClusterFuture ... done
  [20:54:38.972] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.973] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.973] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:38.973]  length: 3 (resolved future 3)
  [20:54:38.973] signalConditionsASAP(NULL, pos=4) ...
  [20:54:38.990] - nx: 6
  [20:54:38.990] - relay: TRUE
  [20:54:38.990] - stdout: TRUE
  [20:54:38.991] - signal: TRUE
  [20:54:38.991] - resignal: FALSE
  [20:54:38.991] - force: TRUE
  [20:54:38.991] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.991] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.992]  - until=5
  [20:54:38.992]  - relaying element #5
  [20:54:38.996] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.997] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.997] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:38.997]  length: 2 (resolved future 4)
  [20:54:38.997] signalConditionsASAP(NULL, pos=5) ...
  [20:54:38.998] - nx: 6
  [20:54:38.998] - relay: TRUE
  [20:54:38.998] - stdout: TRUE
  [20:54:38.998] - signal: TRUE
  [20:54:38.999] - resignal: FALSE
  [20:54:38.999] - force: TRUE
  [20:54:38.999] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:38.999] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:38.999]  - until=6
  [20:54:39.000]  - relaying element #6
  [20:54:39.000] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.000] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.000] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:39.001]  length: 1 (resolved future 5)
  [20:54:39.001] signalConditionsASAP(numeric, pos=6) ...
  [20:54:39.001] - nx: 6
  [20:54:39.001] - relay: TRUE
  [20:54:39.002] - stdout: TRUE
  [20:54:39.002] - signal: TRUE
  [20:54:39.002] - resignal: FALSE
  [20:54:39.002] - force: TRUE
  [20:54:39.002] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.003] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.003]  - until=6
  [20:54:39.003] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.003] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.004] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:39.004]  length: 0 (resolved future 6)
  [20:54:39.004] Relaying remaining futures
  [20:54:39.004] signalConditionsASAP(NULL, pos=0) ...
  [20:54:39.004] - nx: 6
  [20:54:39.005] - relay: TRUE
  [20:54:39.005] - stdout: TRUE
  [20:54:39.005] - signal: TRUE
  [20:54:39.005] - resignal: FALSE
  [20:54:39.005] - force: TRUE
  [20:54:39.009] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.009] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:39.010] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.010] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.010] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:39.011] resolve() on list ... DONE
  [20:54:39.011] result() for ClusterFuture ...
  [20:54:39.011] - result already collected: FutureResult
  [20:54:39.011] result() for ClusterFuture ... done
  [20:54:39.012] result() for ClusterFuture ...
  [20:54:39.012] - result already collected: FutureResult
  [20:54:39.012] result() for ClusterFuture ... done
  [20:54:39.012] result() for ClusterFuture ...
  [20:54:39.013] - result already collected: FutureResult
  [20:54:39.013] result() for ClusterFuture ... done
  [20:54:39.013] result() for ClusterFuture ...
  [20:54:39.013] - result already collected: FutureResult
  [20:54:39.013] 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)
  [20:54:39.040] getGlobalsAndPackages() ...
  [20:54:39.040] Searching for globals...
  [20:54:39.041] 
  [20:54:39.041] Searching for globals ... DONE
  [20:54:39.041] - globals: [0] <none>
  [20:54:39.042] getGlobalsAndPackages() ... DONE
  [20:54:39.045] Packages needed by the future expression (n = 0): <none>
  [20:54:39.045] Packages needed by future strategies (n = 0): <none>
  [20:54:39.049] {
  [20:54:39.049]     {
  [20:54:39.049]         ...future.startTime <- base::Sys.time()
  [20:54:39.049]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.049]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.049]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.049]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.049]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.049]         {
  [20:54:39.049]             {
  [20:54:39.049]                 has_future <- base::requireNamespace("future", 
  [20:54:39.049]                   quietly = TRUE)
  [20:54:39.049]                 version <- if (has_future) 
  [20:54:39.049]                   utils::packageVersion("future")
  [20:54:39.049]                 else NULL
  [20:54:39.049]                 if (!has_future || version < "1.8.0") {
  [20:54:39.049]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.049]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.049]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.049]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.049]                       "release", "version")], collapse = " "), 
  [20:54:39.049]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.049]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.049]                     info)
  [20:54:39.049]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.049]                   if (!has_future) {
  [20:54:39.049]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.049]                       info)
  [20:54:39.049]                   }
  [20:54:39.049]                   else {
  [20:54:39.049]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.049]                       info, version)
  [20:54:39.049]                   }
  [20:54:39.049]                   base::stop(msg)
  [20:54:39.049]                 }
  [20:54:39.049]             }
  [20:54:39.049]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.049]         }
  [20:54:39.049]     }
  [20:54:39.049]     if (base::is.na(TRUE)) {
  [20:54:39.049]     }
  [20:54:39.049]     else {
  [20:54:39.049]         if (TRUE) {
  [20:54:39.049]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.049]                 open = "w")
  [20:54:39.049]         }
  [20:54:39.049]         else {
  [20:54:39.049]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.049]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.049]         }
  [20:54:39.049]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.049]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.049]             base::sink(type = "output", split = FALSE)
  [20:54:39.049]             base::close(...future.stdout)
  [20:54:39.049]         }, add = TRUE)
  [20:54:39.049]     }
  [20:54:39.049]     ...future.frame <- base::sys.nframe()
  [20:54:39.049]     ...future.conditions <- base::list()
  [20:54:39.049]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.049]     ...future.result <- base::tryCatch({
  [20:54:39.049]         base::withCallingHandlers({
  [20:54:39.049]             ...future.value <- base::withVisible(base::local({
  [20:54:39.049]                 ...future.sendCondition <- local({
  [20:54:39.049]                   sendCondition <- NULL
  [20:54:39.049]                   function(frame = 1L) {
  [20:54:39.049]                     if (is.function(sendCondition)) 
  [20:54:39.049]                       return(sendCondition)
  [20:54:39.049]                     ns <- getNamespace("parallel")
  [20:54:39.049]                     if (exists("sendData", mode = "function", 
  [20:54:39.049]                       envir = ns)) {
  [20:54:39.049]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:39.049]                         envir = ns)
  [20:54:39.049]                       envir <- sys.frame(frame)
  [20:54:39.049]                       master <- NULL
  [20:54:39.049]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:39.049]                         !identical(envir, emptyenv())) {
  [20:54:39.049]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:39.049]                           inherits = FALSE)) {
  [20:54:39.049]                           master <- get("master", mode = "list", 
  [20:54:39.049]                             envir = envir, inherits = FALSE)
  [20:54:39.049]                           if (inherits(master, "SOCKnode")) {
  [20:54:39.049]                             sendCondition <<- function(cond) {
  [20:54:39.049]                               data <- list(type = "VALUE", value = cond, 
  [20:54:39.049]                                 success = TRUE)
  [20:54:39.049]                               parallel_sendData(master, data)
  [20:54:39.049]                             }
  [20:54:39.049]                             return(sendCondition)
  [20:54:39.049]                           }
  [20:54:39.049]                         }
  [20:54:39.049]                         frame <- frame + 1L
  [20:54:39.049]                         envir <- sys.frame(frame)
  [20:54:39.049]                       }
  [20:54:39.049]                     }
  [20:54:39.049]                     sendCondition <<- function(cond) NULL
  [20:54:39.049]                   }
  [20:54:39.049]                 })
  [20:54:39.049]                 withCallingHandlers({
  [20:54:39.049]                   2
  [20:54:39.049]                 }, immediateCondition = function(cond) {
  [20:54:39.049]                   sendCondition <- ...future.sendCondition()
  [20:54:39.049]                   sendCondition(cond)
  [20:54:39.049]                   muffleCondition <- function (cond) 
  [20:54:39.049]                   {
  [20:54:39.049]                     inherits <- base::inherits
  [20:54:39.049]                     invokeRestart <- base::invokeRestart
  [20:54:39.049]                     muffled <- FALSE
  [20:54:39.049]                     if (inherits(cond, "message")) {
  [20:54:39.049]                       invokeRestart("muffleMessage")
  [20:54:39.049]                       muffled <- TRUE
  [20:54:39.049]                     }
  [20:54:39.049]                     else if (inherits(cond, "warning")) {
  [20:54:39.049]                       invokeRestart("muffleWarning")
  [20:54:39.049]                       muffled <- TRUE
  [20:54:39.049]                     }
  [20:54:39.049]                     else if (inherits(cond, "condition")) {
  [20:54:39.049]                       computeRestarts <- base::computeRestarts
  [20:54:39.049]                       grepl <- base::grepl
  [20:54:39.049]                       is.null <- base::is.null
  [20:54:39.049]                       restarts <- computeRestarts(cond)
  [20:54:39.049]                       for (restart in restarts) {
  [20:54:39.049]                         name <- restart$name
  [20:54:39.049]                         if (is.null(name)) 
  [20:54:39.049]                           next
  [20:54:39.049]                         if (!grepl("^muffle", name)) 
  [20:54:39.049]                           next
  [20:54:39.049]                         invokeRestart(restart)
  [20:54:39.049]                         muffled <- TRUE
  [20:54:39.049]                         break
  [20:54:39.049]                       }
  [20:54:39.049]                     }
  [20:54:39.049]                     invisible(muffled)
  [20:54:39.049]                   }
  [20:54:39.049]                   muffleCondition(cond)
  [20:54:39.049]                 })
  [20:54:39.049]             }))
  [20:54:39.049]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.049]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.049]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.049]                 version = "1.8")
  [20:54:39.049]         }, condition = base::local({
  [20:54:39.049]             c <- base::c
  [20:54:39.049]             inherits <- base::inherits
  [20:54:39.049]             invokeRestart <- base::invokeRestart
  [20:54:39.049]             length <- base::length
  [20:54:39.049]             list <- base::list
  [20:54:39.049]             seq.int <- base::seq.int
  [20:54:39.049]             signalCondition <- base::signalCondition
  [20:54:39.049]             sys.calls <- base::sys.calls
  [20:54:39.049]             Sys.time <- base::Sys.time
  [20:54:39.049]             `[[` <- base::`[[`
  [20:54:39.049]             `+` <- base::`+`
  [20:54:39.049]             `<<-` <- base::`<<-`
  [20:54:39.049]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.049]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.049]                   3L)]
  [20:54:39.049]             }
  [20:54:39.049]             function(cond) {
  [20:54:39.049]                 if (inherits(cond, "error")) {
  [20:54:39.049]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.049]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.049]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.049]                   signalCondition(cond)
  [20:54:39.049]                 }
  [20:54:39.049]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.049]                 ))) {
  [20:54:39.049]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.049]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.049]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.049]                   if (!signal) {
  [20:54:39.049]                     muffleCondition <- function (cond) 
  [20:54:39.049]                     {
  [20:54:39.049]                       inherits <- base::inherits
  [20:54:39.049]                       invokeRestart <- base::invokeRestart
  [20:54:39.049]                       muffled <- FALSE
  [20:54:39.049]                       if (inherits(cond, "message")) {
  [20:54:39.049]                         invokeRestart("muffleMessage")
  [20:54:39.049]                         muffled <- TRUE
  [20:54:39.049]                       }
  [20:54:39.049]                       else if (inherits(cond, "warning")) {
  [20:54:39.049]                         invokeRestart("muffleWarning")
  [20:54:39.049]                         muffled <- TRUE
  [20:54:39.049]                       }
  [20:54:39.049]                       else if (inherits(cond, "condition")) {
  [20:54:39.049]                         computeRestarts <- base::computeRestarts
  [20:54:39.049]                         grepl <- base::grepl
  [20:54:39.049]                         is.null <- base::is.null
  [20:54:39.049]                         restarts <- computeRestarts(cond)
  [20:54:39.049]                         for (restart in restarts) {
  [20:54:39.049]                           name <- restart$name
  [20:54:39.049]                           if (is.null(name)) 
  [20:54:39.049]                             next
  [20:54:39.049]                           if (!grepl("^muffle", name)) 
  [20:54:39.049]                             next
  [20:54:39.049]                           invokeRestart(restart)
  [20:54:39.049]                           muffled <- TRUE
  [20:54:39.049]                           break
  [20:54:39.049]                         }
  [20:54:39.049]                       }
  [20:54:39.049]                       invisible(muffled)
  [20:54:39.049]                     }
  [20:54:39.049]                     muffleCondition(cond)
  [20:54:39.049]                   }
  [20:54:39.049]                 }
  [20:54:39.049]             }
  [20:54:39.049]         }))
  [20:54:39.049]     }, error = function(ex) {
  [20:54:39.049]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.049]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.049]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.049]     }, finally = {
  [20:54:39.049]         {
  [20:54:39.049]             NULL
  [20:54:39.049]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.049]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.049]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:39.049]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:39.049]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:39.049]                 ...) 
  [20:54:39.049]             {
  [20:54:39.049]                 if (substitute) 
  [20:54:39.049]                   expr <- substitute(expr)
  [20:54:39.049]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:39.049]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.049]                   globals = globals, persistent = persistent, 
  [20:54:39.049]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:39.049]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:39.049]                   label = label, ...)
  [20:54:39.049]                 if (!future$lazy) 
  [20:54:39.049]                   future <- run(future)
  [20:54:39.049]                 invisible(future)
  [20:54:39.049]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.049]         }
  [20:54:39.049]         base::options(...future.oldOptions)
  [20:54:39.049]     })
  [20:54:39.049]     Sys.time
  [20:54:39.049]     if (base::is.na(TRUE)) {
  [20:54:39.049]     }
  [20:54:39.049]     else {
  [20:54:39.049]         base::sink(type = "output", split = FALSE)
  [20:54:39.049]         if (TRUE) {
  [20:54:39.049]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.049]         }
  [20:54:39.049]         else {
  [20:54:39.049]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.049]         }
  [20:54:39.049]         base::close(...future.stdout)
  [20:54:39.049]         ...future.stdout <- NULL
  [20:54:39.049]     }
  [20:54:39.049]     ...future.result$conditions <- ...future.conditions
  [20:54:39.049]     ...future.result
  [20:54:39.049] }
  [20:54:39.079] ClusterFuture started
  [20:54:39.083] getGlobalsAndPackages() ...
  [20:54:39.084] Searching for globals...
  [20:54:39.084] 
  [20:54:39.084] Searching for globals ... DONE
  [20:54:39.085] - globals: [0] <none>
  [20:54:39.085] getGlobalsAndPackages() ... DONE
  [20:54:39.087] Packages needed by the future expression (n = 0): <none>
  [20:54:39.088] Packages needed by future strategies (n = 0): <none>
  [20:54:39.111] {
  [20:54:39.111]     {
  [20:54:39.111]         ...future.startTime <- base::Sys.time()
  [20:54:39.111]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.111]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.111]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.111]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.111]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.111]         {
  [20:54:39.111]             {
  [20:54:39.111]                 has_future <- base::requireNamespace("future", 
  [20:54:39.111]                   quietly = TRUE)
  [20:54:39.111]                 version <- if (has_future) 
  [20:54:39.111]                   utils::packageVersion("future")
  [20:54:39.111]                 else NULL
  [20:54:39.111]                 if (!has_future || version < "1.8.0") {
  [20:54:39.111]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.111]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.111]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.111]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.111]                       "release", "version")], collapse = " "), 
  [20:54:39.111]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.111]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.111]                     info)
  [20:54:39.111]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.111]                   if (!has_future) {
  [20:54:39.111]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.111]                       info)
  [20:54:39.111]                   }
  [20:54:39.111]                   else {
  [20:54:39.111]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.111]                       info, version)
  [20:54:39.111]                   }
  [20:54:39.111]                   base::stop(msg)
  [20:54:39.111]                 }
  [20:54:39.111]             }
  [20:54:39.111]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.111]         }
  [20:54:39.111]     }
  [20:54:39.111]     if (base::is.na(TRUE)) {
  [20:54:39.111]     }
  [20:54:39.111]     else {
  [20:54:39.111]         if (TRUE) {
  [20:54:39.111]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.111]                 open = "w")
  [20:54:39.111]         }
  [20:54:39.111]         else {
  [20:54:39.111]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.111]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.111]         }
  [20:54:39.111]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.111]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.111]             base::sink(type = "output", split = FALSE)
  [20:54:39.111]             base::close(...future.stdout)
  [20:54:39.111]         }, add = TRUE)
  [20:54:39.111]     }
  [20:54:39.111]     ...future.frame <- base::sys.nframe()
  [20:54:39.111]     ...future.conditions <- base::list()
  [20:54:39.111]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.111]     ...future.result <- base::tryCatch({
  [20:54:39.111]         base::withCallingHandlers({
  [20:54:39.111]             ...future.value <- base::withVisible(base::local({
  [20:54:39.111]                 ...future.sendCondition <- local({
  [20:54:39.111]                   sendCondition <- NULL
  [20:54:39.111]                   function(frame = 1L) {
  [20:54:39.111]                     if (is.function(sendCondition)) 
  [20:54:39.111]                       return(sendCondition)
  [20:54:39.111]                     ns <- getNamespace("parallel")
  [20:54:39.111]                     if (exists("sendData", mode = "function", 
  [20:54:39.111]                       envir = ns)) {
  [20:54:39.111]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:39.111]                         envir = ns)
  [20:54:39.111]                       envir <- sys.frame(frame)
  [20:54:39.111]                       master <- NULL
  [20:54:39.111]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:39.111]                         !identical(envir, emptyenv())) {
  [20:54:39.111]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:39.111]                           inherits = FALSE)) {
  [20:54:39.111]                           master <- get("master", mode = "list", 
  [20:54:39.111]                             envir = envir, inherits = FALSE)
  [20:54:39.111]                           if (inherits(master, "SOCKnode")) {
  [20:54:39.111]                             sendCondition <<- function(cond) {
  [20:54:39.111]                               data <- list(type = "VALUE", value = cond, 
  [20:54:39.111]                                 success = TRUE)
  [20:54:39.111]                               parallel_sendData(master, data)
  [20:54:39.111]                             }
  [20:54:39.111]                             return(sendCondition)
  [20:54:39.111]                           }
  [20:54:39.111]                         }
  [20:54:39.111]                         frame <- frame + 1L
  [20:54:39.111]                         envir <- sys.frame(frame)
  [20:54:39.111]                       }
  [20:54:39.111]                     }
  [20:54:39.111]                     sendCondition <<- function(cond) NULL
  [20:54:39.111]                   }
  [20:54:39.111]                 })
  [20:54:39.111]                 withCallingHandlers({
  [20:54:39.111]                   NULL
  [20:54:39.111]                 }, immediateCondition = function(cond) {
  [20:54:39.111]                   sendCondition <- ...future.sendCondition()
  [20:54:39.111]                   sendCondition(cond)
  [20:54:39.111]                   muffleCondition <- function (cond) 
  [20:54:39.111]                   {
  [20:54:39.111]                     inherits <- base::inherits
  [20:54:39.111]                     invokeRestart <- base::invokeRestart
  [20:54:39.111]                     muffled <- FALSE
  [20:54:39.111]                     if (inherits(cond, "message")) {
  [20:54:39.111]                       invokeRestart("muffleMessage")
  [20:54:39.111]                       muffled <- TRUE
  [20:54:39.111]                     }
  [20:54:39.111]                     else if (inherits(cond, "warning")) {
  [20:54:39.111]                       invokeRestart("muffleWarning")
  [20:54:39.111]                       muffled <- TRUE
  [20:54:39.111]                     }
  [20:54:39.111]                     else if (inherits(cond, "condition")) {
  [20:54:39.111]                       computeRestarts <- base::computeRestarts
  [20:54:39.111]                       grepl <- base::grepl
  [20:54:39.111]                       is.null <- base::is.null
  [20:54:39.111]                       restarts <- computeRestarts(cond)
  [20:54:39.111]                       for (restart in restarts) {
  [20:54:39.111]                         name <- restart$name
  [20:54:39.111]                         if (is.null(name)) 
  [20:54:39.111]                           next
  [20:54:39.111]                         if (!grepl("^muffle", name)) 
  [20:54:39.111]                           next
  [20:54:39.111]                         invokeRestart(restart)
  [20:54:39.111]                         muffled <- TRUE
  [20:54:39.111]                         break
  [20:54:39.111]                       }
  [20:54:39.111]                     }
  [20:54:39.111]                     invisible(muffled)
  [20:54:39.111]                   }
  [20:54:39.111]                   muffleCondition(cond)
  [20:54:39.111]                 })
  [20:54:39.111]             }))
  [20:54:39.111]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.111]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.111]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.111]                 version = "1.8")
  [20:54:39.111]         }, condition = base::local({
  [20:54:39.111]             c <- base::c
  [20:54:39.111]             inherits <- base::inherits
  [20:54:39.111]             invokeRestart <- base::invokeRestart
  [20:54:39.111]             length <- base::length
  [20:54:39.111]             list <- base::list
  [20:54:39.111]             seq.int <- base::seq.int
  [20:54:39.111]             signalCondition <- base::signalCondition
  [20:54:39.111]             sys.calls <- base::sys.calls
  [20:54:39.111]             Sys.time <- base::Sys.time
  [20:54:39.111]             `[[` <- base::`[[`
  [20:54:39.111]             `+` <- base::`+`
  [20:54:39.111]             `<<-` <- base::`<<-`
  [20:54:39.111]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.111]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.111]                   3L)]
  [20:54:39.111]             }
  [20:54:39.111]             function(cond) {
  [20:54:39.111]                 if (inherits(cond, "error")) {
  [20:54:39.111]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.111]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.111]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.111]                   signalCondition(cond)
  [20:54:39.111]                 }
  [20:54:39.111]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.111]                 ))) {
  [20:54:39.111]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.111]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.111]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.111]                   if (!signal) {
  [20:54:39.111]                     muffleCondition <- function (cond) 
  [20:54:39.111]                     {
  [20:54:39.111]                       inherits <- base::inherits
  [20:54:39.111]                       invokeRestart <- base::invokeRestart
  [20:54:39.111]                       muffled <- FALSE
  [20:54:39.111]                       if (inherits(cond, "message")) {
  [20:54:39.111]                         invokeRestart("muffleMessage")
  [20:54:39.111]                         muffled <- TRUE
  [20:54:39.111]                       }
  [20:54:39.111]                       else if (inherits(cond, "warning")) {
  [20:54:39.111]                         invokeRestart("muffleWarning")
  [20:54:39.111]                         muffled <- TRUE
  [20:54:39.111]                       }
  [20:54:39.111]                       else if (inherits(cond, "condition")) {
  [20:54:39.111]                         computeRestarts <- base::computeRestarts
  [20:54:39.111]                         grepl <- base::grepl
  [20:54:39.111]                         is.null <- base::is.null
  [20:54:39.111]                         restarts <- computeRestarts(cond)
  [20:54:39.111]                         for (restart in restarts) {
  [20:54:39.111]                           name <- restart$name
  [20:54:39.111]                           if (is.null(name)) 
  [20:54:39.111]                             next
  [20:54:39.111]                           if (!grepl("^muffle", name)) 
  [20:54:39.111]                             next
  [20:54:39.111]                           invokeRestart(restart)
  [20:54:39.111]                           muffled <- TRUE
  [20:54:39.111]                           break
  [20:54:39.111]                         }
  [20:54:39.111]                       }
  [20:54:39.111]                       invisible(muffled)
  [20:54:39.111]                     }
  [20:54:39.111]                     muffleCondition(cond)
  [20:54:39.111]                   }
  [20:54:39.111]                 }
  [20:54:39.111]             }
  [20:54:39.111]         }))
  [20:54:39.111]     }, error = function(ex) {
  [20:54:39.111]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.111]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.111]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.111]     }, finally = {
  [20:54:39.111]         {
  [20:54:39.111]             NULL
  [20:54:39.111]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.111]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.111]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:39.111]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:39.111]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:39.111]                 ...) 
  [20:54:39.111]             {
  [20:54:39.111]                 if (substitute) 
  [20:54:39.111]                   expr <- substitute(expr)
  [20:54:39.111]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:39.111]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.111]                   globals = globals, persistent = persistent, 
  [20:54:39.111]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:39.111]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:39.111]                   label = label, ...)
  [20:54:39.111]                 if (!future$lazy) 
  [20:54:39.111]                   future <- run(future)
  [20:54:39.111]                 invisible(future)
  [20:54:39.111]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.111]         }
  [20:54:39.111]         base::options(...future.oldOptions)
  [20:54:39.111]     })
  [20:54:39.111]     Sys.time
  [20:54:39.111]     if (base::is.na(TRUE)) {
  [20:54:39.111]     }
  [20:54:39.111]     else {
  [20:54:39.111]         base::sink(type = "output", split = FALSE)
  [20:54:39.111]         if (TRUE) {
  [20:54:39.111]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.111]         }
  [20:54:39.111]         else {
  [20:54:39.111]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.111]         }
  [20:54:39.111]         base::close(...future.stdout)
  [20:54:39.111]         ...future.stdout <- NULL
  [20:54:39.111]     }
  [20:54:39.111]     ...future.result$conditions <- ...future.conditions
  [20:54:39.111]     ...future.result
  [20:54:39.111] }
  [20:54:39.115] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:39.127] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:39.128] - Validating connection of ClusterFuture
  [20:54:39.128] - received message: FutureResult
  [20:54:39.128] - Received FutureResult
  [20:54:39.128] - Erased future from FutureRegistry
  [20:54:39.129] result() for ClusterFuture ...
  [20:54:39.129] - result already collected: FutureResult
  [20:54:39.129] result() for ClusterFuture ... done
  [20:54:39.130] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:39.130] result() for ClusterFuture ...
  [20:54:39.130] - result already collected: FutureResult
  [20:54:39.131] result() for ClusterFuture ... done
  [20:54:39.131] result() for ClusterFuture ...
  [20:54:39.131] - result already collected: FutureResult
  [20:54:39.131] result() for ClusterFuture ... done
  [20:54:39.134] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b113c6160> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b1193ce48> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b113c6160> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b1193ce48> 
   $  : 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"
  [20:54:39.182] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:39.182] - Validating connection of ClusterFuture
  [20:54:39.183] - received message: FutureResult
  [20:54:39.183] - Received FutureResult
  [20:54:39.183] - Erased future from FutureRegistry
  [20:54:39.184] result() for ClusterFuture ...
  [20:54:39.184] - result already collected: FutureResult
  [20:54:39.184] result() for ClusterFuture ... done
  [20:54:39.184] 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" "" ...
  [20:54:39.190] resolve() on list ...
  [20:54:39.190]  recursive: 0
  [20:54:39.190]  length: 6
  [20:54:39.190]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:39.191] signalConditionsASAP(numeric, pos=1) ...
  [20:54:39.191] - nx: 6
  [20:54:39.191] - relay: TRUE
  [20:54:39.191] - stdout: TRUE
  [20:54:39.192] - signal: TRUE
  [20:54:39.192] - resignal: FALSE
  [20:54:39.192] - force: TRUE
  [20:54:39.192] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.193] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.193]  - until=2
  [20:54:39.193]  - relaying element #2
  [20:54:39.193] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.194] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.194] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:39.194]  length: 5 (resolved future 1)
  [20:54:39.194] Future #2
  [20:54:39.195] result() for ClusterFuture ...
  [20:54:39.195] - result already collected: FutureResult
  [20:54:39.195] result() for ClusterFuture ... done
  [20:54:39.196] result() for ClusterFuture ...
  [20:54:39.196] - result already collected: FutureResult
  [20:54:39.196] result() for ClusterFuture ... done
  [20:54:39.196] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:39.197] - nx: 6
  [20:54:39.197] - relay: TRUE
  [20:54:39.197] - stdout: TRUE
  [20:54:39.197] - signal: TRUE
  [20:54:39.208] - resignal: FALSE
  [20:54:39.208] - force: TRUE
  [20:54:39.208] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.209] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.209]  - until=2
  [20:54:39.209]  - relaying element #2
  [20:54:39.210] result() for ClusterFuture ...
  [20:54:39.210] - result already collected: FutureResult
  [20:54:39.210] result() for ClusterFuture ... done
  [20:54:39.210] result() for ClusterFuture ...
  [20:54:39.211] - result already collected: FutureResult
  [20:54:39.211] result() for ClusterFuture ... done
  [20:54:39.211] result() for ClusterFuture ...
  [20:54:39.212] - result already collected: FutureResult
  [20:54:39.212] result() for ClusterFuture ... done
  [20:54:39.212] result() for ClusterFuture ...
  [20:54:39.212] - result already collected: FutureResult
  [20:54:39.213] result() for ClusterFuture ... done
  [20:54:39.213] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.213] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.213] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:39.214]  length: 4 (resolved future 2)
  [20:54:39.214] Future #3
  [20:54:39.214] result() for ClusterFuture ...
  [20:54:39.215] - result already collected: FutureResult
  [20:54:39.215] result() for ClusterFuture ... done
  [20:54:39.215] result() for ClusterFuture ...
  [20:54:39.215] - result already collected: FutureResult
  [20:54:39.216] result() for ClusterFuture ... done
  [20:54:39.216] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:39.216] - nx: 6
  [20:54:39.216] - relay: TRUE
  [20:54:39.217] - stdout: TRUE
  [20:54:39.217] - signal: TRUE
  [20:54:39.217] - resignal: FALSE
  [20:54:39.217] - force: TRUE
  [20:54:39.238] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.239] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.239]  - until=3
  [20:54:39.239]  - relaying element #3
  [20:54:39.239] result() for ClusterFuture ...
  [20:54:39.240] - result already collected: FutureResult
  [20:54:39.240] result() for ClusterFuture ... done
  [20:54:39.240] result() for ClusterFuture ...
  [20:54:39.241] - result already collected: FutureResult
  [20:54:39.241] result() for ClusterFuture ... done
  [20:54:39.241] result() for ClusterFuture ...
  [20:54:39.241] - result already collected: FutureResult
  [20:54:39.242] result() for ClusterFuture ... done
  [20:54:39.242] result() for ClusterFuture ...
  [20:54:39.242] - result already collected: FutureResult
  [20:54:39.243] result() for ClusterFuture ... done
  [20:54:39.243] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.243] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.243] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:39.244]  length: 3 (resolved future 3)
  [20:54:39.244] signalConditionsASAP(NULL, pos=4) ...
  [20:54:39.244] - nx: 6
  [20:54:39.244] - relay: TRUE
  [20:54:39.245] - stdout: TRUE
  [20:54:39.245] - signal: TRUE
  [20:54:39.245] - resignal: FALSE
  [20:54:39.245] - force: TRUE
  [20:54:39.246] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.246] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.246]  - until=5
  [20:54:39.246]  - relaying element #5
  [20:54:39.247] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:39.247] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.247] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:39.247]  length: 2 (resolved future 4)
  [20:54:39.248] signalConditionsASAP(NULL, pos=5) ...
  [20:54:39.248] - nx: 6
  [20:54:39.248] - relay: TRUE
  [20:54:39.248] - stdout: TRUE
  [20:54:39.249] - signal: TRUE
  [20:54:39.249] - resignal: FALSE
  [20:54:39.249] - force: TRUE
  [20:54:39.249] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:39.250] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.250]  - until=6
  [20:54:39.250]  - relaying element #6
  [20:54:39.250] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.251] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.251] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:39.251]  length: 1 (resolved future 5)
  [20:54:39.251] signalConditionsASAP(numeric, pos=6) ...
  [20:54:39.252] - nx: 6
  [20:54:39.252] - relay: TRUE
  [20:54:39.252] - stdout: TRUE
  [20:54:39.252] - signal: TRUE
  [20:54:39.253] - resignal: FALSE
  [20:54:39.253] - force: TRUE
  [20:54:39.253] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.253] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.261]  - until=6
  [20:54:39.262] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.262] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.262] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:39.263]  length: 0 (resolved future 6)
  [20:54:39.263] Relaying remaining futures
  [20:54:39.263] signalConditionsASAP(NULL, pos=0) ...
  [20:54:39.263] - nx: 6
  [20:54:39.263] - relay: TRUE
  [20:54:39.264] - stdout: TRUE
  [20:54:39.264] - signal: TRUE
  [20:54:39.264] - resignal: FALSE
  [20:54:39.264] - force: TRUE
  [20:54:39.265] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.265] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:39.265] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.266] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.266] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:39.266] resolve() on list ... DONE
  [20:54:39.266] result() for ClusterFuture ...
  [20:54:39.267] - result already collected: FutureResult
  [20:54:39.267] result() for ClusterFuture ... done
  [20:54:39.267] result() for ClusterFuture ...
  [20:54:39.267] - result already collected: FutureResult
  [20:54:39.268] result() for ClusterFuture ... done
  [20:54:39.268] result() for ClusterFuture ...
  [20:54:39.268] - result already collected: FutureResult
  [20:54:39.269] result() for ClusterFuture ... done
  [20:54:39.269] result() for ClusterFuture ...
  [20:54:39.269] - result already collected: FutureResult
  [20:54:39.269] 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)
  [20:54:39.293] getGlobalsAndPackages() ...
  [20:54:39.293] Searching for globals...
  [20:54:39.303] 
  [20:54:39.303] Searching for globals ... DONE
  [20:54:39.304] - globals: [0] <none>
  [20:54:39.304] getGlobalsAndPackages() ... DONE
  [20:54:39.311] Packages needed by the future expression (n = 0): <none>
  [20:54:39.311] Packages needed by future strategies (n = 0): <none>
  [20:54:39.315] {
  [20:54:39.315]     {
  [20:54:39.315]         ...future.startTime <- base::Sys.time()
  [20:54:39.315]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.315]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.315]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.315]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.315]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.315]         {
  [20:54:39.315]             {
  [20:54:39.315]                 has_future <- base::requireNamespace("future", 
  [20:54:39.315]                   quietly = TRUE)
  [20:54:39.315]                 version <- if (has_future) 
  [20:54:39.315]                   utils::packageVersion("future")
  [20:54:39.315]                 else NULL
  [20:54:39.315]                 if (!has_future || version < "1.8.0") {
  [20:54:39.315]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.315]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.315]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.315]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.315]                       "release", "version")], collapse = " "), 
  [20:54:39.315]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.315]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.315]                     info)
  [20:54:39.315]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.315]                   if (!has_future) {
  [20:54:39.315]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.315]                       info)
  [20:54:39.315]                   }
  [20:54:39.315]                   else {
  [20:54:39.315]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.315]                       info, version)
  [20:54:39.315]                   }
  [20:54:39.315]                   base::stop(msg)
  [20:54:39.315]                 }
  [20:54:39.315]             }
  [20:54:39.315]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.315]         }
  [20:54:39.315]     }
  [20:54:39.315]     if (base::is.na(TRUE)) {
  [20:54:39.315]     }
  [20:54:39.315]     else {
  [20:54:39.315]         if (TRUE) {
  [20:54:39.315]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.315]                 open = "w")
  [20:54:39.315]         }
  [20:54:39.315]         else {
  [20:54:39.315]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.315]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.315]         }
  [20:54:39.315]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.315]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.315]             base::sink(type = "output", split = FALSE)
  [20:54:39.315]             base::close(...future.stdout)
  [20:54:39.315]         }, add = TRUE)
  [20:54:39.315]     }
  [20:54:39.315]     ...future.frame <- base::sys.nframe()
  [20:54:39.315]     ...future.conditions <- base::list()
  [20:54:39.315]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.315]     ...future.result <- base::tryCatch({
  [20:54:39.315]         base::withCallingHandlers({
  [20:54:39.315]             ...future.value <- base::withVisible(base::local({
  [20:54:39.315]                 ...future.sendCondition <- local({
  [20:54:39.315]                   sendCondition <- NULL
  [20:54:39.315]                   function(frame = 1L) {
  [20:54:39.315]                     if (is.function(sendCondition)) 
  [20:54:39.315]                       return(sendCondition)
  [20:54:39.315]                     ns <- getNamespace("parallel")
  [20:54:39.315]                     if (exists("sendData", mode = "function", 
  [20:54:39.315]                       envir = ns)) {
  [20:54:39.315]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:39.315]                         envir = ns)
  [20:54:39.315]                       envir <- sys.frame(frame)
  [20:54:39.315]                       master <- NULL
  [20:54:39.315]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:39.315]                         !identical(envir, emptyenv())) {
  [20:54:39.315]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:39.315]                           inherits = FALSE)) {
  [20:54:39.315]                           master <- get("master", mode = "list", 
  [20:54:39.315]                             envir = envir, inherits = FALSE)
  [20:54:39.315]                           if (inherits(master, "SOCKnode")) {
  [20:54:39.315]                             sendCondition <<- function(cond) {
  [20:54:39.315]                               data <- list(type = "VALUE", value = cond, 
  [20:54:39.315]                                 success = TRUE)
  [20:54:39.315]                               parallel_sendData(master, data)
  [20:54:39.315]                             }
  [20:54:39.315]                             return(sendCondition)
  [20:54:39.315]                           }
  [20:54:39.315]                         }
  [20:54:39.315]                         frame <- frame + 1L
  [20:54:39.315]                         envir <- sys.frame(frame)
  [20:54:39.315]                       }
  [20:54:39.315]                     }
  [20:54:39.315]                     sendCondition <<- function(cond) NULL
  [20:54:39.315]                   }
  [20:54:39.315]                 })
  [20:54:39.315]                 withCallingHandlers({
  [20:54:39.315]                   2
  [20:54:39.315]                 }, immediateCondition = function(cond) {
  [20:54:39.315]                   sendCondition <- ...future.sendCondition()
  [20:54:39.315]                   sendCondition(cond)
  [20:54:39.315]                   muffleCondition <- function (cond) 
  [20:54:39.315]                   {
  [20:54:39.315]                     inherits <- base::inherits
  [20:54:39.315]                     invokeRestart <- base::invokeRestart
  [20:54:39.315]                     muffled <- FALSE
  [20:54:39.315]                     if (inherits(cond, "message")) {
  [20:54:39.315]                       invokeRestart("muffleMessage")
  [20:54:39.315]                       muffled <- TRUE
  [20:54:39.315]                     }
  [20:54:39.315]                     else if (inherits(cond, "warning")) {
  [20:54:39.315]                       invokeRestart("muffleWarning")
  [20:54:39.315]                       muffled <- TRUE
  [20:54:39.315]                     }
  [20:54:39.315]                     else if (inherits(cond, "condition")) {
  [20:54:39.315]                       computeRestarts <- base::computeRestarts
  [20:54:39.315]                       grepl <- base::grepl
  [20:54:39.315]                       is.null <- base::is.null
  [20:54:39.315]                       restarts <- computeRestarts(cond)
  [20:54:39.315]                       for (restart in restarts) {
  [20:54:39.315]                         name <- restart$name
  [20:54:39.315]                         if (is.null(name)) 
  [20:54:39.315]                           next
  [20:54:39.315]                         if (!grepl("^muffle", name)) 
  [20:54:39.315]                           next
  [20:54:39.315]                         invokeRestart(restart)
  [20:54:39.315]                         muffled <- TRUE
  [20:54:39.315]                         break
  [20:54:39.315]                       }
  [20:54:39.315]                     }
  [20:54:39.315]                     invisible(muffled)
  [20:54:39.315]                   }
  [20:54:39.315]                   muffleCondition(cond)
  [20:54:39.315]                 })
  [20:54:39.315]             }))
  [20:54:39.315]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.315]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.315]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.315]                 version = "1.8")
  [20:54:39.315]         }, condition = base::local({
  [20:54:39.315]             c <- base::c
  [20:54:39.315]             inherits <- base::inherits
  [20:54:39.315]             invokeRestart <- base::invokeRestart
  [20:54:39.315]             length <- base::length
  [20:54:39.315]             list <- base::list
  [20:54:39.315]             seq.int <- base::seq.int
  [20:54:39.315]             signalCondition <- base::signalCondition
  [20:54:39.315]             sys.calls <- base::sys.calls
  [20:54:39.315]             Sys.time <- base::Sys.time
  [20:54:39.315]             `[[` <- base::`[[`
  [20:54:39.315]             `+` <- base::`+`
  [20:54:39.315]             `<<-` <- base::`<<-`
  [20:54:39.315]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.315]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.315]                   3L)]
  [20:54:39.315]             }
  [20:54:39.315]             function(cond) {
  [20:54:39.315]                 if (inherits(cond, "error")) {
  [20:54:39.315]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.315]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.315]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.315]                   signalCondition(cond)
  [20:54:39.315]                 }
  [20:54:39.315]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.315]                 ))) {
  [20:54:39.315]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.315]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.315]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.315]                   if (!signal) {
  [20:54:39.315]                     muffleCondition <- function (cond) 
  [20:54:39.315]                     {
  [20:54:39.315]                       inherits <- base::inherits
  [20:54:39.315]                       invokeRestart <- base::invokeRestart
  [20:54:39.315]                       muffled <- FALSE
  [20:54:39.315]                       if (inherits(cond, "message")) {
  [20:54:39.315]                         invokeRestart("muffleMessage")
  [20:54:39.315]                         muffled <- TRUE
  [20:54:39.315]                       }
  [20:54:39.315]                       else if (inherits(cond, "warning")) {
  [20:54:39.315]                         invokeRestart("muffleWarning")
  [20:54:39.315]                         muffled <- TRUE
  [20:54:39.315]                       }
  [20:54:39.315]                       else if (inherits(cond, "condition")) {
  [20:54:39.315]                         computeRestarts <- base::computeRestarts
  [20:54:39.315]                         grepl <- base::grepl
  [20:54:39.315]                         is.null <- base::is.null
  [20:54:39.315]                         restarts <- computeRestarts(cond)
  [20:54:39.315]                         for (restart in restarts) {
  [20:54:39.315]                           name <- restart$name
  [20:54:39.315]                           if (is.null(name)) 
  [20:54:39.315]                             next
  [20:54:39.315]                           if (!grepl("^muffle", name)) 
  [20:54:39.315]                             next
  [20:54:39.315]                           invokeRestart(restart)
  [20:54:39.315]                           muffled <- TRUE
  [20:54:39.315]                           break
  [20:54:39.315]                         }
  [20:54:39.315]                       }
  [20:54:39.315]                       invisible(muffled)
  [20:54:39.315]                     }
  [20:54:39.315]                     muffleCondition(cond)
  [20:54:39.315]                   }
  [20:54:39.315]                 }
  [20:54:39.315]             }
  [20:54:39.315]         }))
  [20:54:39.315]     }, error = function(ex) {
  [20:54:39.315]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.315]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.315]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.315]     }, finally = {
  [20:54:39.315]         {
  [20:54:39.315]             NULL
  [20:54:39.315]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.315]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.315]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:39.315]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:39.315]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:39.315]                 ...) 
  [20:54:39.315]             {
  [20:54:39.315]                 if (substitute) 
  [20:54:39.315]                   expr <- substitute(expr)
  [20:54:39.315]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:39.315]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.315]                   globals = globals, persistent = persistent, 
  [20:54:39.315]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:39.315]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:39.315]                   label = label, ...)
  [20:54:39.315]                 if (!future$lazy) 
  [20:54:39.315]                   future <- run(future)
  [20:54:39.315]                 invisible(future)
  [20:54:39.315]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.315]         }
  [20:54:39.315]         base::options(...future.oldOptions)
  [20:54:39.315]     })
  [20:54:39.315]     Sys.time
  [20:54:39.315]     if (base::is.na(TRUE)) {
  [20:54:39.315]     }
  [20:54:39.315]     else {
  [20:54:39.315]         base::sink(type = "output", split = FALSE)
  [20:54:39.315]         if (TRUE) {
  [20:54:39.315]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.315]         }
  [20:54:39.315]         else {
  [20:54:39.315]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.315]         }
  [20:54:39.315]         base::close(...future.stdout)
  [20:54:39.315]         ...future.stdout <- NULL
  [20:54:39.315]     }
  [20:54:39.315]     ...future.result$conditions <- ...future.conditions
  [20:54:39.315]     ...future.result
  [20:54:39.315] }
  [20:54:39.322] ClusterFuture started
  [20:54:39.326] getGlobalsAndPackages() ...
  [20:54:39.327] Searching for globals...
  [20:54:39.327] 
  [20:54:39.328] Searching for globals ... DONE
  [20:54:39.332] - globals: [0] <none>
  [20:54:39.332] getGlobalsAndPackages() ... DONE
  [20:54:39.335] Packages needed by the future expression (n = 0): <none>
  [20:54:39.335] Packages needed by future strategies (n = 0): <none>
  [20:54:39.339] {
  [20:54:39.339]     {
  [20:54:39.339]         ...future.startTime <- base::Sys.time()
  [20:54:39.339]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.339]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.339]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.339]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.339]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.339]         {
  [20:54:39.339]             {
  [20:54:39.339]                 has_future <- base::requireNamespace("future", 
  [20:54:39.339]                   quietly = TRUE)
  [20:54:39.339]                 version <- if (has_future) 
  [20:54:39.339]                   utils::packageVersion("future")
  [20:54:39.339]                 else NULL
  [20:54:39.339]                 if (!has_future || version < "1.8.0") {
  [20:54:39.339]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.339]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.339]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.339]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.339]                       "release", "version")], collapse = " "), 
  [20:54:39.339]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.339]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.339]                     info)
  [20:54:39.339]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.339]                   if (!has_future) {
  [20:54:39.339]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.339]                       info)
  [20:54:39.339]                   }
  [20:54:39.339]                   else {
  [20:54:39.339]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.339]                       info, version)
  [20:54:39.339]                   }
  [20:54:39.339]                   base::stop(msg)
  [20:54:39.339]                 }
  [20:54:39.339]             }
  [20:54:39.339]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.339]         }
  [20:54:39.339]     }
  [20:54:39.339]     if (base::is.na(TRUE)) {
  [20:54:39.339]     }
  [20:54:39.339]     else {
  [20:54:39.339]         if (TRUE) {
  [20:54:39.339]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.339]                 open = "w")
  [20:54:39.339]         }
  [20:54:39.339]         else {
  [20:54:39.339]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.339]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.339]         }
  [20:54:39.339]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.339]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.339]             base::sink(type = "output", split = FALSE)
  [20:54:39.339]             base::close(...future.stdout)
  [20:54:39.339]         }, add = TRUE)
  [20:54:39.339]     }
  [20:54:39.339]     ...future.frame <- base::sys.nframe()
  [20:54:39.339]     ...future.conditions <- base::list()
  [20:54:39.339]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.339]     ...future.result <- base::tryCatch({
  [20:54:39.339]         base::withCallingHandlers({
  [20:54:39.339]             ...future.value <- base::withVisible(base::local({
  [20:54:39.339]                 ...future.sendCondition <- local({
  [20:54:39.339]                   sendCondition <- NULL
  [20:54:39.339]                   function(frame = 1L) {
  [20:54:39.339]                     if (is.function(sendCondition)) 
  [20:54:39.339]                       return(sendCondition)
  [20:54:39.339]                     ns <- getNamespace("parallel")
  [20:54:39.339]                     if (exists("sendData", mode = "function", 
  [20:54:39.339]                       envir = ns)) {
  [20:54:39.339]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:39.339]                         envir = ns)
  [20:54:39.339]                       envir <- sys.frame(frame)
  [20:54:39.339]                       master <- NULL
  [20:54:39.339]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:39.339]                         !identical(envir, emptyenv())) {
  [20:54:39.339]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:39.339]                           inherits = FALSE)) {
  [20:54:39.339]                           master <- get("master", mode = "list", 
  [20:54:39.339]                             envir = envir, inherits = FALSE)
  [20:54:39.339]                           if (inherits(master, "SOCKnode")) {
  [20:54:39.339]                             sendCondition <<- function(cond) {
  [20:54:39.339]                               data <- list(type = "VALUE", value = cond, 
  [20:54:39.339]                                 success = TRUE)
  [20:54:39.339]                               parallel_sendData(master, data)
  [20:54:39.339]                             }
  [20:54:39.339]                             return(sendCondition)
  [20:54:39.339]                           }
  [20:54:39.339]                         }
  [20:54:39.339]                         frame <- frame + 1L
  [20:54:39.339]                         envir <- sys.frame(frame)
  [20:54:39.339]                       }
  [20:54:39.339]                     }
  [20:54:39.339]                     sendCondition <<- function(cond) NULL
  [20:54:39.339]                   }
  [20:54:39.339]                 })
  [20:54:39.339]                 withCallingHandlers({
  [20:54:39.339]                   NULL
  [20:54:39.339]                 }, immediateCondition = function(cond) {
  [20:54:39.339]                   sendCondition <- ...future.sendCondition()
  [20:54:39.339]                   sendCondition(cond)
  [20:54:39.339]                   muffleCondition <- function (cond) 
  [20:54:39.339]                   {
  [20:54:39.339]                     inherits <- base::inherits
  [20:54:39.339]                     invokeRestart <- base::invokeRestart
  [20:54:39.339]                     muffled <- FALSE
  [20:54:39.339]                     if (inherits(cond, "message")) {
  [20:54:39.339]                       invokeRestart("muffleMessage")
  [20:54:39.339]                       muffled <- TRUE
  [20:54:39.339]                     }
  [20:54:39.339]                     else if (inherits(cond, "warning")) {
  [20:54:39.339]                       invokeRestart("muffleWarning")
  [20:54:39.339]                       muffled <- TRUE
  [20:54:39.339]                     }
  [20:54:39.339]                     else if (inherits(cond, "condition")) {
  [20:54:39.339]                       computeRestarts <- base::computeRestarts
  [20:54:39.339]                       grepl <- base::grepl
  [20:54:39.339]                       is.null <- base::is.null
  [20:54:39.339]                       restarts <- computeRestarts(cond)
  [20:54:39.339]                       for (restart in restarts) {
  [20:54:39.339]                         name <- restart$name
  [20:54:39.339]                         if (is.null(name)) 
  [20:54:39.339]                           next
  [20:54:39.339]                         if (!grepl("^muffle", name)) 
  [20:54:39.339]                           next
  [20:54:39.339]                         invokeRestart(restart)
  [20:54:39.339]                         muffled <- TRUE
  [20:54:39.339]                         break
  [20:54:39.339]                       }
  [20:54:39.339]                     }
  [20:54:39.339]                     invisible(muffled)
  [20:54:39.339]                   }
  [20:54:39.339]                   muffleCondition(cond)
  [20:54:39.339]                 })
  [20:54:39.339]             }))
  [20:54:39.339]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.339]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.339]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.339]                 version = "1.8")
  [20:54:39.339]         }, condition = base::local({
  [20:54:39.339]             c <- base::c
  [20:54:39.339]             inherits <- base::inherits
  [20:54:39.339]             invokeRestart <- base::invokeRestart
  [20:54:39.339]             length <- base::length
  [20:54:39.339]             list <- base::list
  [20:54:39.339]             seq.int <- base::seq.int
  [20:54:39.339]             signalCondition <- base::signalCondition
  [20:54:39.339]             sys.calls <- base::sys.calls
  [20:54:39.339]             Sys.time <- base::Sys.time
  [20:54:39.339]             `[[` <- base::`[[`
  [20:54:39.339]             `+` <- base::`+`
  [20:54:39.339]             `<<-` <- base::`<<-`
  [20:54:39.339]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.339]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.339]                   3L)]
  [20:54:39.339]             }
  [20:54:39.339]             function(cond) {
  [20:54:39.339]                 if (inherits(cond, "error")) {
  [20:54:39.339]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.339]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.339]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.339]                   signalCondition(cond)
  [20:54:39.339]                 }
  [20:54:39.339]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.339]                 ))) {
  [20:54:39.339]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.339]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.339]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.339]                   if (!signal) {
  [20:54:39.339]                     muffleCondition <- function (cond) 
  [20:54:39.339]                     {
  [20:54:39.339]                       inherits <- base::inherits
  [20:54:39.339]                       invokeRestart <- base::invokeRestart
  [20:54:39.339]                       muffled <- FALSE
  [20:54:39.339]                       if (inherits(cond, "message")) {
  [20:54:39.339]                         invokeRestart("muffleMessage")
  [20:54:39.339]                         muffled <- TRUE
  [20:54:39.339]                       }
  [20:54:39.339]                       else if (inherits(cond, "warning")) {
  [20:54:39.339]                         invokeRestart("muffleWarning")
  [20:54:39.339]                         muffled <- TRUE
  [20:54:39.339]                       }
  [20:54:39.339]                       else if (inherits(cond, "condition")) {
  [20:54:39.339]                         computeRestarts <- base::computeRestarts
  [20:54:39.339]                         grepl <- base::grepl
  [20:54:39.339]                         is.null <- base::is.null
  [20:54:39.339]                         restarts <- computeRestarts(cond)
  [20:54:39.339]                         for (restart in restarts) {
  [20:54:39.339]                           name <- restart$name
  [20:54:39.339]                           if (is.null(name)) 
  [20:54:39.339]                             next
  [20:54:39.339]                           if (!grepl("^muffle", name)) 
  [20:54:39.339]                             next
  [20:54:39.339]                           invokeRestart(restart)
  [20:54:39.339]                           muffled <- TRUE
  [20:54:39.339]                           break
  [20:54:39.339]                         }
  [20:54:39.339]                       }
  [20:54:39.339]                       invisible(muffled)
  [20:54:39.339]                     }
  [20:54:39.339]                     muffleCondition(cond)
  [20:54:39.339]                   }
  [20:54:39.339]                 }
  [20:54:39.339]             }
  [20:54:39.339]         }))
  [20:54:39.339]     }, error = function(ex) {
  [20:54:39.339]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.339]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.339]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.339]     }, finally = {
  [20:54:39.339]         {
  [20:54:39.339]             NULL
  [20:54:39.339]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.339]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.339]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:39.339]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:39.339]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:39.339]                 ...) 
  [20:54:39.339]             {
  [20:54:39.339]                 if (substitute) 
  [20:54:39.339]                   expr <- substitute(expr)
  [20:54:39.339]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:39.339]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.339]                   globals = globals, persistent = persistent, 
  [20:54:39.339]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:39.339]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:39.339]                   label = label, ...)
  [20:54:39.339]                 if (!future$lazy) 
  [20:54:39.339]                   future <- run(future)
  [20:54:39.339]                 invisible(future)
  [20:54:39.339]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.339]         }
  [20:54:39.339]         base::options(...future.oldOptions)
  [20:54:39.339]     })
  [20:54:39.339]     Sys.time
  [20:54:39.339]     if (base::is.na(TRUE)) {
  [20:54:39.339]     }
  [20:54:39.339]     else {
  [20:54:39.339]         base::sink(type = "output", split = FALSE)
  [20:54:39.339]         if (TRUE) {
  [20:54:39.339]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.339]         }
  [20:54:39.339]         else {
  [20:54:39.339]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.339]         }
  [20:54:39.339]         base::close(...future.stdout)
  [20:54:39.339]         ...future.stdout <- NULL
  [20:54:39.339]     }
  [20:54:39.339]     ...future.result$conditions <- ...future.conditions
  [20:54:39.339]     ...future.result
  [20:54:39.339] }
  [20:54:39.344] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:39.366] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:39.366] - Validating connection of ClusterFuture
  [20:54:39.366] - received message: FutureResult
  [20:54:39.367] - Received FutureResult
  [20:54:39.367] - Erased future from FutureRegistry
  [20:54:39.367] result() for ClusterFuture ...
  [20:54:39.368] - result already collected: FutureResult
  [20:54:39.368] result() for ClusterFuture ... done
  [20:54:39.368] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:39.368] result() for ClusterFuture ...
  [20:54:39.369] - result already collected: FutureResult
  [20:54:39.369] result() for ClusterFuture ... done
  [20:54:39.369] result() for ClusterFuture ...
  [20:54:39.370] - result already collected: FutureResult
  [20:54:39.370] result() for ClusterFuture ... done
  [20:54:39.372] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11805b98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b10612b78> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b11805b98> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x556b10612b78> 
   $  : 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"
  [20:54:39.418] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:39.418] - Validating connection of ClusterFuture
  [20:54:39.419] - received message: FutureResult
  [20:54:39.419] - Received FutureResult
  [20:54:39.419] - Erased future from FutureRegistry
  [20:54:39.419] result() for ClusterFuture ...
  [20:54:39.420] - result already collected: FutureResult
  [20:54:39.420] result() for ClusterFuture ... done
  [20:54:39.420] 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" "" ...
  [20:54:39.425] resolve() on list ...
  [20:54:39.426]  recursive: 0
  [20:54:39.426]  length: 6
  [20:54:39.426]  elements: 'a', 'b', 'c', '', '', ''
  [20:54:39.427] signalConditionsASAP(numeric, pos=1) ...
  [20:54:39.427] - nx: 6
  [20:54:39.427] - relay: TRUE
  [20:54:39.427] - stdout: TRUE
  [20:54:39.428] - signal: TRUE
  [20:54:39.428] - resignal: FALSE
  [20:54:39.428] - force: TRUE
  [20:54:39.428] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.428] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.429]  - until=2
  [20:54:39.429]  - relaying element #2
  [20:54:39.429] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.430] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.430] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:39.430]  length: 5 (resolved future 1)
  [20:54:39.489] Future #2
  [20:54:39.489] result() for ClusterFuture ...
  [20:54:39.489] - result already collected: FutureResult
  [20:54:39.490] result() for ClusterFuture ... done
  [20:54:39.490] result() for ClusterFuture ...
  [20:54:39.490] - result already collected: FutureResult
  [20:54:39.490] result() for ClusterFuture ... done
  [20:54:39.491] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:39.491] - nx: 6
  [20:54:39.491] - relay: TRUE
  [20:54:39.492] - stdout: TRUE
  [20:54:39.492] - signal: TRUE
  [20:54:39.492] - resignal: FALSE
  [20:54:39.492] - force: TRUE
  [20:54:39.493] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.493] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.493]  - until=2
  [20:54:39.494]  - relaying element #2
  [20:54:39.494] result() for ClusterFuture ...
  [20:54:39.494] - result already collected: FutureResult
  [20:54:39.494] result() for ClusterFuture ... done
  [20:54:39.495] result() for ClusterFuture ...
  [20:54:39.495] - result already collected: FutureResult
  [20:54:39.495] result() for ClusterFuture ... done
  [20:54:39.496] result() for ClusterFuture ...
  [20:54:39.496] - result already collected: FutureResult
  [20:54:39.496] result() for ClusterFuture ... done
  [20:54:39.496] result() for ClusterFuture ...
  [20:54:39.497] - result already collected: FutureResult
  [20:54:39.497] result() for ClusterFuture ... done
  [20:54:39.497] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.497] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.498] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:39.498]  length: 4 (resolved future 2)
  [20:54:39.499] Future #3
  [20:54:39.502] result() for ClusterFuture ...
  [20:54:39.502] - result already collected: FutureResult
  [20:54:39.502] result() for ClusterFuture ... done
  [20:54:39.502] result() for ClusterFuture ...
  [20:54:39.503] - result already collected: FutureResult
  [20:54:39.503] result() for ClusterFuture ... done
  [20:54:39.503] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:39.503] - nx: 6
  [20:54:39.504] - relay: TRUE
  [20:54:39.504] - stdout: TRUE
  [20:54:39.504] - signal: TRUE
  [20:54:39.504] - resignal: FALSE
  [20:54:39.505] - force: TRUE
  [20:54:39.505] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.505] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:39.505]  - until=3
  [20:54:39.506]  - relaying element #3
  [20:54:39.506] result() for ClusterFuture ...
  [20:54:39.506] - result already collected: FutureResult
  [20:54:39.506] result() for ClusterFuture ... done
  [20:54:39.507] result() for ClusterFuture ...
  [20:54:39.507] - result already collected: FutureResult
  [20:54:39.507] result() for ClusterFuture ... done
  [20:54:39.508] result() for ClusterFuture ...
  [20:54:39.508] - result already collected: FutureResult
  [20:54:39.508] result() for ClusterFuture ... done
  [20:54:39.508] result() for ClusterFuture ...
  [20:54:39.509] - result already collected: FutureResult
  [20:54:39.509] result() for ClusterFuture ... done
  [20:54:39.509] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.509] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.510] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:39.510]  length: 3 (resolved future 3)
  [20:54:39.510] signalConditionsASAP(NULL, pos=4) ...
  [20:54:39.510] - nx: 6
  [20:54:39.511] - relay: TRUE
  [20:54:39.511] - stdout: TRUE
  [20:54:39.511] - signal: TRUE
  [20:54:39.511] - resignal: FALSE
  [20:54:39.512] - force: TRUE
  [20:54:39.512] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.512] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.512]  - until=5
  [20:54:39.513]  - relaying element #5
  [20:54:39.513] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:39.513] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.513] signalConditionsASAP(NULL, pos=4) ... done
  [20:54:39.514]  length: 2 (resolved future 4)
  [20:54:39.514] signalConditionsASAP(NULL, pos=5) ...
  [20:54:39.514] - nx: 6
  [20:54:39.515] - relay: TRUE
  [20:54:39.515] - stdout: TRUE
  [20:54:39.515] - signal: TRUE
  [20:54:39.515] - resignal: FALSE
  [20:54:39.516] - force: TRUE
  [20:54:39.516] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:39.516] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.516]  - until=6
  [20:54:39.517]  - relaying element #6
  [20:54:39.517] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.517] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.518] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:39.518]  length: 1 (resolved future 5)
  [20:54:39.518] signalConditionsASAP(numeric, pos=6) ...
  [20:54:39.518] - nx: 6
  [20:54:39.519] - relay: TRUE
  [20:54:39.519] - stdout: TRUE
  [20:54:39.519] - signal: TRUE
  [20:54:39.519] - resignal: FALSE
  [20:54:39.520] - force: TRUE
  [20:54:39.520] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:39.520] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.520]  - until=6
  [20:54:39.521] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.521] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.521] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:39.521]  length: 0 (resolved future 6)
  [20:54:39.522] Relaying remaining futures
  [20:54:39.522] signalConditionsASAP(NULL, pos=0) ...
  [20:54:39.522] - nx: 6
  [20:54:39.522] - relay: TRUE
  [20:54:39.523] - stdout: TRUE
  [20:54:39.523] - signal: TRUE
  [20:54:39.523] - resignal: FALSE
  [20:54:39.523] - force: TRUE
  [20:54:39.523] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.524] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [20:54:39.524] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:39.524] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:39.524] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:39.525] resolve() on list ... DONE
  [20:54:39.525] result() for ClusterFuture ...
  [20:54:39.525] - result already collected: FutureResult
  [20:54:39.525] result() for ClusterFuture ... done
  [20:54:39.526] result() for ClusterFuture ...
  [20:54:39.526] - result already collected: FutureResult
  [20:54:39.526] result() for ClusterFuture ... done
  [20:54:39.526] result() for ClusterFuture ...
  [20:54:39.527] - result already collected: FutureResult
  [20:54:39.527] result() for ClusterFuture ... done
  [20:54:39.527] result() for ClusterFuture ...
  [20:54:39.527] - result already collected: FutureResult
  [20:54:39.527] 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
  [20:54:39.551] plan(): Setting new future strategy stack:
  [20:54:39.552] List of future strategies:
  [20:54:39.552] 1. sequential:
  [20:54:39.552]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.552]    - tweaked: FALSE
  [20:54:39.552]    - call: plan(strategy)
  [20:54:39.554] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [20:54:39.555] getGlobalsAndPackages() ...
  [20:54:39.555] Searching for globals...
  [20:54:39.556] 
  [20:54:39.556] Searching for globals ... DONE
  [20:54:39.556] - globals: [0] <none>
  [20:54:39.556] getGlobalsAndPackages() ... DONE
  [20:54:39.558] Packages needed by the future expression (n = 0): <none>
  [20:54:39.558] Packages needed by future strategies (n = 0): <none>
  [20:54:39.562] {
  [20:54:39.562]     {
  [20:54:39.562]         ...future.startTime <- base::Sys.time()
  [20:54:39.562]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.562]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.562]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.562]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.562]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.562]         {
  [20:54:39.562]             {
  [20:54:39.562]                 has_future <- base::requireNamespace("future", 
  [20:54:39.562]                   quietly = TRUE)
  [20:54:39.562]                 version <- if (has_future) 
  [20:54:39.562]                   utils::packageVersion("future")
  [20:54:39.562]                 else NULL
  [20:54:39.562]                 if (!has_future || version < "1.8.0") {
  [20:54:39.562]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.562]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.562]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.562]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.562]                       "release", "version")], collapse = " "), 
  [20:54:39.562]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.562]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.562]                     info)
  [20:54:39.562]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.562]                   if (!has_future) {
  [20:54:39.562]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.562]                       info)
  [20:54:39.562]                   }
  [20:54:39.562]                   else {
  [20:54:39.562]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.562]                       info, version)
  [20:54:39.562]                   }
  [20:54:39.562]                   base::stop(msg)
  [20:54:39.562]                 }
  [20:54:39.562]             }
  [20:54:39.562]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.562]         }
  [20:54:39.562]     }
  [20:54:39.562]     if (base::is.na(TRUE)) {
  [20:54:39.562]     }
  [20:54:39.562]     else {
  [20:54:39.562]         if (TRUE) {
  [20:54:39.562]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.562]                 open = "w")
  [20:54:39.562]         }
  [20:54:39.562]         else {
  [20:54:39.562]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.562]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.562]         }
  [20:54:39.562]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.562]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.562]             base::sink(type = "output", split = FALSE)
  [20:54:39.562]             base::close(...future.stdout)
  [20:54:39.562]         }, add = TRUE)
  [20:54:39.562]     }
  [20:54:39.562]     ...future.frame <- base::sys.nframe()
  [20:54:39.562]     ...future.conditions <- base::list()
  [20:54:39.562]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.562]     ...future.result <- base::tryCatch({
  [20:54:39.562]         base::withCallingHandlers({
  [20:54:39.562]             ...future.value <- base::withVisible(base::local(2))
  [20:54:39.562]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.562]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.562]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.562]                 version = "1.8")
  [20:54:39.562]         }, condition = base::local({
  [20:54:39.562]             c <- base::c
  [20:54:39.562]             inherits <- base::inherits
  [20:54:39.562]             invokeRestart <- base::invokeRestart
  [20:54:39.562]             length <- base::length
  [20:54:39.562]             list <- base::list
  [20:54:39.562]             seq.int <- base::seq.int
  [20:54:39.562]             signalCondition <- base::signalCondition
  [20:54:39.562]             sys.calls <- base::sys.calls
  [20:54:39.562]             Sys.time <- base::Sys.time
  [20:54:39.562]             `[[` <- base::`[[`
  [20:54:39.562]             `+` <- base::`+`
  [20:54:39.562]             `<<-` <- base::`<<-`
  [20:54:39.562]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.562]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.562]                   3L)]
  [20:54:39.562]             }
  [20:54:39.562]             function(cond) {
  [20:54:39.562]                 if (inherits(cond, "error")) {
  [20:54:39.562]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.562]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.562]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.562]                   signalCondition(cond)
  [20:54:39.562]                 }
  [20:54:39.562]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.562]                 ))) {
  [20:54:39.562]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.562]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.562]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.562]                   if (!signal) {
  [20:54:39.562]                     muffleCondition <- function (cond) 
  [20:54:39.562]                     {
  [20:54:39.562]                       inherits <- base::inherits
  [20:54:39.562]                       invokeRestart <- base::invokeRestart
  [20:54:39.562]                       muffled <- FALSE
  [20:54:39.562]                       if (inherits(cond, "message")) {
  [20:54:39.562]                         invokeRestart("muffleMessage")
  [20:54:39.562]                         muffled <- TRUE
  [20:54:39.562]                       }
  [20:54:39.562]                       else if (inherits(cond, "warning")) {
  [20:54:39.562]                         invokeRestart("muffleWarning")
  [20:54:39.562]                         muffled <- TRUE
  [20:54:39.562]                       }
  [20:54:39.562]                       else if (inherits(cond, "condition")) {
  [20:54:39.562]                         computeRestarts <- base::computeRestarts
  [20:54:39.562]                         grepl <- base::grepl
  [20:54:39.562]                         is.null <- base::is.null
  [20:54:39.562]                         restarts <- computeRestarts(cond)
  [20:54:39.562]                         for (restart in restarts) {
  [20:54:39.562]                           name <- restart$name
  [20:54:39.562]                           if (is.null(name)) 
  [20:54:39.562]                             next
  [20:54:39.562]                           if (!grepl("^muffle", name)) 
  [20:54:39.562]                             next
  [20:54:39.562]                           invokeRestart(restart)
  [20:54:39.562]                           muffled <- TRUE
  [20:54:39.562]                           break
  [20:54:39.562]                         }
  [20:54:39.562]                       }
  [20:54:39.562]                       invisible(muffled)
  [20:54:39.562]                     }
  [20:54:39.562]                     muffleCondition(cond)
  [20:54:39.562]                   }
  [20:54:39.562]                 }
  [20:54:39.562]             }
  [20:54:39.562]         }))
  [20:54:39.562]     }, error = function(ex) {
  [20:54:39.562]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.562]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.562]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.562]     }, finally = {
  [20:54:39.562]         {
  [20:54:39.562]             NULL
  [20:54:39.562]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.562]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.562]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.562]                 label = NULL, ...) 
  [20:54:39.562]             {
  [20:54:39.562]                 if (substitute) 
  [20:54:39.562]                   expr <- substitute(expr)
  [20:54:39.562]                 local <- as.logical(local)
  [20:54:39.562]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.562]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.562]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.562]                   label = label, ...)
  [20:54:39.562]                 if (!future$lazy) 
  [20:54:39.562]                   future <- run(future)
  [20:54:39.562]                 invisible(future)
  [20:54:39.562]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.562]         }
  [20:54:39.562]         base::options(...future.oldOptions)
  [20:54:39.562]     })
  [20:54:39.562]     Sys.time
  [20:54:39.562]     if (base::is.na(TRUE)) {
  [20:54:39.562]     }
  [20:54:39.562]     else {
  [20:54:39.562]         base::sink(type = "output", split = FALSE)
  [20:54:39.562]         if (TRUE) {
  [20:54:39.562]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.562]         }
  [20:54:39.562]         else {
  [20:54:39.562]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.562]         }
  [20:54:39.562]         base::close(...future.stdout)
  [20:54:39.562]         ...future.stdout <- NULL
  [20:54:39.562]     }
  [20:54:39.562]     ...future.result$conditions <- ...future.conditions
  [20:54:39.562]     ...future.result
  [20:54:39.562] }
  [20:54:39.566] plan(): Setting new future strategy stack:
  [20:54:39.567] List of future strategies:
  [20:54:39.567] 1. sequential:
  [20:54:39.567]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.567]    - tweaked: FALSE
  [20:54:39.567]    - call: NULL
  [20:54:39.568] plan(): nbrOfWorkers() = 1
  [20:54:39.569] plan(): Setting new future strategy stack:
  [20:54:39.569] List of future strategies:
  [20:54:39.569] 1. sequential:
  [20:54:39.569]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.569]    - tweaked: FALSE
  [20:54:39.569]    - call: plan(strategy)
  [20:54:39.570] plan(): nbrOfWorkers() = 1
  [20:54:39.570] SequentialFuture started (and completed)
  [20:54:39.570] getGlobalsAndPackages() ...
  [20:54:39.571] Searching for globals...
  [20:54:39.571] 
  [20:54:39.572] Searching for globals ... DONE
  [20:54:39.572] - globals: [0] <none>
  [20:54:39.572] getGlobalsAndPackages() ... DONE
  [20:54:39.590] Packages needed by the future expression (n = 0): <none>
  [20:54:39.590] Packages needed by future strategies (n = 0): <none>
  [20:54:39.594] {
  [20:54:39.594]     {
  [20:54:39.594]         ...future.startTime <- base::Sys.time()
  [20:54:39.594]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.594]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.594]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.594]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.594]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.594]         {
  [20:54:39.594]             {
  [20:54:39.594]                 has_future <- base::requireNamespace("future", 
  [20:54:39.594]                   quietly = TRUE)
  [20:54:39.594]                 version <- if (has_future) 
  [20:54:39.594]                   utils::packageVersion("future")
  [20:54:39.594]                 else NULL
  [20:54:39.594]                 if (!has_future || version < "1.8.0") {
  [20:54:39.594]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.594]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.594]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.594]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.594]                       "release", "version")], collapse = " "), 
  [20:54:39.594]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.594]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.594]                     info)
  [20:54:39.594]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.594]                   if (!has_future) {
  [20:54:39.594]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.594]                       info)
  [20:54:39.594]                   }
  [20:54:39.594]                   else {
  [20:54:39.594]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.594]                       info, version)
  [20:54:39.594]                   }
  [20:54:39.594]                   base::stop(msg)
  [20:54:39.594]                 }
  [20:54:39.594]             }
  [20:54:39.594]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.594]         }
  [20:54:39.594]     }
  [20:54:39.594]     if (base::is.na(TRUE)) {
  [20:54:39.594]     }
  [20:54:39.594]     else {
  [20:54:39.594]         if (TRUE) {
  [20:54:39.594]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.594]                 open = "w")
  [20:54:39.594]         }
  [20:54:39.594]         else {
  [20:54:39.594]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.594]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.594]         }
  [20:54:39.594]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.594]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.594]             base::sink(type = "output", split = FALSE)
  [20:54:39.594]             base::close(...future.stdout)
  [20:54:39.594]         }, add = TRUE)
  [20:54:39.594]     }
  [20:54:39.594]     ...future.frame <- base::sys.nframe()
  [20:54:39.594]     ...future.conditions <- base::list()
  [20:54:39.594]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.594]     ...future.result <- base::tryCatch({
  [20:54:39.594]         base::withCallingHandlers({
  [20:54:39.594]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:39.594]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.594]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.594]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.594]                 version = "1.8")
  [20:54:39.594]         }, condition = base::local({
  [20:54:39.594]             c <- base::c
  [20:54:39.594]             inherits <- base::inherits
  [20:54:39.594]             invokeRestart <- base::invokeRestart
  [20:54:39.594]             length <- base::length
  [20:54:39.594]             list <- base::list
  [20:54:39.594]             seq.int <- base::seq.int
  [20:54:39.594]             signalCondition <- base::signalCondition
  [20:54:39.594]             sys.calls <- base::sys.calls
  [20:54:39.594]             Sys.time <- base::Sys.time
  [20:54:39.594]             `[[` <- base::`[[`
  [20:54:39.594]             `+` <- base::`+`
  [20:54:39.594]             `<<-` <- base::`<<-`
  [20:54:39.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.594]                   3L)]
  [20:54:39.594]             }
  [20:54:39.594]             function(cond) {
  [20:54:39.594]                 if (inherits(cond, "error")) {
  [20:54:39.594]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.594]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.594]                   signalCondition(cond)
  [20:54:39.594]                 }
  [20:54:39.594]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.594]                 ))) {
  [20:54:39.594]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.594]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.594]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.594]                   if (!signal) {
  [20:54:39.594]                     muffleCondition <- function (cond) 
  [20:54:39.594]                     {
  [20:54:39.594]                       inherits <- base::inherits
  [20:54:39.594]                       invokeRestart <- base::invokeRestart
  [20:54:39.594]                       muffled <- FALSE
  [20:54:39.594]                       if (inherits(cond, "message")) {
  [20:54:39.594]                         invokeRestart("muffleMessage")
  [20:54:39.594]                         muffled <- TRUE
  [20:54:39.594]                       }
  [20:54:39.594]                       else if (inherits(cond, "warning")) {
  [20:54:39.594]                         invokeRestart("muffleWarning")
  [20:54:39.594]                         muffled <- TRUE
  [20:54:39.594]                       }
  [20:54:39.594]                       else if (inherits(cond, "condition")) {
  [20:54:39.594]                         computeRestarts <- base::computeRestarts
  [20:54:39.594]                         grepl <- base::grepl
  [20:54:39.594]                         is.null <- base::is.null
  [20:54:39.594]                         restarts <- computeRestarts(cond)
  [20:54:39.594]                         for (restart in restarts) {
  [20:54:39.594]                           name <- restart$name
  [20:54:39.594]                           if (is.null(name)) 
  [20:54:39.594]                             next
  [20:54:39.594]                           if (!grepl("^muffle", name)) 
  [20:54:39.594]                             next
  [20:54:39.594]                           invokeRestart(restart)
  [20:54:39.594]                           muffled <- TRUE
  [20:54:39.594]                           break
  [20:54:39.594]                         }
  [20:54:39.594]                       }
  [20:54:39.594]                       invisible(muffled)
  [20:54:39.594]                     }
  [20:54:39.594]                     muffleCondition(cond)
  [20:54:39.594]                   }
  [20:54:39.594]                 }
  [20:54:39.594]             }
  [20:54:39.594]         }))
  [20:54:39.594]     }, error = function(ex) {
  [20:54:39.594]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.594]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.594]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.594]     }, finally = {
  [20:54:39.594]         {
  [20:54:39.594]             NULL
  [20:54:39.594]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.594]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.594]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.594]                 label = NULL, ...) 
  [20:54:39.594]             {
  [20:54:39.594]                 if (substitute) 
  [20:54:39.594]                   expr <- substitute(expr)
  [20:54:39.594]                 local <- as.logical(local)
  [20:54:39.594]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.594]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.594]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.594]                   label = label, ...)
  [20:54:39.594]                 if (!future$lazy) 
  [20:54:39.594]                   future <- run(future)
  [20:54:39.594]                 invisible(future)
  [20:54:39.594]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.594]         }
  [20:54:39.594]         base::options(...future.oldOptions)
  [20:54:39.594]     })
  [20:54:39.594]     Sys.time
  [20:54:39.594]     if (base::is.na(TRUE)) {
  [20:54:39.594]     }
  [20:54:39.594]     else {
  [20:54:39.594]         base::sink(type = "output", split = FALSE)
  [20:54:39.594]         if (TRUE) {
  [20:54:39.594]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.594]         }
  [20:54:39.594]         else {
  [20:54:39.594]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.594]         }
  [20:54:39.594]         base::close(...future.stdout)
  [20:54:39.594]         ...future.stdout <- NULL
  [20:54:39.594]     }
  [20:54:39.594]     ...future.result$conditions <- ...future.conditions
  [20:54:39.594]     ...future.result
  [20:54:39.594] }
  [20:54:39.599] plan(): Setting new future strategy stack:
  [20:54:39.599] List of future strategies:
  [20:54:39.599] 1. sequential:
  [20:54:39.599]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.599]    - tweaked: FALSE
  [20:54:39.599]    - call: NULL
  [20:54:39.600] plan(): nbrOfWorkers() = 1
  [20:54:39.601] plan(): Setting new future strategy stack:
  [20:54:39.601] List of future strategies:
  [20:54:39.601] 1. sequential:
  [20:54:39.601]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.601]    - tweaked: FALSE
  [20:54:39.601]    - call: plan(strategy)
  [20:54:39.602] plan(): nbrOfWorkers() = 1
  [20:54:39.602] SequentialFuture started (and completed)
  [20:54:39.605] getGlobalsAndPackages() ...
  [20:54:39.605] Searching for globals...
  [20:54:39.626] - globals found: [1] '{'
  [20:54:39.626] Searching for globals ... DONE
  [20:54:39.626] Resolving globals: FALSE
  [20:54:39.627] 
  [20:54:39.627] 
  [20:54:39.628] getGlobalsAndPackages() ... DONE
  [20:54:39.629] Packages needed by the future expression (n = 0): <none>
  [20:54:39.629] Packages needed by future strategies (n = 0): <none>
  [20:54:39.633] {
  [20:54:39.633]     {
  [20:54:39.633]         ...future.startTime <- base::Sys.time()
  [20:54:39.633]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.633]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.633]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.633]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.633]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.633]         {
  [20:54:39.633]             {
  [20:54:39.633]                 has_future <- base::requireNamespace("future", 
  [20:54:39.633]                   quietly = TRUE)
  [20:54:39.633]                 version <- if (has_future) 
  [20:54:39.633]                   utils::packageVersion("future")
  [20:54:39.633]                 else NULL
  [20:54:39.633]                 if (!has_future || version < "1.8.0") {
  [20:54:39.633]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.633]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.633]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.633]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.633]                       "release", "version")], collapse = " "), 
  [20:54:39.633]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.633]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.633]                     info)
  [20:54:39.633]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.633]                   if (!has_future) {
  [20:54:39.633]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.633]                       info)
  [20:54:39.633]                   }
  [20:54:39.633]                   else {
  [20:54:39.633]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.633]                       info, version)
  [20:54:39.633]                   }
  [20:54:39.633]                   base::stop(msg)
  [20:54:39.633]                 }
  [20:54:39.633]             }
  [20:54:39.633]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.633]         }
  [20:54:39.633]     }
  [20:54:39.633]     if (base::is.na(TRUE)) {
  [20:54:39.633]     }
  [20:54:39.633]     else {
  [20:54:39.633]         if (TRUE) {
  [20:54:39.633]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.633]                 open = "w")
  [20:54:39.633]         }
  [20:54:39.633]         else {
  [20:54:39.633]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.633]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.633]         }
  [20:54:39.633]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.633]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.633]             base::sink(type = "output", split = FALSE)
  [20:54:39.633]             base::close(...future.stdout)
  [20:54:39.633]         }, add = TRUE)
  [20:54:39.633]     }
  [20:54:39.633]     ...future.frame <- base::sys.nframe()
  [20:54:39.633]     ...future.conditions <- base::list()
  [20:54:39.633]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.633]     ...future.result <- base::tryCatch({
  [20:54:39.633]         base::withCallingHandlers({
  [20:54:39.633]             ...future.value <- base::withVisible(base::local({
  [20:54:39.633]                 4
  [20:54:39.633]             }))
  [20:54:39.633]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.633]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.633]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.633]                 version = "1.8")
  [20:54:39.633]         }, condition = base::local({
  [20:54:39.633]             c <- base::c
  [20:54:39.633]             inherits <- base::inherits
  [20:54:39.633]             invokeRestart <- base::invokeRestart
  [20:54:39.633]             length <- base::length
  [20:54:39.633]             list <- base::list
  [20:54:39.633]             seq.int <- base::seq.int
  [20:54:39.633]             signalCondition <- base::signalCondition
  [20:54:39.633]             sys.calls <- base::sys.calls
  [20:54:39.633]             Sys.time <- base::Sys.time
  [20:54:39.633]             `[[` <- base::`[[`
  [20:54:39.633]             `+` <- base::`+`
  [20:54:39.633]             `<<-` <- base::`<<-`
  [20:54:39.633]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.633]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.633]                   3L)]
  [20:54:39.633]             }
  [20:54:39.633]             function(cond) {
  [20:54:39.633]                 if (inherits(cond, "error")) {
  [20:54:39.633]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.633]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.633]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.633]                   signalCondition(cond)
  [20:54:39.633]                 }
  [20:54:39.633]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.633]                 ))) {
  [20:54:39.633]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.633]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.633]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.633]                   if (!signal) {
  [20:54:39.633]                     muffleCondition <- function (cond) 
  [20:54:39.633]                     {
  [20:54:39.633]                       inherits <- base::inherits
  [20:54:39.633]                       invokeRestart <- base::invokeRestart
  [20:54:39.633]                       muffled <- FALSE
  [20:54:39.633]                       if (inherits(cond, "message")) {
  [20:54:39.633]                         invokeRestart("muffleMessage")
  [20:54:39.633]                         muffled <- TRUE
  [20:54:39.633]                       }
  [20:54:39.633]                       else if (inherits(cond, "warning")) {
  [20:54:39.633]                         invokeRestart("muffleWarning")
  [20:54:39.633]                         muffled <- TRUE
  [20:54:39.633]                       }
  [20:54:39.633]                       else if (inherits(cond, "condition")) {
  [20:54:39.633]                         computeRestarts <- base::computeRestarts
  [20:54:39.633]                         grepl <- base::grepl
  [20:54:39.633]                         is.null <- base::is.null
  [20:54:39.633]                         restarts <- computeRestarts(cond)
  [20:54:39.633]                         for (restart in restarts) {
  [20:54:39.633]                           name <- restart$name
  [20:54:39.633]                           if (is.null(name)) 
  [20:54:39.633]                             next
  [20:54:39.633]                           if (!grepl("^muffle", name)) 
  [20:54:39.633]                             next
  [20:54:39.633]                           invokeRestart(restart)
  [20:54:39.633]                           muffled <- TRUE
  [20:54:39.633]                           break
  [20:54:39.633]                         }
  [20:54:39.633]                       }
  [20:54:39.633]                       invisible(muffled)
  [20:54:39.633]                     }
  [20:54:39.633]                     muffleCondition(cond)
  [20:54:39.633]                   }
  [20:54:39.633]                 }
  [20:54:39.633]             }
  [20:54:39.633]         }))
  [20:54:39.633]     }, error = function(ex) {
  [20:54:39.633]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.633]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.633]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.633]     }, finally = {
  [20:54:39.633]         {
  [20:54:39.633]             NULL
  [20:54:39.633]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.633]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.633]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.633]                 label = NULL, ...) 
  [20:54:39.633]             {
  [20:54:39.633]                 if (substitute) 
  [20:54:39.633]                   expr <- substitute(expr)
  [20:54:39.633]                 local <- as.logical(local)
  [20:54:39.633]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.633]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.633]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.633]                   label = label, ...)
  [20:54:39.633]                 if (!future$lazy) 
  [20:54:39.633]                   future <- run(future)
  [20:54:39.633]                 invisible(future)
  [20:54:39.633]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.633]         }
  [20:54:39.633]         base::options(...future.oldOptions)
  [20:54:39.633]     })
  [20:54:39.633]     Sys.time
  [20:54:39.633]     if (base::is.na(TRUE)) {
  [20:54:39.633]     }
  [20:54:39.633]     else {
  [20:54:39.633]         base::sink(type = "output", split = FALSE)
  [20:54:39.633]         if (TRUE) {
  [20:54:39.633]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.633]         }
  [20:54:39.633]         else {
  [20:54:39.633]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.633]         }
  [20:54:39.633]         base::close(...future.stdout)
  [20:54:39.633]         ...future.stdout <- NULL
  [20:54:39.633]     }
  [20:54:39.633]     ...future.result$conditions <- ...future.conditions
  [20:54:39.633]     ...future.result
  [20:54:39.633] }
  [20:54:39.650] plan(): Setting new future strategy stack:
  [20:54:39.650] List of future strategies:
  [20:54:39.650] 1. sequential:
  [20:54:39.650]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.650]    - tweaked: FALSE
  [20:54:39.650]    - call: NULL
  [20:54:39.651] plan(): nbrOfWorkers() = 1
  [20:54:39.652] plan(): Setting new future strategy stack:
  [20:54:39.652] List of future strategies:
  [20:54:39.652] 1. sequential:
  [20:54:39.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.652]    - tweaked: FALSE
  [20:54:39.652]    - call: plan(strategy)
  [20:54:39.653] plan(): nbrOfWorkers() = 1
  [20:54:39.658] SequentialFuture started (and completed)
  <environment: 0x556b119f6fc8> 
  <environment: 0x556b102246b0> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:39.665] resolve() on environment ...
  [20:54:39.665]  recursive: 0
  [20:54:39.682]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:39.683] signalConditionsASAP(numeric, pos=1) ...
  [20:54:39.683] - nx: 4
  [20:54:39.683] - relay: TRUE
  [20:54:39.683] - stdout: TRUE
  [20:54:39.684] - signal: TRUE
  [20:54:39.684] - resignal: FALSE
  [20:54:39.684] - force: TRUE
  [20:54:39.684] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.685] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.685]  - until=2
  [20:54:39.685]  - relaying element #2
  [20:54:39.685] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:39.686] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.686] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:39.686]  length: 3 (resolved future 1)
  [20:54:39.686] Future #2
  [20:54:39.687] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:39.687] - nx: 4
  [20:54:39.687] - relay: TRUE
  [20:54:39.687] - stdout: TRUE
  [20:54:39.688] - signal: TRUE
  [20:54:39.688] - resignal: FALSE
  [20:54:39.688] - force: TRUE
  [20:54:39.688] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:39.688] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.689]  - until=2
  [20:54:39.689]  - relaying element #2
  [20:54:39.689] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:39.690] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:39.690] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:39.690]  length: 2 (resolved future 2)
  [20:54:39.691] Future #3
  [20:54:39.691] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:39.691] - nx: 4
  [20:54:39.691] - relay: TRUE
  [20:54:39.692] - stdout: TRUE
  [20:54:39.692] - signal: TRUE
  [20:54:39.692] - resignal: FALSE
  [20:54:39.692] - force: TRUE
  [20:54:39.692] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:39.693] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:39.693]  - until=3
  [20:54:39.693]  - relaying element #3
  [20:54:39.694] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:39.694] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:39.694] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:39.694]  length: 1 (resolved future 3)
  [20:54:39.695] Future #4
  [20:54:39.695] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:39.695] - nx: 4
  [20:54:39.696] - relay: TRUE
  [20:54:39.696] - stdout: TRUE
  [20:54:39.696] - signal: TRUE
  [20:54:39.696] - resignal: FALSE
  [20:54:39.696] - force: TRUE
  [20:54:39.697] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:39.697] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:39.697]  - until=4
  [20:54:39.697]  - relaying element #4
  [20:54:39.714] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.714] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:39.715] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:39.715]  length: 0 (resolved future 4)
  [20:54:39.715] Relaying remaining futures
  [20:54:39.715] signalConditionsASAP(NULL, pos=0) ...
  [20:54:39.716] - nx: 4
  [20:54:39.716] - relay: TRUE
  [20:54:39.716] - stdout: TRUE
  [20:54:39.716] - signal: TRUE
  [20:54:39.716] - resignal: FALSE
  [20:54:39.717] - force: TRUE
  [20:54:39.717] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.717] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:39.717] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.718] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:39.718] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:39.718] resolve() on environment ... DONE
  <environment: 0x556b104fc270> 
  Dimensions: c(1, 6)
  [20:54:39.719] getGlobalsAndPackages() ...
  [20:54:39.720] Searching for globals...
  [20:54:39.720] 
  [20:54:39.720] Searching for globals ... DONE
  [20:54:39.721] - globals: [0] <none>
  [20:54:39.721] getGlobalsAndPackages() ... DONE
  [20:54:39.722] Packages needed by the future expression (n = 0): <none>
  [20:54:39.723] Packages needed by future strategies (n = 0): <none>
  [20:54:39.726] {
  [20:54:39.726]     {
  [20:54:39.726]         ...future.startTime <- base::Sys.time()
  [20:54:39.726]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.726]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.726]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.726]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.726]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.726]         {
  [20:54:39.726]             {
  [20:54:39.726]                 has_future <- base::requireNamespace("future", 
  [20:54:39.726]                   quietly = TRUE)
  [20:54:39.726]                 version <- if (has_future) 
  [20:54:39.726]                   utils::packageVersion("future")
  [20:54:39.726]                 else NULL
  [20:54:39.726]                 if (!has_future || version < "1.8.0") {
  [20:54:39.726]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.726]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.726]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.726]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.726]                       "release", "version")], collapse = " "), 
  [20:54:39.726]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.726]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.726]                     info)
  [20:54:39.726]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.726]                   if (!has_future) {
  [20:54:39.726]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.726]                       info)
  [20:54:39.726]                   }
  [20:54:39.726]                   else {
  [20:54:39.726]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.726]                       info, version)
  [20:54:39.726]                   }
  [20:54:39.726]                   base::stop(msg)
  [20:54:39.726]                 }
  [20:54:39.726]             }
  [20:54:39.726]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.726]         }
  [20:54:39.726]     }
  [20:54:39.726]     if (base::is.na(TRUE)) {
  [20:54:39.726]     }
  [20:54:39.726]     else {
  [20:54:39.726]         if (TRUE) {
  [20:54:39.726]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.726]                 open = "w")
  [20:54:39.726]         }
  [20:54:39.726]         else {
  [20:54:39.726]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.726]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.726]         }
  [20:54:39.726]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.726]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.726]             base::sink(type = "output", split = FALSE)
  [20:54:39.726]             base::close(...future.stdout)
  [20:54:39.726]         }, add = TRUE)
  [20:54:39.726]     }
  [20:54:39.726]     ...future.frame <- base::sys.nframe()
  [20:54:39.726]     ...future.conditions <- base::list()
  [20:54:39.726]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.726]     ...future.result <- base::tryCatch({
  [20:54:39.726]         base::withCallingHandlers({
  [20:54:39.726]             ...future.value <- base::withVisible(base::local(2))
  [20:54:39.726]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.726]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.726]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.726]                 version = "1.8")
  [20:54:39.726]         }, condition = base::local({
  [20:54:39.726]             c <- base::c
  [20:54:39.726]             inherits <- base::inherits
  [20:54:39.726]             invokeRestart <- base::invokeRestart
  [20:54:39.726]             length <- base::length
  [20:54:39.726]             list <- base::list
  [20:54:39.726]             seq.int <- base::seq.int
  [20:54:39.726]             signalCondition <- base::signalCondition
  [20:54:39.726]             sys.calls <- base::sys.calls
  [20:54:39.726]             Sys.time <- base::Sys.time
  [20:54:39.726]             `[[` <- base::`[[`
  [20:54:39.726]             `+` <- base::`+`
  [20:54:39.726]             `<<-` <- base::`<<-`
  [20:54:39.726]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.726]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.726]                   3L)]
  [20:54:39.726]             }
  [20:54:39.726]             function(cond) {
  [20:54:39.726]                 if (inherits(cond, "error")) {
  [20:54:39.726]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.726]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.726]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.726]                   signalCondition(cond)
  [20:54:39.726]                 }
  [20:54:39.726]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.726]                 ))) {
  [20:54:39.726]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.726]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.726]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.726]                   if (!signal) {
  [20:54:39.726]                     muffleCondition <- function (cond) 
  [20:54:39.726]                     {
  [20:54:39.726]                       inherits <- base::inherits
  [20:54:39.726]                       invokeRestart <- base::invokeRestart
  [20:54:39.726]                       muffled <- FALSE
  [20:54:39.726]                       if (inherits(cond, "message")) {
  [20:54:39.726]                         invokeRestart("muffleMessage")
  [20:54:39.726]                         muffled <- TRUE
  [20:54:39.726]                       }
  [20:54:39.726]                       else if (inherits(cond, "warning")) {
  [20:54:39.726]                         invokeRestart("muffleWarning")
  [20:54:39.726]                         muffled <- TRUE
  [20:54:39.726]                       }
  [20:54:39.726]                       else if (inherits(cond, "condition")) {
  [20:54:39.726]                         computeRestarts <- base::computeRestarts
  [20:54:39.726]                         grepl <- base::grepl
  [20:54:39.726]                         is.null <- base::is.null
  [20:54:39.726]                         restarts <- computeRestarts(cond)
  [20:54:39.726]                         for (restart in restarts) {
  [20:54:39.726]                           name <- restart$name
  [20:54:39.726]                           if (is.null(name)) 
  [20:54:39.726]                             next
  [20:54:39.726]                           if (!grepl("^muffle", name)) 
  [20:54:39.726]                             next
  [20:54:39.726]                           invokeRestart(restart)
  [20:54:39.726]                           muffled <- TRUE
  [20:54:39.726]                           break
  [20:54:39.726]                         }
  [20:54:39.726]                       }
  [20:54:39.726]                       invisible(muffled)
  [20:54:39.726]                     }
  [20:54:39.726]                     muffleCondition(cond)
  [20:54:39.726]                   }
  [20:54:39.726]                 }
  [20:54:39.726]             }
  [20:54:39.726]         }))
  [20:54:39.726]     }, error = function(ex) {
  [20:54:39.726]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.726]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.726]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.726]     }, finally = {
  [20:54:39.726]         {
  [20:54:39.726]             NULL
  [20:54:39.726]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.726]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.726]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.726]                 label = NULL, ...) 
  [20:54:39.726]             {
  [20:54:39.726]                 if (substitute) 
  [20:54:39.726]                   expr <- substitute(expr)
  [20:54:39.726]                 local <- as.logical(local)
  [20:54:39.726]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.726]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.726]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.726]                   label = label, ...)
  [20:54:39.726]                 if (!future$lazy) 
  [20:54:39.726]                   future <- run(future)
  [20:54:39.726]                 invisible(future)
  [20:54:39.726]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.726]         }
  [20:54:39.726]         base::options(...future.oldOptions)
  [20:54:39.726]     })
  [20:54:39.726]     Sys.time
  [20:54:39.726]     if (base::is.na(TRUE)) {
  [20:54:39.726]     }
  [20:54:39.726]     else {
  [20:54:39.726]         base::sink(type = "output", split = FALSE)
  [20:54:39.726]         if (TRUE) {
  [20:54:39.726]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.726]         }
  [20:54:39.726]         else {
  [20:54:39.726]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.726]         }
  [20:54:39.726]         base::close(...future.stdout)
  [20:54:39.726]         ...future.stdout <- NULL
  [20:54:39.726]     }
  [20:54:39.726]     ...future.result$conditions <- ...future.conditions
  [20:54:39.726]     ...future.result
  [20:54:39.726] }
  [20:54:39.747] plan(): Setting new future strategy stack:
  [20:54:39.747] List of future strategies:
  [20:54:39.747] 1. sequential:
  [20:54:39.747]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.747]    - tweaked: FALSE
  [20:54:39.747]    - call: NULL
  [20:54:39.748] plan(): nbrOfWorkers() = 1
  [20:54:39.749] plan(): Setting new future strategy stack:
  [20:54:39.749] List of future strategies:
  [20:54:39.749] 1. sequential:
  [20:54:39.749]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.749]    - tweaked: FALSE
  [20:54:39.749]    - call: plan(strategy)
  [20:54:39.750] plan(): nbrOfWorkers() = 1
  [20:54:39.750] SequentialFuture started (and completed)
  [20:54:39.751] getGlobalsAndPackages() ...
  [20:54:39.751] Searching for globals...
  [20:54:39.751] 
  [20:54:39.752] Searching for globals ... DONE
  [20:54:39.752] - globals: [0] <none>
  [20:54:39.752] getGlobalsAndPackages() ... DONE
  [20:54:39.754] Packages needed by the future expression (n = 0): <none>
  [20:54:39.754] Packages needed by future strategies (n = 0): <none>
  [20:54:39.778] {
  [20:54:39.778]     {
  [20:54:39.778]         ...future.startTime <- base::Sys.time()
  [20:54:39.778]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.778]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.778]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.778]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.778]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.778]         {
  [20:54:39.778]             {
  [20:54:39.778]                 has_future <- base::requireNamespace("future", 
  [20:54:39.778]                   quietly = TRUE)
  [20:54:39.778]                 version <- if (has_future) 
  [20:54:39.778]                   utils::packageVersion("future")
  [20:54:39.778]                 else NULL
  [20:54:39.778]                 if (!has_future || version < "1.8.0") {
  [20:54:39.778]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.778]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.778]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.778]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.778]                       "release", "version")], collapse = " "), 
  [20:54:39.778]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.778]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.778]                     info)
  [20:54:39.778]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.778]                   if (!has_future) {
  [20:54:39.778]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.778]                       info)
  [20:54:39.778]                   }
  [20:54:39.778]                   else {
  [20:54:39.778]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.778]                       info, version)
  [20:54:39.778]                   }
  [20:54:39.778]                   base::stop(msg)
  [20:54:39.778]                 }
  [20:54:39.778]             }
  [20:54:39.778]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.778]         }
  [20:54:39.778]     }
  [20:54:39.778]     if (base::is.na(TRUE)) {
  [20:54:39.778]     }
  [20:54:39.778]     else {
  [20:54:39.778]         if (TRUE) {
  [20:54:39.778]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.778]                 open = "w")
  [20:54:39.778]         }
  [20:54:39.778]         else {
  [20:54:39.778]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.778]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.778]         }
  [20:54:39.778]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.778]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.778]             base::sink(type = "output", split = FALSE)
  [20:54:39.778]             base::close(...future.stdout)
  [20:54:39.778]         }, add = TRUE)
  [20:54:39.778]     }
  [20:54:39.778]     ...future.frame <- base::sys.nframe()
  [20:54:39.778]     ...future.conditions <- base::list()
  [20:54:39.778]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.778]     ...future.result <- base::tryCatch({
  [20:54:39.778]         base::withCallingHandlers({
  [20:54:39.778]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:39.778]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.778]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.778]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.778]                 version = "1.8")
  [20:54:39.778]         }, condition = base::local({
  [20:54:39.778]             c <- base::c
  [20:54:39.778]             inherits <- base::inherits
  [20:54:39.778]             invokeRestart <- base::invokeRestart
  [20:54:39.778]             length <- base::length
  [20:54:39.778]             list <- base::list
  [20:54:39.778]             seq.int <- base::seq.int
  [20:54:39.778]             signalCondition <- base::signalCondition
  [20:54:39.778]             sys.calls <- base::sys.calls
  [20:54:39.778]             Sys.time <- base::Sys.time
  [20:54:39.778]             `[[` <- base::`[[`
  [20:54:39.778]             `+` <- base::`+`
  [20:54:39.778]             `<<-` <- base::`<<-`
  [20:54:39.778]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.778]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.778]                   3L)]
  [20:54:39.778]             }
  [20:54:39.778]             function(cond) {
  [20:54:39.778]                 if (inherits(cond, "error")) {
  [20:54:39.778]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.778]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.778]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.778]                   signalCondition(cond)
  [20:54:39.778]                 }
  [20:54:39.778]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.778]                 ))) {
  [20:54:39.778]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.778]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.778]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.778]                   if (!signal) {
  [20:54:39.778]                     muffleCondition <- function (cond) 
  [20:54:39.778]                     {
  [20:54:39.778]                       inherits <- base::inherits
  [20:54:39.778]                       invokeRestart <- base::invokeRestart
  [20:54:39.778]                       muffled <- FALSE
  [20:54:39.778]                       if (inherits(cond, "message")) {
  [20:54:39.778]                         invokeRestart("muffleMessage")
  [20:54:39.778]                         muffled <- TRUE
  [20:54:39.778]                       }
  [20:54:39.778]                       else if (inherits(cond, "warning")) {
  [20:54:39.778]                         invokeRestart("muffleWarning")
  [20:54:39.778]                         muffled <- TRUE
  [20:54:39.778]                       }
  [20:54:39.778]                       else if (inherits(cond, "condition")) {
  [20:54:39.778]                         computeRestarts <- base::computeRestarts
  [20:54:39.778]                         grepl <- base::grepl
  [20:54:39.778]                         is.null <- base::is.null
  [20:54:39.778]                         restarts <- computeRestarts(cond)
  [20:54:39.778]                         for (restart in restarts) {
  [20:54:39.778]                           name <- restart$name
  [20:54:39.778]                           if (is.null(name)) 
  [20:54:39.778]                             next
  [20:54:39.778]                           if (!grepl("^muffle", name)) 
  [20:54:39.778]                             next
  [20:54:39.778]                           invokeRestart(restart)
  [20:54:39.778]                           muffled <- TRUE
  [20:54:39.778]                           break
  [20:54:39.778]                         }
  [20:54:39.778]                       }
  [20:54:39.778]                       invisible(muffled)
  [20:54:39.778]                     }
  [20:54:39.778]                     muffleCondition(cond)
  [20:54:39.778]                   }
  [20:54:39.778]                 }
  [20:54:39.778]             }
  [20:54:39.778]         }))
  [20:54:39.778]     }, error = function(ex) {
  [20:54:39.778]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.778]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.778]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.778]     }, finally = {
  [20:54:39.778]         {
  [20:54:39.778]             NULL
  [20:54:39.778]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.778]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.778]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.778]                 label = NULL, ...) 
  [20:54:39.778]             {
  [20:54:39.778]                 if (substitute) 
  [20:54:39.778]                   expr <- substitute(expr)
  [20:54:39.778]                 local <- as.logical(local)
  [20:54:39.778]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.778]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.778]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.778]                   label = label, ...)
  [20:54:39.778]                 if (!future$lazy) 
  [20:54:39.778]                   future <- run(future)
  [20:54:39.778]                 invisible(future)
  [20:54:39.778]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.778]         }
  [20:54:39.778]         base::options(...future.oldOptions)
  [20:54:39.778]     })
  [20:54:39.778]     Sys.time
  [20:54:39.778]     if (base::is.na(TRUE)) {
  [20:54:39.778]     }
  [20:54:39.778]     else {
  [20:54:39.778]         base::sink(type = "output", split = FALSE)
  [20:54:39.778]         if (TRUE) {
  [20:54:39.778]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.778]         }
  [20:54:39.778]         else {
  [20:54:39.778]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.778]         }
  [20:54:39.778]         base::close(...future.stdout)
  [20:54:39.778]         ...future.stdout <- NULL
  [20:54:39.778]     }
  [20:54:39.778]     ...future.result$conditions <- ...future.conditions
  [20:54:39.778]     ...future.result
  [20:54:39.778] }
  [20:54:39.783] plan(): Setting new future strategy stack:
  [20:54:39.783] List of future strategies:
  [20:54:39.783] 1. sequential:
  [20:54:39.783]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.783]    - tweaked: FALSE
  [20:54:39.783]    - call: NULL
  [20:54:39.784] plan(): nbrOfWorkers() = 1
  [20:54:39.785] plan(): Setting new future strategy stack:
  [20:54:39.785] List of future strategies:
  [20:54:39.785] 1. sequential:
  [20:54:39.785]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.785]    - tweaked: FALSE
  [20:54:39.785]    - call: plan(strategy)
  [20:54:39.786] plan(): nbrOfWorkers() = 1
  [20:54:39.787] SequentialFuture started (and completed)
  [20:54:39.787] getGlobalsAndPackages() ...
  [20:54:39.788] Searching for globals...
  [20:54:39.789] - globals found: [1] '{'
  [20:54:39.789] Searching for globals ... DONE
  [20:54:39.789] Resolving globals: FALSE
  [20:54:39.790] 
  [20:54:39.790] 
  [20:54:39.791] getGlobalsAndPackages() ... DONE
  [20:54:39.792] Packages needed by the future expression (n = 0): <none>
  [20:54:39.792] Packages needed by future strategies (n = 0): <none>
  [20:54:39.813] {
  [20:54:39.813]     {
  [20:54:39.813]         ...future.startTime <- base::Sys.time()
  [20:54:39.813]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.813]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.813]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.813]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.813]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.813]         {
  [20:54:39.813]             {
  [20:54:39.813]                 has_future <- base::requireNamespace("future", 
  [20:54:39.813]                   quietly = TRUE)
  [20:54:39.813]                 version <- if (has_future) 
  [20:54:39.813]                   utils::packageVersion("future")
  [20:54:39.813]                 else NULL
  [20:54:39.813]                 if (!has_future || version < "1.8.0") {
  [20:54:39.813]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.813]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.813]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.813]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.813]                       "release", "version")], collapse = " "), 
  [20:54:39.813]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.813]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.813]                     info)
  [20:54:39.813]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.813]                   if (!has_future) {
  [20:54:39.813]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.813]                       info)
  [20:54:39.813]                   }
  [20:54:39.813]                   else {
  [20:54:39.813]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.813]                       info, version)
  [20:54:39.813]                   }
  [20:54:39.813]                   base::stop(msg)
  [20:54:39.813]                 }
  [20:54:39.813]             }
  [20:54:39.813]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.813]         }
  [20:54:39.813]     }
  [20:54:39.813]     if (base::is.na(TRUE)) {
  [20:54:39.813]     }
  [20:54:39.813]     else {
  [20:54:39.813]         if (TRUE) {
  [20:54:39.813]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.813]                 open = "w")
  [20:54:39.813]         }
  [20:54:39.813]         else {
  [20:54:39.813]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.813]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.813]         }
  [20:54:39.813]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.813]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.813]             base::sink(type = "output", split = FALSE)
  [20:54:39.813]             base::close(...future.stdout)
  [20:54:39.813]         }, add = TRUE)
  [20:54:39.813]     }
  [20:54:39.813]     ...future.frame <- base::sys.nframe()
  [20:54:39.813]     ...future.conditions <- base::list()
  [20:54:39.813]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.813]     ...future.result <- base::tryCatch({
  [20:54:39.813]         base::withCallingHandlers({
  [20:54:39.813]             ...future.value <- base::withVisible(base::local({
  [20:54:39.813]                 4
  [20:54:39.813]             }))
  [20:54:39.813]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.813]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.813]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.813]                 version = "1.8")
  [20:54:39.813]         }, condition = base::local({
  [20:54:39.813]             c <- base::c
  [20:54:39.813]             inherits <- base::inherits
  [20:54:39.813]             invokeRestart <- base::invokeRestart
  [20:54:39.813]             length <- base::length
  [20:54:39.813]             list <- base::list
  [20:54:39.813]             seq.int <- base::seq.int
  [20:54:39.813]             signalCondition <- base::signalCondition
  [20:54:39.813]             sys.calls <- base::sys.calls
  [20:54:39.813]             Sys.time <- base::Sys.time
  [20:54:39.813]             `[[` <- base::`[[`
  [20:54:39.813]             `+` <- base::`+`
  [20:54:39.813]             `<<-` <- base::`<<-`
  [20:54:39.813]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.813]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.813]                   3L)]
  [20:54:39.813]             }
  [20:54:39.813]             function(cond) {
  [20:54:39.813]                 if (inherits(cond, "error")) {
  [20:54:39.813]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.813]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.813]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.813]                   signalCondition(cond)
  [20:54:39.813]                 }
  [20:54:39.813]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.813]                 ))) {
  [20:54:39.813]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.813]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.813]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.813]                   if (!signal) {
  [20:54:39.813]                     muffleCondition <- function (cond) 
  [20:54:39.813]                     {
  [20:54:39.813]                       inherits <- base::inherits
  [20:54:39.813]                       invokeRestart <- base::invokeRestart
  [20:54:39.813]                       muffled <- FALSE
  [20:54:39.813]                       if (inherits(cond, "message")) {
  [20:54:39.813]                         invokeRestart("muffleMessage")
  [20:54:39.813]                         muffled <- TRUE
  [20:54:39.813]                       }
  [20:54:39.813]                       else if (inherits(cond, "warning")) {
  [20:54:39.813]                         invokeRestart("muffleWarning")
  [20:54:39.813]                         muffled <- TRUE
  [20:54:39.813]                       }
  [20:54:39.813]                       else if (inherits(cond, "condition")) {
  [20:54:39.813]                         computeRestarts <- base::computeRestarts
  [20:54:39.813]                         grepl <- base::grepl
  [20:54:39.813]                         is.null <- base::is.null
  [20:54:39.813]                         restarts <- computeRestarts(cond)
  [20:54:39.813]                         for (restart in restarts) {
  [20:54:39.813]                           name <- restart$name
  [20:54:39.813]                           if (is.null(name)) 
  [20:54:39.813]                             next
  [20:54:39.813]                           if (!grepl("^muffle", name)) 
  [20:54:39.813]                             next
  [20:54:39.813]                           invokeRestart(restart)
  [20:54:39.813]                           muffled <- TRUE
  [20:54:39.813]                           break
  [20:54:39.813]                         }
  [20:54:39.813]                       }
  [20:54:39.813]                       invisible(muffled)
  [20:54:39.813]                     }
  [20:54:39.813]                     muffleCondition(cond)
  [20:54:39.813]                   }
  [20:54:39.813]                 }
  [20:54:39.813]             }
  [20:54:39.813]         }))
  [20:54:39.813]     }, error = function(ex) {
  [20:54:39.813]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.813]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.813]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.813]     }, finally = {
  [20:54:39.813]         {
  [20:54:39.813]             NULL
  [20:54:39.813]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.813]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.813]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.813]                 label = NULL, ...) 
  [20:54:39.813]             {
  [20:54:39.813]                 if (substitute) 
  [20:54:39.813]                   expr <- substitute(expr)
  [20:54:39.813]                 local <- as.logical(local)
  [20:54:39.813]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.813]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.813]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.813]                   label = label, ...)
  [20:54:39.813]                 if (!future$lazy) 
  [20:54:39.813]                   future <- run(future)
  [20:54:39.813]                 invisible(future)
  [20:54:39.813]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.813]         }
  [20:54:39.813]         base::options(...future.oldOptions)
  [20:54:39.813]     })
  [20:54:39.813]     Sys.time
  [20:54:39.813]     if (base::is.na(TRUE)) {
  [20:54:39.813]     }
  [20:54:39.813]     else {
  [20:54:39.813]         base::sink(type = "output", split = FALSE)
  [20:54:39.813]         if (TRUE) {
  [20:54:39.813]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.813]         }
  [20:54:39.813]         else {
  [20:54:39.813]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.813]         }
  [20:54:39.813]         base::close(...future.stdout)
  [20:54:39.813]         ...future.stdout <- NULL
  [20:54:39.813]     }
  [20:54:39.813]     ...future.result$conditions <- ...future.conditions
  [20:54:39.813]     ...future.result
  [20:54:39.813] }
  [20:54:39.817] plan(): Setting new future strategy stack:
  [20:54:39.818] List of future strategies:
  [20:54:39.818] 1. sequential:
  [20:54:39.818]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.818]    - tweaked: FALSE
  [20:54:39.818]    - call: NULL
  [20:54:39.819] plan(): nbrOfWorkers() = 1
  [20:54:39.820] plan(): Setting new future strategy stack:
  [20:54:39.820] List of future strategies:
  [20:54:39.820] 1. sequential:
  [20:54:39.820]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.820]    - tweaked: FALSE
  [20:54:39.820]    - call: plan(strategy)
  [20:54:39.821] plan(): nbrOfWorkers() = 1
  [20:54:39.821] SequentialFuture started (and completed)
  <environment: 0x556b112debb8> 
  <environment: 0x556b106dcc50> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:39.843] resolve() on environment ...
  [20:54:39.844]  recursive: 0
  [20:54:39.845]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:39.845] signalConditionsASAP(numeric, pos=1) ...
  [20:54:39.845] - nx: 4
  [20:54:39.846] - relay: TRUE
  [20:54:39.846] - stdout: TRUE
  [20:54:39.846] - signal: TRUE
  [20:54:39.846] - resignal: FALSE
  [20:54:39.847] - force: TRUE
  [20:54:39.847] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.847] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.847]  - until=2
  [20:54:39.848]  - relaying element #2
  [20:54:39.848] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:39.848] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.848] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:39.849]  length: 3 (resolved future 1)
  [20:54:39.849] Future #2
  [20:54:39.849] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:39.850] - nx: 4
  [20:54:39.850] - relay: TRUE
  [20:54:39.850] - stdout: TRUE
  [20:54:39.850] - signal: TRUE
  [20:54:39.851] - resignal: FALSE
  [20:54:39.851] - force: TRUE
  [20:54:39.851] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:39.851] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:39.852]  - until=2
  [20:54:39.852]  - relaying element #2
  [20:54:39.852] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:39.853] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:39.853] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:39.853]  length: 2 (resolved future 2)
  [20:54:39.854] Future #3
  [20:54:39.854] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:39.854] - nx: 4
  [20:54:39.854] - relay: TRUE
  [20:54:39.855] - stdout: TRUE
  [20:54:39.855] - signal: TRUE
  [20:54:39.855] - resignal: FALSE
  [20:54:39.855] - force: TRUE
  [20:54:39.856] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:39.856] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:39.856]  - until=3
  [20:54:39.856]  - relaying element #3
  [20:54:39.857] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:39.857] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:39.857] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:39.874]  length: 1 (resolved future 3)
  [20:54:39.874] Future #4
  [20:54:39.875] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:39.875] - nx: 4
  [20:54:39.875] - relay: TRUE
  [20:54:39.875] - stdout: TRUE
  [20:54:39.876] - signal: TRUE
  [20:54:39.876] - resignal: FALSE
  [20:54:39.876] - force: TRUE
  [20:54:39.876] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:39.877] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:39.877]  - until=4
  [20:54:39.877]  - relaying element #4
  [20:54:39.878] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.878] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:39.878] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:39.879]  length: 0 (resolved future 4)
  [20:54:39.879] Relaying remaining futures
  [20:54:39.879] signalConditionsASAP(NULL, pos=0) ...
  [20:54:39.879] - nx: 4
  [20:54:39.880] - relay: TRUE
  [20:54:39.880] - stdout: TRUE
  [20:54:39.880] - signal: TRUE
  [20:54:39.880] - resignal: FALSE
  [20:54:39.881] - force: TRUE
  [20:54:39.881] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.881] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:39.886] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:39.886] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:39.886] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:39.887] resolve() on environment ... DONE
  <environment: 0x556b1137f400> 
  Dimensions: c(2, 3)
  [20:54:39.888] getGlobalsAndPackages() ...
  [20:54:39.888] Searching for globals...
  [20:54:39.889] 
  [20:54:39.889] Searching for globals ... DONE
  [20:54:39.906] - globals: [0] <none>
  [20:54:39.906] getGlobalsAndPackages() ... DONE
  [20:54:39.908] Packages needed by the future expression (n = 0): <none>
  [20:54:39.908] Packages needed by future strategies (n = 0): <none>
  [20:54:39.912] {
  [20:54:39.912]     {
  [20:54:39.912]         ...future.startTime <- base::Sys.time()
  [20:54:39.912]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.912]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.912]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.912]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.912]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.912]         {
  [20:54:39.912]             {
  [20:54:39.912]                 has_future <- base::requireNamespace("future", 
  [20:54:39.912]                   quietly = TRUE)
  [20:54:39.912]                 version <- if (has_future) 
  [20:54:39.912]                   utils::packageVersion("future")
  [20:54:39.912]                 else NULL
  [20:54:39.912]                 if (!has_future || version < "1.8.0") {
  [20:54:39.912]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.912]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.912]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.912]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.912]                       "release", "version")], collapse = " "), 
  [20:54:39.912]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.912]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.912]                     info)
  [20:54:39.912]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.912]                   if (!has_future) {
  [20:54:39.912]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.912]                       info)
  [20:54:39.912]                   }
  [20:54:39.912]                   else {
  [20:54:39.912]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.912]                       info, version)
  [20:54:39.912]                   }
  [20:54:39.912]                   base::stop(msg)
  [20:54:39.912]                 }
  [20:54:39.912]             }
  [20:54:39.912]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.912]         }
  [20:54:39.912]     }
  [20:54:39.912]     if (base::is.na(TRUE)) {
  [20:54:39.912]     }
  [20:54:39.912]     else {
  [20:54:39.912]         if (TRUE) {
  [20:54:39.912]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.912]                 open = "w")
  [20:54:39.912]         }
  [20:54:39.912]         else {
  [20:54:39.912]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.912]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.912]         }
  [20:54:39.912]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.912]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.912]             base::sink(type = "output", split = FALSE)
  [20:54:39.912]             base::close(...future.stdout)
  [20:54:39.912]         }, add = TRUE)
  [20:54:39.912]     }
  [20:54:39.912]     ...future.frame <- base::sys.nframe()
  [20:54:39.912]     ...future.conditions <- base::list()
  [20:54:39.912]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.912]     ...future.result <- base::tryCatch({
  [20:54:39.912]         base::withCallingHandlers({
  [20:54:39.912]             ...future.value <- base::withVisible(base::local(2))
  [20:54:39.912]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.912]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.912]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.912]                 version = "1.8")
  [20:54:39.912]         }, condition = base::local({
  [20:54:39.912]             c <- base::c
  [20:54:39.912]             inherits <- base::inherits
  [20:54:39.912]             invokeRestart <- base::invokeRestart
  [20:54:39.912]             length <- base::length
  [20:54:39.912]             list <- base::list
  [20:54:39.912]             seq.int <- base::seq.int
  [20:54:39.912]             signalCondition <- base::signalCondition
  [20:54:39.912]             sys.calls <- base::sys.calls
  [20:54:39.912]             Sys.time <- base::Sys.time
  [20:54:39.912]             `[[` <- base::`[[`
  [20:54:39.912]             `+` <- base::`+`
  [20:54:39.912]             `<<-` <- base::`<<-`
  [20:54:39.912]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.912]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.912]                   3L)]
  [20:54:39.912]             }
  [20:54:39.912]             function(cond) {
  [20:54:39.912]                 if (inherits(cond, "error")) {
  [20:54:39.912]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.912]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.912]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.912]                   signalCondition(cond)
  [20:54:39.912]                 }
  [20:54:39.912]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.912]                 ))) {
  [20:54:39.912]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.912]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.912]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.912]                   if (!signal) {
  [20:54:39.912]                     muffleCondition <- function (cond) 
  [20:54:39.912]                     {
  [20:54:39.912]                       inherits <- base::inherits
  [20:54:39.912]                       invokeRestart <- base::invokeRestart
  [20:54:39.912]                       muffled <- FALSE
  [20:54:39.912]                       if (inherits(cond, "message")) {
  [20:54:39.912]                         invokeRestart("muffleMessage")
  [20:54:39.912]                         muffled <- TRUE
  [20:54:39.912]                       }
  [20:54:39.912]                       else if (inherits(cond, "warning")) {
  [20:54:39.912]                         invokeRestart("muffleWarning")
  [20:54:39.912]                         muffled <- TRUE
  [20:54:39.912]                       }
  [20:54:39.912]                       else if (inherits(cond, "condition")) {
  [20:54:39.912]                         computeRestarts <- base::computeRestarts
  [20:54:39.912]                         grepl <- base::grepl
  [20:54:39.912]                         is.null <- base::is.null
  [20:54:39.912]                         restarts <- computeRestarts(cond)
  [20:54:39.912]                         for (restart in restarts) {
  [20:54:39.912]                           name <- restart$name
  [20:54:39.912]                           if (is.null(name)) 
  [20:54:39.912]                             next
  [20:54:39.912]                           if (!grepl("^muffle", name)) 
  [20:54:39.912]                             next
  [20:54:39.912]                           invokeRestart(restart)
  [20:54:39.912]                           muffled <- TRUE
  [20:54:39.912]                           break
  [20:54:39.912]                         }
  [20:54:39.912]                       }
  [20:54:39.912]                       invisible(muffled)
  [20:54:39.912]                     }
  [20:54:39.912]                     muffleCondition(cond)
  [20:54:39.912]                   }
  [20:54:39.912]                 }
  [20:54:39.912]             }
  [20:54:39.912]         }))
  [20:54:39.912]     }, error = function(ex) {
  [20:54:39.912]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.912]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.912]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.912]     }, finally = {
  [20:54:39.912]         {
  [20:54:39.912]             NULL
  [20:54:39.912]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.912]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.912]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.912]                 label = NULL, ...) 
  [20:54:39.912]             {
  [20:54:39.912]                 if (substitute) 
  [20:54:39.912]                   expr <- substitute(expr)
  [20:54:39.912]                 local <- as.logical(local)
  [20:54:39.912]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.912]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.912]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.912]                   label = label, ...)
  [20:54:39.912]                 if (!future$lazy) 
  [20:54:39.912]                   future <- run(future)
  [20:54:39.912]                 invisible(future)
  [20:54:39.912]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.912]         }
  [20:54:39.912]         base::options(...future.oldOptions)
  [20:54:39.912]     })
  [20:54:39.912]     Sys.time
  [20:54:39.912]     if (base::is.na(TRUE)) {
  [20:54:39.912]     }
  [20:54:39.912]     else {
  [20:54:39.912]         base::sink(type = "output", split = FALSE)
  [20:54:39.912]         if (TRUE) {
  [20:54:39.912]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.912]         }
  [20:54:39.912]         else {
  [20:54:39.912]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.912]         }
  [20:54:39.912]         base::close(...future.stdout)
  [20:54:39.912]         ...future.stdout <- NULL
  [20:54:39.912]     }
  [20:54:39.912]     ...future.result$conditions <- ...future.conditions
  [20:54:39.912]     ...future.result
  [20:54:39.912] }
  [20:54:39.931] plan(): Setting new future strategy stack:
  [20:54:39.931] List of future strategies:
  [20:54:39.931] 1. sequential:
  [20:54:39.931]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.931]    - tweaked: FALSE
  [20:54:39.931]    - call: NULL
  [20:54:39.932] plan(): nbrOfWorkers() = 1
  [20:54:39.933] plan(): Setting new future strategy stack:
  [20:54:39.933] List of future strategies:
  [20:54:39.933] 1. sequential:
  [20:54:39.933]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.933]    - tweaked: FALSE
  [20:54:39.933]    - call: plan(strategy)
  [20:54:39.934] plan(): nbrOfWorkers() = 1
  [20:54:39.935] SequentialFuture started (and completed)
  [20:54:39.935] getGlobalsAndPackages() ...
  [20:54:39.935] Searching for globals...
  [20:54:39.936] 
  [20:54:39.936] Searching for globals ... DONE
  [20:54:39.936] - globals: [0] <none>
  [20:54:39.937] getGlobalsAndPackages() ... DONE
  [20:54:39.938] Packages needed by the future expression (n = 0): <none>
  [20:54:39.939] Packages needed by future strategies (n = 0): <none>
  [20:54:39.943] {
  [20:54:39.943]     {
  [20:54:39.943]         ...future.startTime <- base::Sys.time()
  [20:54:39.943]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.943]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.943]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.943]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.943]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.943]         {
  [20:54:39.943]             {
  [20:54:39.943]                 has_future <- base::requireNamespace("future", 
  [20:54:39.943]                   quietly = TRUE)
  [20:54:39.943]                 version <- if (has_future) 
  [20:54:39.943]                   utils::packageVersion("future")
  [20:54:39.943]                 else NULL
  [20:54:39.943]                 if (!has_future || version < "1.8.0") {
  [20:54:39.943]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.943]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.943]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.943]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.943]                       "release", "version")], collapse = " "), 
  [20:54:39.943]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.943]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.943]                     info)
  [20:54:39.943]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.943]                   if (!has_future) {
  [20:54:39.943]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.943]                       info)
  [20:54:39.943]                   }
  [20:54:39.943]                   else {
  [20:54:39.943]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.943]                       info, version)
  [20:54:39.943]                   }
  [20:54:39.943]                   base::stop(msg)
  [20:54:39.943]                 }
  [20:54:39.943]             }
  [20:54:39.943]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.943]         }
  [20:54:39.943]     }
  [20:54:39.943]     if (base::is.na(TRUE)) {
  [20:54:39.943]     }
  [20:54:39.943]     else {
  [20:54:39.943]         if (TRUE) {
  [20:54:39.943]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.943]                 open = "w")
  [20:54:39.943]         }
  [20:54:39.943]         else {
  [20:54:39.943]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.943]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.943]         }
  [20:54:39.943]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.943]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.943]             base::sink(type = "output", split = FALSE)
  [20:54:39.943]             base::close(...future.stdout)
  [20:54:39.943]         }, add = TRUE)
  [20:54:39.943]     }
  [20:54:39.943]     ...future.frame <- base::sys.nframe()
  [20:54:39.943]     ...future.conditions <- base::list()
  [20:54:39.943]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.943]     ...future.result <- base::tryCatch({
  [20:54:39.943]         base::withCallingHandlers({
  [20:54:39.943]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:39.943]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.943]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.943]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.943]                 version = "1.8")
  [20:54:39.943]         }, condition = base::local({
  [20:54:39.943]             c <- base::c
  [20:54:39.943]             inherits <- base::inherits
  [20:54:39.943]             invokeRestart <- base::invokeRestart
  [20:54:39.943]             length <- base::length
  [20:54:39.943]             list <- base::list
  [20:54:39.943]             seq.int <- base::seq.int
  [20:54:39.943]             signalCondition <- base::signalCondition
  [20:54:39.943]             sys.calls <- base::sys.calls
  [20:54:39.943]             Sys.time <- base::Sys.time
  [20:54:39.943]             `[[` <- base::`[[`
  [20:54:39.943]             `+` <- base::`+`
  [20:54:39.943]             `<<-` <- base::`<<-`
  [20:54:39.943]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.943]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.943]                   3L)]
  [20:54:39.943]             }
  [20:54:39.943]             function(cond) {
  [20:54:39.943]                 if (inherits(cond, "error")) {
  [20:54:39.943]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.943]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.943]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.943]                   signalCondition(cond)
  [20:54:39.943]                 }
  [20:54:39.943]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.943]                 ))) {
  [20:54:39.943]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.943]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.943]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.943]                   if (!signal) {
  [20:54:39.943]                     muffleCondition <- function (cond) 
  [20:54:39.943]                     {
  [20:54:39.943]                       inherits <- base::inherits
  [20:54:39.943]                       invokeRestart <- base::invokeRestart
  [20:54:39.943]                       muffled <- FALSE
  [20:54:39.943]                       if (inherits(cond, "message")) {
  [20:54:39.943]                         invokeRestart("muffleMessage")
  [20:54:39.943]                         muffled <- TRUE
  [20:54:39.943]                       }
  [20:54:39.943]                       else if (inherits(cond, "warning")) {
  [20:54:39.943]                         invokeRestart("muffleWarning")
  [20:54:39.943]                         muffled <- TRUE
  [20:54:39.943]                       }
  [20:54:39.943]                       else if (inherits(cond, "condition")) {
  [20:54:39.943]                         computeRestarts <- base::computeRestarts
  [20:54:39.943]                         grepl <- base::grepl
  [20:54:39.943]                         is.null <- base::is.null
  [20:54:39.943]                         restarts <- computeRestarts(cond)
  [20:54:39.943]                         for (restart in restarts) {
  [20:54:39.943]                           name <- restart$name
  [20:54:39.943]                           if (is.null(name)) 
  [20:54:39.943]                             next
  [20:54:39.943]                           if (!grepl("^muffle", name)) 
  [20:54:39.943]                             next
  [20:54:39.943]                           invokeRestart(restart)
  [20:54:39.943]                           muffled <- TRUE
  [20:54:39.943]                           break
  [20:54:39.943]                         }
  [20:54:39.943]                       }
  [20:54:39.943]                       invisible(muffled)
  [20:54:39.943]                     }
  [20:54:39.943]                     muffleCondition(cond)
  [20:54:39.943]                   }
  [20:54:39.943]                 }
  [20:54:39.943]             }
  [20:54:39.943]         }))
  [20:54:39.943]     }, error = function(ex) {
  [20:54:39.943]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.943]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.943]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.943]     }, finally = {
  [20:54:39.943]         {
  [20:54:39.943]             NULL
  [20:54:39.943]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.943]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.943]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.943]                 label = NULL, ...) 
  [20:54:39.943]             {
  [20:54:39.943]                 if (substitute) 
  [20:54:39.943]                   expr <- substitute(expr)
  [20:54:39.943]                 local <- as.logical(local)
  [20:54:39.943]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.943]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.943]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.943]                   label = label, ...)
  [20:54:39.943]                 if (!future$lazy) 
  [20:54:39.943]                   future <- run(future)
  [20:54:39.943]                 invisible(future)
  [20:54:39.943]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.943]         }
  [20:54:39.943]         base::options(...future.oldOptions)
  [20:54:39.943]     })
  [20:54:39.943]     Sys.time
  [20:54:39.943]     if (base::is.na(TRUE)) {
  [20:54:39.943]     }
  [20:54:39.943]     else {
  [20:54:39.943]         base::sink(type = "output", split = FALSE)
  [20:54:39.943]         if (TRUE) {
  [20:54:39.943]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.943]         }
  [20:54:39.943]         else {
  [20:54:39.943]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.943]         }
  [20:54:39.943]         base::close(...future.stdout)
  [20:54:39.943]         ...future.stdout <- NULL
  [20:54:39.943]     }
  [20:54:39.943]     ...future.result$conditions <- ...future.conditions
  [20:54:39.943]     ...future.result
  [20:54:39.943] }
  [20:54:39.963] plan(): Setting new future strategy stack:
  [20:54:39.963] List of future strategies:
  [20:54:39.963] 1. sequential:
  [20:54:39.963]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.963]    - tweaked: FALSE
  [20:54:39.963]    - call: NULL
  [20:54:39.964] plan(): nbrOfWorkers() = 1
  [20:54:39.965] plan(): Setting new future strategy stack:
  [20:54:39.965] List of future strategies:
  [20:54:39.965] 1. sequential:
  [20:54:39.965]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.965]    - tweaked: FALSE
  [20:54:39.965]    - call: plan(strategy)
  [20:54:39.966] plan(): nbrOfWorkers() = 1
  [20:54:39.967] SequentialFuture started (and completed)
  [20:54:39.968] getGlobalsAndPackages() ...
  [20:54:39.968] Searching for globals...
  [20:54:39.969] - globals found: [1] '{'
  [20:54:39.969] Searching for globals ... DONE
  [20:54:39.970] Resolving globals: FALSE
  [20:54:39.970] 
  [20:54:39.971] 
  [20:54:39.971] getGlobalsAndPackages() ... DONE
  [20:54:39.973] Packages needed by the future expression (n = 0): <none>
  [20:54:39.973] Packages needed by future strategies (n = 0): <none>
  [20:54:39.977] {
  [20:54:39.977]     {
  [20:54:39.977]         ...future.startTime <- base::Sys.time()
  [20:54:39.977]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:39.977]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:39.977]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:39.977]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:39.977]             future.resolve.recursive = NULL, width = 80L)
  [20:54:39.977]         {
  [20:54:39.977]             {
  [20:54:39.977]                 has_future <- base::requireNamespace("future", 
  [20:54:39.977]                   quietly = TRUE)
  [20:54:39.977]                 version <- if (has_future) 
  [20:54:39.977]                   utils::packageVersion("future")
  [20:54:39.977]                 else NULL
  [20:54:39.977]                 if (!has_future || version < "1.8.0") {
  [20:54:39.977]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:39.977]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:39.977]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:39.977]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:39.977]                       "release", "version")], collapse = " "), 
  [20:54:39.977]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:39.977]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:39.977]                     info)
  [20:54:39.977]                   info <- base::paste(info, collapse = "; ")
  [20:54:39.977]                   if (!has_future) {
  [20:54:39.977]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:39.977]                       info)
  [20:54:39.977]                   }
  [20:54:39.977]                   else {
  [20:54:39.977]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:39.977]                       info, version)
  [20:54:39.977]                   }
  [20:54:39.977]                   base::stop(msg)
  [20:54:39.977]                 }
  [20:54:39.977]             }
  [20:54:39.977]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:39.977]         }
  [20:54:39.977]     }
  [20:54:39.977]     if (base::is.na(TRUE)) {
  [20:54:39.977]     }
  [20:54:39.977]     else {
  [20:54:39.977]         if (TRUE) {
  [20:54:39.977]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:39.977]                 open = "w")
  [20:54:39.977]         }
  [20:54:39.977]         else {
  [20:54:39.977]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:39.977]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:39.977]         }
  [20:54:39.977]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:39.977]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:39.977]             base::sink(type = "output", split = FALSE)
  [20:54:39.977]             base::close(...future.stdout)
  [20:54:39.977]         }, add = TRUE)
  [20:54:39.977]     }
  [20:54:39.977]     ...future.frame <- base::sys.nframe()
  [20:54:39.977]     ...future.conditions <- base::list()
  [20:54:39.977]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:39.977]     ...future.result <- base::tryCatch({
  [20:54:39.977]         base::withCallingHandlers({
  [20:54:39.977]             ...future.value <- base::withVisible(base::local({
  [20:54:39.977]                 4
  [20:54:39.977]             }))
  [20:54:39.977]             future::FutureResult(value = ...future.value$value, 
  [20:54:39.977]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.977]                   ...future.rng), started = ...future.startTime, 
  [20:54:39.977]                 version = "1.8")
  [20:54:39.977]         }, condition = base::local({
  [20:54:39.977]             c <- base::c
  [20:54:39.977]             inherits <- base::inherits
  [20:54:39.977]             invokeRestart <- base::invokeRestart
  [20:54:39.977]             length <- base::length
  [20:54:39.977]             list <- base::list
  [20:54:39.977]             seq.int <- base::seq.int
  [20:54:39.977]             signalCondition <- base::signalCondition
  [20:54:39.977]             sys.calls <- base::sys.calls
  [20:54:39.977]             Sys.time <- base::Sys.time
  [20:54:39.977]             `[[` <- base::`[[`
  [20:54:39.977]             `+` <- base::`+`
  [20:54:39.977]             `<<-` <- base::`<<-`
  [20:54:39.977]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:39.977]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:39.977]                   3L)]
  [20:54:39.977]             }
  [20:54:39.977]             function(cond) {
  [20:54:39.977]                 if (inherits(cond, "error")) {
  [20:54:39.977]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.977]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:39.977]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:39.977]                   signalCondition(cond)
  [20:54:39.977]                 }
  [20:54:39.977]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:39.977]                 ))) {
  [20:54:39.977]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:39.977]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:39.977]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:39.977]                   if (!signal) {
  [20:54:39.977]                     muffleCondition <- function (cond) 
  [20:54:39.977]                     {
  [20:54:39.977]                       inherits <- base::inherits
  [20:54:39.977]                       invokeRestart <- base::invokeRestart
  [20:54:39.977]                       muffled <- FALSE
  [20:54:39.977]                       if (inherits(cond, "message")) {
  [20:54:39.977]                         invokeRestart("muffleMessage")
  [20:54:39.977]                         muffled <- TRUE
  [20:54:39.977]                       }
  [20:54:39.977]                       else if (inherits(cond, "warning")) {
  [20:54:39.977]                         invokeRestart("muffleWarning")
  [20:54:39.977]                         muffled <- TRUE
  [20:54:39.977]                       }
  [20:54:39.977]                       else if (inherits(cond, "condition")) {
  [20:54:39.977]                         computeRestarts <- base::computeRestarts
  [20:54:39.977]                         grepl <- base::grepl
  [20:54:39.977]                         is.null <- base::is.null
  [20:54:39.977]                         restarts <- computeRestarts(cond)
  [20:54:39.977]                         for (restart in restarts) {
  [20:54:39.977]                           name <- restart$name
  [20:54:39.977]                           if (is.null(name)) 
  [20:54:39.977]                             next
  [20:54:39.977]                           if (!grepl("^muffle", name)) 
  [20:54:39.977]                             next
  [20:54:39.977]                           invokeRestart(restart)
  [20:54:39.977]                           muffled <- TRUE
  [20:54:39.977]                           break
  [20:54:39.977]                         }
  [20:54:39.977]                       }
  [20:54:39.977]                       invisible(muffled)
  [20:54:39.977]                     }
  [20:54:39.977]                     muffleCondition(cond)
  [20:54:39.977]                   }
  [20:54:39.977]                 }
  [20:54:39.977]             }
  [20:54:39.977]         }))
  [20:54:39.977]     }, error = function(ex) {
  [20:54:39.977]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:39.977]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:39.977]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:39.977]     }, finally = {
  [20:54:39.977]         {
  [20:54:39.977]             NULL
  [20:54:39.977]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:39.977]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:39.977]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:39.977]                 label = NULL, ...) 
  [20:54:39.977]             {
  [20:54:39.977]                 if (substitute) 
  [20:54:39.977]                   expr <- substitute(expr)
  [20:54:39.977]                 local <- as.logical(local)
  [20:54:39.977]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:39.977]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:39.977]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:39.977]                   label = label, ...)
  [20:54:39.977]                 if (!future$lazy) 
  [20:54:39.977]                   future <- run(future)
  [20:54:39.977]                 invisible(future)
  [20:54:39.977]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:39.977]         }
  [20:54:39.977]         base::options(...future.oldOptions)
  [20:54:39.977]     })
  [20:54:39.977]     Sys.time
  [20:54:39.977]     if (base::is.na(TRUE)) {
  [20:54:39.977]     }
  [20:54:39.977]     else {
  [20:54:39.977]         base::sink(type = "output", split = FALSE)
  [20:54:39.977]         if (TRUE) {
  [20:54:39.977]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:39.977]         }
  [20:54:39.977]         else {
  [20:54:39.977]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:39.977]         }
  [20:54:39.977]         base::close(...future.stdout)
  [20:54:39.977]         ...future.stdout <- NULL
  [20:54:39.977]     }
  [20:54:39.977]     ...future.result$conditions <- ...future.conditions
  [20:54:39.977]     ...future.result
  [20:54:39.977] }
  [20:54:39.994] plan(): Setting new future strategy stack:
  [20:54:39.994] List of future strategies:
  [20:54:39.994] 1. sequential:
  [20:54:39.994]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.994]    - tweaked: FALSE
  [20:54:39.994]    - call: NULL
  [20:54:39.995] plan(): nbrOfWorkers() = 1
  [20:54:39.996] plan(): Setting new future strategy stack:
  [20:54:39.996] List of future strategies:
  [20:54:39.996] 1. sequential:
  [20:54:39.996]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:39.996]    - tweaked: FALSE
  [20:54:39.996]    - call: plan(strategy)
  [20:54:40.001] plan(): nbrOfWorkers() = 1
  [20:54:40.001] SequentialFuture started (and completed)
  <environment: 0x556b11742b60> 
  <environment: 0x556b10893558> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:40.026] resolve() on environment ...
  [20:54:40.027]  recursive: 0
  [20:54:40.028]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:40.028] signalConditionsASAP(numeric, pos=1) ...
  [20:54:40.028] - nx: 4
  [20:54:40.029] - relay: TRUE
  [20:54:40.029] - stdout: TRUE
  [20:54:40.029] - signal: TRUE
  [20:54:40.029] - resignal: FALSE
  [20:54:40.029] - force: TRUE
  [20:54:40.030] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.030] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.030]  - until=2
  [20:54:40.030]  - relaying element #2
  [20:54:40.031] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.031] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.031] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:40.031]  length: 3 (resolved future 1)
  [20:54:40.032] Future #2
  [20:54:40.032] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:40.032] - nx: 4
  [20:54:40.032] - relay: TRUE
  [20:54:40.033] - stdout: TRUE
  [20:54:40.033] - signal: TRUE
  [20:54:40.033] - resignal: FALSE
  [20:54:40.033] - force: TRUE
  [20:54:40.033] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.034] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.034]  - until=2
  [20:54:40.034]  - relaying element #2
  [20:54:40.035] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.035] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.035] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:40.035]  length: 2 (resolved future 2)
  [20:54:40.036] Future #3
  [20:54:40.036] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:40.036] - nx: 4
  [20:54:40.037] - relay: TRUE
  [20:54:40.037] - stdout: TRUE
  [20:54:40.037] - signal: TRUE
  [20:54:40.037] - resignal: FALSE
  [20:54:40.038] - force: TRUE
  [20:54:40.038] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.038] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.038]  - until=3
  [20:54:40.039]  - relaying element #3
  [20:54:40.039] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.039] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.040] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:40.040]  length: 1 (resolved future 3)
  [20:54:40.040] Future #4
  [20:54:40.041] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:40.041] - nx: 4
  [20:54:40.041] - relay: TRUE
  [20:54:40.041] - stdout: TRUE
  [20:54:40.042] - signal: TRUE
  [20:54:40.086] - resignal: FALSE
  [20:54:40.086] - force: TRUE
  [20:54:40.086] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.087] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.087]  - until=4
  [20:54:40.087]  - relaying element #4
  [20:54:40.088] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.088] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.088] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:40.089]  length: 0 (resolved future 4)
  [20:54:40.089] Relaying remaining futures
  [20:54:40.089] signalConditionsASAP(NULL, pos=0) ...
  [20:54:40.089] - nx: 4
  [20:54:40.089] - relay: TRUE
  [20:54:40.090] - stdout: TRUE
  [20:54:40.090] - signal: TRUE
  [20:54:40.090] - resignal: FALSE
  [20:54:40.090] - force: TRUE
  [20:54:40.091] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.091] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:40.091] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.092] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.092] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:40.092] resolve() on environment ... DONE
  <environment: 0x556b1048d8a0> 
  Dimensions: c(2, 3, 1)
  [20:54:40.093] getGlobalsAndPackages() ...
  [20:54:40.094] Searching for globals...
  [20:54:40.095] 
  [20:54:40.095] Searching for globals ... DONE
  [20:54:40.095] - globals: [0] <none>
  [20:54:40.095] getGlobalsAndPackages() ... DONE
  [20:54:40.097] Packages needed by the future expression (n = 0): <none>
  [20:54:40.097] Packages needed by future strategies (n = 0): <none>
  [20:54:40.101] {
  [20:54:40.101]     {
  [20:54:40.101]         ...future.startTime <- base::Sys.time()
  [20:54:40.101]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.101]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.101]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.101]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.101]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.101]         {
  [20:54:40.101]             {
  [20:54:40.101]                 has_future <- base::requireNamespace("future", 
  [20:54:40.101]                   quietly = TRUE)
  [20:54:40.101]                 version <- if (has_future) 
  [20:54:40.101]                   utils::packageVersion("future")
  [20:54:40.101]                 else NULL
  [20:54:40.101]                 if (!has_future || version < "1.8.0") {
  [20:54:40.101]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.101]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.101]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.101]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.101]                       "release", "version")], collapse = " "), 
  [20:54:40.101]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.101]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.101]                     info)
  [20:54:40.101]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.101]                   if (!has_future) {
  [20:54:40.101]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.101]                       info)
  [20:54:40.101]                   }
  [20:54:40.101]                   else {
  [20:54:40.101]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.101]                       info, version)
  [20:54:40.101]                   }
  [20:54:40.101]                   base::stop(msg)
  [20:54:40.101]                 }
  [20:54:40.101]             }
  [20:54:40.101]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.101]         }
  [20:54:40.101]     }
  [20:54:40.101]     if (base::is.na(TRUE)) {
  [20:54:40.101]     }
  [20:54:40.101]     else {
  [20:54:40.101]         if (TRUE) {
  [20:54:40.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.101]                 open = "w")
  [20:54:40.101]         }
  [20:54:40.101]         else {
  [20:54:40.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.101]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.101]         }
  [20:54:40.101]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.101]             base::sink(type = "output", split = FALSE)
  [20:54:40.101]             base::close(...future.stdout)
  [20:54:40.101]         }, add = TRUE)
  [20:54:40.101]     }
  [20:54:40.101]     ...future.frame <- base::sys.nframe()
  [20:54:40.101]     ...future.conditions <- base::list()
  [20:54:40.101]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.101]     ...future.result <- base::tryCatch({
  [20:54:40.101]         base::withCallingHandlers({
  [20:54:40.101]             ...future.value <- base::withVisible(base::local(2))
  [20:54:40.101]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.101]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.101]                 version = "1.8")
  [20:54:40.101]         }, condition = base::local({
  [20:54:40.101]             c <- base::c
  [20:54:40.101]             inherits <- base::inherits
  [20:54:40.101]             invokeRestart <- base::invokeRestart
  [20:54:40.101]             length <- base::length
  [20:54:40.101]             list <- base::list
  [20:54:40.101]             seq.int <- base::seq.int
  [20:54:40.101]             signalCondition <- base::signalCondition
  [20:54:40.101]             sys.calls <- base::sys.calls
  [20:54:40.101]             Sys.time <- base::Sys.time
  [20:54:40.101]             `[[` <- base::`[[`
  [20:54:40.101]             `+` <- base::`+`
  [20:54:40.101]             `<<-` <- base::`<<-`
  [20:54:40.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.101]                   3L)]
  [20:54:40.101]             }
  [20:54:40.101]             function(cond) {
  [20:54:40.101]                 if (inherits(cond, "error")) {
  [20:54:40.101]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.101]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.101]                   signalCondition(cond)
  [20:54:40.101]                 }
  [20:54:40.101]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.101]                 ))) {
  [20:54:40.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.101]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.101]                   if (!signal) {
  [20:54:40.101]                     muffleCondition <- function (cond) 
  [20:54:40.101]                     {
  [20:54:40.101]                       inherits <- base::inherits
  [20:54:40.101]                       invokeRestart <- base::invokeRestart
  [20:54:40.101]                       muffled <- FALSE
  [20:54:40.101]                       if (inherits(cond, "message")) {
  [20:54:40.101]                         invokeRestart("muffleMessage")
  [20:54:40.101]                         muffled <- TRUE
  [20:54:40.101]                       }
  [20:54:40.101]                       else if (inherits(cond, "warning")) {
  [20:54:40.101]                         invokeRestart("muffleWarning")
  [20:54:40.101]                         muffled <- TRUE
  [20:54:40.101]                       }
  [20:54:40.101]                       else if (inherits(cond, "condition")) {
  [20:54:40.101]                         computeRestarts <- base::computeRestarts
  [20:54:40.101]                         grepl <- base::grepl
  [20:54:40.101]                         is.null <- base::is.null
  [20:54:40.101]                         restarts <- computeRestarts(cond)
  [20:54:40.101]                         for (restart in restarts) {
  [20:54:40.101]                           name <- restart$name
  [20:54:40.101]                           if (is.null(name)) 
  [20:54:40.101]                             next
  [20:54:40.101]                           if (!grepl("^muffle", name)) 
  [20:54:40.101]                             next
  [20:54:40.101]                           invokeRestart(restart)
  [20:54:40.101]                           muffled <- TRUE
  [20:54:40.101]                           break
  [20:54:40.101]                         }
  [20:54:40.101]                       }
  [20:54:40.101]                       invisible(muffled)
  [20:54:40.101]                     }
  [20:54:40.101]                     muffleCondition(cond)
  [20:54:40.101]                   }
  [20:54:40.101]                 }
  [20:54:40.101]             }
  [20:54:40.101]         }))
  [20:54:40.101]     }, error = function(ex) {
  [20:54:40.101]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.101]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.101]     }, finally = {
  [20:54:40.101]         {
  [20:54:40.101]             NULL
  [20:54:40.101]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.101]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.101]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.101]                 label = NULL, ...) 
  [20:54:40.101]             {
  [20:54:40.101]                 if (substitute) 
  [20:54:40.101]                   expr <- substitute(expr)
  [20:54:40.101]                 local <- as.logical(local)
  [20:54:40.101]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.101]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.101]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.101]                   label = label, ...)
  [20:54:40.101]                 if (!future$lazy) 
  [20:54:40.101]                   future <- run(future)
  [20:54:40.101]                 invisible(future)
  [20:54:40.101]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.101]         }
  [20:54:40.101]         base::options(...future.oldOptions)
  [20:54:40.101]     })
  [20:54:40.101]     Sys.time
  [20:54:40.101]     if (base::is.na(TRUE)) {
  [20:54:40.101]     }
  [20:54:40.101]     else {
  [20:54:40.101]         base::sink(type = "output", split = FALSE)
  [20:54:40.101]         if (TRUE) {
  [20:54:40.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.101]         }
  [20:54:40.101]         else {
  [20:54:40.101]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.101]         }
  [20:54:40.101]         base::close(...future.stdout)
  [20:54:40.101]         ...future.stdout <- NULL
  [20:54:40.101]     }
  [20:54:40.101]     ...future.result$conditions <- ...future.conditions
  [20:54:40.101]     ...future.result
  [20:54:40.101] }
  [20:54:40.113] plan(): Setting new future strategy stack:
  [20:54:40.113] List of future strategies:
  [20:54:40.113] 1. sequential:
  [20:54:40.113]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.113]    - tweaked: FALSE
  [20:54:40.113]    - call: NULL
  [20:54:40.114] plan(): nbrOfWorkers() = 1
  [20:54:40.115] plan(): Setting new future strategy stack:
  [20:54:40.115] List of future strategies:
  [20:54:40.115] 1. sequential:
  [20:54:40.115]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.115]    - tweaked: FALSE
  [20:54:40.115]    - call: plan(strategy)
  [20:54:40.116] plan(): nbrOfWorkers() = 1
  [20:54:40.116] SequentialFuture started (and completed)
  [20:54:40.117] getGlobalsAndPackages() ...
  [20:54:40.117] Searching for globals...
  [20:54:40.118] 
  [20:54:40.118] Searching for globals ... DONE
  [20:54:40.118] - globals: [0] <none>
  [20:54:40.118] getGlobalsAndPackages() ... DONE
  [20:54:40.120] Packages needed by the future expression (n = 0): <none>
  [20:54:40.120] Packages needed by future strategies (n = 0): <none>
  [20:54:40.128] {
  [20:54:40.128]     {
  [20:54:40.128]         ...future.startTime <- base::Sys.time()
  [20:54:40.128]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.128]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.128]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.128]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.128]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.128]         {
  [20:54:40.128]             {
  [20:54:40.128]                 has_future <- base::requireNamespace("future", 
  [20:54:40.128]                   quietly = TRUE)
  [20:54:40.128]                 version <- if (has_future) 
  [20:54:40.128]                   utils::packageVersion("future")
  [20:54:40.128]                 else NULL
  [20:54:40.128]                 if (!has_future || version < "1.8.0") {
  [20:54:40.128]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.128]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.128]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.128]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.128]                       "release", "version")], collapse = " "), 
  [20:54:40.128]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.128]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.128]                     info)
  [20:54:40.128]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.128]                   if (!has_future) {
  [20:54:40.128]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.128]                       info)
  [20:54:40.128]                   }
  [20:54:40.128]                   else {
  [20:54:40.128]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.128]                       info, version)
  [20:54:40.128]                   }
  [20:54:40.128]                   base::stop(msg)
  [20:54:40.128]                 }
  [20:54:40.128]             }
  [20:54:40.128]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.128]         }
  [20:54:40.128]     }
  [20:54:40.128]     if (base::is.na(TRUE)) {
  [20:54:40.128]     }
  [20:54:40.128]     else {
  [20:54:40.128]         if (TRUE) {
  [20:54:40.128]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.128]                 open = "w")
  [20:54:40.128]         }
  [20:54:40.128]         else {
  [20:54:40.128]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.128]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.128]         }
  [20:54:40.128]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.128]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.128]             base::sink(type = "output", split = FALSE)
  [20:54:40.128]             base::close(...future.stdout)
  [20:54:40.128]         }, add = TRUE)
  [20:54:40.128]     }
  [20:54:40.128]     ...future.frame <- base::sys.nframe()
  [20:54:40.128]     ...future.conditions <- base::list()
  [20:54:40.128]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.128]     ...future.result <- base::tryCatch({
  [20:54:40.128]         base::withCallingHandlers({
  [20:54:40.128]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:40.128]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.128]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.128]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.128]                 version = "1.8")
  [20:54:40.128]         }, condition = base::local({
  [20:54:40.128]             c <- base::c
  [20:54:40.128]             inherits <- base::inherits
  [20:54:40.128]             invokeRestart <- base::invokeRestart
  [20:54:40.128]             length <- base::length
  [20:54:40.128]             list <- base::list
  [20:54:40.128]             seq.int <- base::seq.int
  [20:54:40.128]             signalCondition <- base::signalCondition
  [20:54:40.128]             sys.calls <- base::sys.calls
  [20:54:40.128]             Sys.time <- base::Sys.time
  [20:54:40.128]             `[[` <- base::`[[`
  [20:54:40.128]             `+` <- base::`+`
  [20:54:40.128]             `<<-` <- base::`<<-`
  [20:54:40.128]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.128]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.128]                   3L)]
  [20:54:40.128]             }
  [20:54:40.128]             function(cond) {
  [20:54:40.128]                 if (inherits(cond, "error")) {
  [20:54:40.128]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.128]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.128]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.128]                   signalCondition(cond)
  [20:54:40.128]                 }
  [20:54:40.128]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.128]                 ))) {
  [20:54:40.128]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.128]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.128]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.128]                   if (!signal) {
  [20:54:40.128]                     muffleCondition <- function (cond) 
  [20:54:40.128]                     {
  [20:54:40.128]                       inherits <- base::inherits
  [20:54:40.128]                       invokeRestart <- base::invokeRestart
  [20:54:40.128]                       muffled <- FALSE
  [20:54:40.128]                       if (inherits(cond, "message")) {
  [20:54:40.128]                         invokeRestart("muffleMessage")
  [20:54:40.128]                         muffled <- TRUE
  [20:54:40.128]                       }
  [20:54:40.128]                       else if (inherits(cond, "warning")) {
  [20:54:40.128]                         invokeRestart("muffleWarning")
  [20:54:40.128]                         muffled <- TRUE
  [20:54:40.128]                       }
  [20:54:40.128]                       else if (inherits(cond, "condition")) {
  [20:54:40.128]                         computeRestarts <- base::computeRestarts
  [20:54:40.128]                         grepl <- base::grepl
  [20:54:40.128]                         is.null <- base::is.null
  [20:54:40.128]                         restarts <- computeRestarts(cond)
  [20:54:40.128]                         for (restart in restarts) {
  [20:54:40.128]                           name <- restart$name
  [20:54:40.128]                           if (is.null(name)) 
  [20:54:40.128]                             next
  [20:54:40.128]                           if (!grepl("^muffle", name)) 
  [20:54:40.128]                             next
  [20:54:40.128]                           invokeRestart(restart)
  [20:54:40.128]                           muffled <- TRUE
  [20:54:40.128]                           break
  [20:54:40.128]                         }
  [20:54:40.128]                       }
  [20:54:40.128]                       invisible(muffled)
  [20:54:40.128]                     }
  [20:54:40.128]                     muffleCondition(cond)
  [20:54:40.128]                   }
  [20:54:40.128]                 }
  [20:54:40.128]             }
  [20:54:40.128]         }))
  [20:54:40.128]     }, error = function(ex) {
  [20:54:40.128]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.128]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.128]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.128]     }, finally = {
  [20:54:40.128]         {
  [20:54:40.128]             NULL
  [20:54:40.128]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.128]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.128]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.128]                 label = NULL, ...) 
  [20:54:40.128]             {
  [20:54:40.128]                 if (substitute) 
  [20:54:40.128]                   expr <- substitute(expr)
  [20:54:40.128]                 local <- as.logical(local)
  [20:54:40.128]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.128]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.128]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.128]                   label = label, ...)
  [20:54:40.128]                 if (!future$lazy) 
  [20:54:40.128]                   future <- run(future)
  [20:54:40.128]                 invisible(future)
  [20:54:40.128]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.128]         }
  [20:54:40.128]         base::options(...future.oldOptions)
  [20:54:40.128]     })
  [20:54:40.128]     Sys.time
  [20:54:40.128]     if (base::is.na(TRUE)) {
  [20:54:40.128]     }
  [20:54:40.128]     else {
  [20:54:40.128]         base::sink(type = "output", split = FALSE)
  [20:54:40.128]         if (TRUE) {
  [20:54:40.128]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.128]         }
  [20:54:40.128]         else {
  [20:54:40.128]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.128]         }
  [20:54:40.128]         base::close(...future.stdout)
  [20:54:40.128]         ...future.stdout <- NULL
  [20:54:40.128]     }
  [20:54:40.128]     ...future.result$conditions <- ...future.conditions
  [20:54:40.128]     ...future.result
  [20:54:40.128] }
  [20:54:40.133] plan(): Setting new future strategy stack:
  [20:54:40.133] List of future strategies:
  [20:54:40.133] 1. sequential:
  [20:54:40.133]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.133]    - tweaked: FALSE
  [20:54:40.133]    - call: NULL
  [20:54:40.134] plan(): nbrOfWorkers() = 1
  [20:54:40.135] plan(): Setting new future strategy stack:
  [20:54:40.135] List of future strategies:
  [20:54:40.135] 1. sequential:
  [20:54:40.135]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.135]    - tweaked: FALSE
  [20:54:40.135]    - call: plan(strategy)
  [20:54:40.136] plan(): nbrOfWorkers() = 1
  [20:54:40.137] SequentialFuture started (and completed)
  [20:54:40.137] getGlobalsAndPackages() ...
  [20:54:40.138] Searching for globals...
  [20:54:40.139] - globals found: [1] '{'
  [20:54:40.139] Searching for globals ... DONE
  [20:54:40.139] Resolving globals: FALSE
  [20:54:40.140] 
  [20:54:40.140] 
  [20:54:40.141] getGlobalsAndPackages() ... DONE
  [20:54:40.142] Packages needed by the future expression (n = 0): <none>
  [20:54:40.143] Packages needed by future strategies (n = 0): <none>
  [20:54:40.152] {
  [20:54:40.152]     {
  [20:54:40.152]         ...future.startTime <- base::Sys.time()
  [20:54:40.152]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.152]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.152]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.152]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.152]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.152]         {
  [20:54:40.152]             {
  [20:54:40.152]                 has_future <- base::requireNamespace("future", 
  [20:54:40.152]                   quietly = TRUE)
  [20:54:40.152]                 version <- if (has_future) 
  [20:54:40.152]                   utils::packageVersion("future")
  [20:54:40.152]                 else NULL
  [20:54:40.152]                 if (!has_future || version < "1.8.0") {
  [20:54:40.152]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.152]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.152]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.152]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.152]                       "release", "version")], collapse = " "), 
  [20:54:40.152]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.152]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.152]                     info)
  [20:54:40.152]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.152]                   if (!has_future) {
  [20:54:40.152]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.152]                       info)
  [20:54:40.152]                   }
  [20:54:40.152]                   else {
  [20:54:40.152]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.152]                       info, version)
  [20:54:40.152]                   }
  [20:54:40.152]                   base::stop(msg)
  [20:54:40.152]                 }
  [20:54:40.152]             }
  [20:54:40.152]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.152]         }
  [20:54:40.152]     }
  [20:54:40.152]     if (base::is.na(TRUE)) {
  [20:54:40.152]     }
  [20:54:40.152]     else {
  [20:54:40.152]         if (TRUE) {
  [20:54:40.152]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.152]                 open = "w")
  [20:54:40.152]         }
  [20:54:40.152]         else {
  [20:54:40.152]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.152]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.152]         }
  [20:54:40.152]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.152]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.152]             base::sink(type = "output", split = FALSE)
  [20:54:40.152]             base::close(...future.stdout)
  [20:54:40.152]         }, add = TRUE)
  [20:54:40.152]     }
  [20:54:40.152]     ...future.frame <- base::sys.nframe()
  [20:54:40.152]     ...future.conditions <- base::list()
  [20:54:40.152]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.152]     ...future.result <- base::tryCatch({
  [20:54:40.152]         base::withCallingHandlers({
  [20:54:40.152]             ...future.value <- base::withVisible(base::local({
  [20:54:40.152]                 4
  [20:54:40.152]             }))
  [20:54:40.152]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.152]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.152]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.152]                 version = "1.8")
  [20:54:40.152]         }, condition = base::local({
  [20:54:40.152]             c <- base::c
  [20:54:40.152]             inherits <- base::inherits
  [20:54:40.152]             invokeRestart <- base::invokeRestart
  [20:54:40.152]             length <- base::length
  [20:54:40.152]             list <- base::list
  [20:54:40.152]             seq.int <- base::seq.int
  [20:54:40.152]             signalCondition <- base::signalCondition
  [20:54:40.152]             sys.calls <- base::sys.calls
  [20:54:40.152]             Sys.time <- base::Sys.time
  [20:54:40.152]             `[[` <- base::`[[`
  [20:54:40.152]             `+` <- base::`+`
  [20:54:40.152]             `<<-` <- base::`<<-`
  [20:54:40.152]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.152]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.152]                   3L)]
  [20:54:40.152]             }
  [20:54:40.152]             function(cond) {
  [20:54:40.152]                 if (inherits(cond, "error")) {
  [20:54:40.152]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.152]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.152]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.152]                   signalCondition(cond)
  [20:54:40.152]                 }
  [20:54:40.152]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.152]                 ))) {
  [20:54:40.152]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.152]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.152]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.152]                   if (!signal) {
  [20:54:40.152]                     muffleCondition <- function (cond) 
  [20:54:40.152]                     {
  [20:54:40.152]                       inherits <- base::inherits
  [20:54:40.152]                       invokeRestart <- base::invokeRestart
  [20:54:40.152]                       muffled <- FALSE
  [20:54:40.152]                       if (inherits(cond, "message")) {
  [20:54:40.152]                         invokeRestart("muffleMessage")
  [20:54:40.152]                         muffled <- TRUE
  [20:54:40.152]                       }
  [20:54:40.152]                       else if (inherits(cond, "warning")) {
  [20:54:40.152]                         invokeRestart("muffleWarning")
  [20:54:40.152]                         muffled <- TRUE
  [20:54:40.152]                       }
  [20:54:40.152]                       else if (inherits(cond, "condition")) {
  [20:54:40.152]                         computeRestarts <- base::computeRestarts
  [20:54:40.152]                         grepl <- base::grepl
  [20:54:40.152]                         is.null <- base::is.null
  [20:54:40.152]                         restarts <- computeRestarts(cond)
  [20:54:40.152]                         for (restart in restarts) {
  [20:54:40.152]                           name <- restart$name
  [20:54:40.152]                           if (is.null(name)) 
  [20:54:40.152]                             next
  [20:54:40.152]                           if (!grepl("^muffle", name)) 
  [20:54:40.152]                             next
  [20:54:40.152]                           invokeRestart(restart)
  [20:54:40.152]                           muffled <- TRUE
  [20:54:40.152]                           break
  [20:54:40.152]                         }
  [20:54:40.152]                       }
  [20:54:40.152]                       invisible(muffled)
  [20:54:40.152]                     }
  [20:54:40.152]                     muffleCondition(cond)
  [20:54:40.152]                   }
  [20:54:40.152]                 }
  [20:54:40.152]             }
  [20:54:40.152]         }))
  [20:54:40.152]     }, error = function(ex) {
  [20:54:40.152]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.152]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.152]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.152]     }, finally = {
  [20:54:40.152]         {
  [20:54:40.152]             NULL
  [20:54:40.152]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.152]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.152]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.152]                 label = NULL, ...) 
  [20:54:40.152]             {
  [20:54:40.152]                 if (substitute) 
  [20:54:40.152]                   expr <- substitute(expr)
  [20:54:40.152]                 local <- as.logical(local)
  [20:54:40.152]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.152]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.152]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.152]                   label = label, ...)
  [20:54:40.152]                 if (!future$lazy) 
  [20:54:40.152]                   future <- run(future)
  [20:54:40.152]                 invisible(future)
  [20:54:40.152]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.152]         }
  [20:54:40.152]         base::options(...future.oldOptions)
  [20:54:40.152]     })
  [20:54:40.152]     Sys.time
  [20:54:40.152]     if (base::is.na(TRUE)) {
  [20:54:40.152]     }
  [20:54:40.152]     else {
  [20:54:40.152]         base::sink(type = "output", split = FALSE)
  [20:54:40.152]         if (TRUE) {
  [20:54:40.152]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.152]         }
  [20:54:40.152]         else {
  [20:54:40.152]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.152]         }
  [20:54:40.152]         base::close(...future.stdout)
  [20:54:40.152]         ...future.stdout <- NULL
  [20:54:40.152]     }
  [20:54:40.152]     ...future.result$conditions <- ...future.conditions
  [20:54:40.152]     ...future.result
  [20:54:40.152] }
  [20:54:40.156] plan(): Setting new future strategy stack:
  [20:54:40.156] List of future strategies:
  [20:54:40.156] 1. sequential:
  [20:54:40.156]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.156]    - tweaked: FALSE
  [20:54:40.156]    - call: NULL
  [20:54:40.157] plan(): nbrOfWorkers() = 1
  [20:54:40.158] plan(): Setting new future strategy stack:
  [20:54:40.159] List of future strategies:
  [20:54:40.159] 1. sequential:
  [20:54:40.159]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.159]    - tweaked: FALSE
  [20:54:40.159]    - call: plan(strategy)
  [20:54:40.160] plan(): nbrOfWorkers() = 1
  [20:54:40.160] SequentialFuture started (and completed)
  <environment: 0x556b113042c0> 
  <environment: 0x556b11328bc8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:40.166] resolve() on environment ...
  [20:54:40.166]  recursive: 0
  [20:54:40.167]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:40.168] signalConditionsASAP(numeric, pos=1) ...
  [20:54:40.168] - nx: 4
  [20:54:40.168] - relay: TRUE
  [20:54:40.168] - stdout: TRUE
  [20:54:40.169] - signal: TRUE
  [20:54:40.169] - resignal: FALSE
  [20:54:40.169] - force: TRUE
  [20:54:40.169] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.170] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.170]  - until=2
  [20:54:40.170]  - relaying element #2
  [20:54:40.170] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.171] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.171] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:40.171]  length: 3 (resolved future 1)
  [20:54:40.171] Future #2
  [20:54:40.172] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:40.172] - nx: 4
  [20:54:40.172] - relay: TRUE
  [20:54:40.173] - stdout: TRUE
  [20:54:40.173] - signal: TRUE
  [20:54:40.173] - resignal: FALSE
  [20:54:40.173] - force: TRUE
  [20:54:40.173] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.174] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.174]  - until=2
  [20:54:40.174]  - relaying element #2
  [20:54:40.175] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.175] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.175] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:40.176]  length: 2 (resolved future 2)
  [20:54:40.176] Future #3
  [20:54:40.176] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:40.176] - nx: 4
  [20:54:40.177] - relay: TRUE
  [20:54:40.177] - stdout: TRUE
  [20:54:40.177] - signal: TRUE
  [20:54:40.177] - resignal: FALSE
  [20:54:40.178] - force: TRUE
  [20:54:40.178] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.178] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.179]  - until=3
  [20:54:40.179]  - relaying element #3
  [20:54:40.179] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.179] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.180] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:40.180]  length: 1 (resolved future 3)
  [20:54:40.180] Future #4
  [20:54:40.181] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:40.181] - nx: 4
  [20:54:40.181] - relay: TRUE
  [20:54:40.181] - stdout: TRUE
  [20:54:40.182] - signal: TRUE
  [20:54:40.182] - resignal: FALSE
  [20:54:40.182] - force: TRUE
  [20:54:40.182] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.183] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.183]  - until=4
  [20:54:40.183]  - relaying element #4
  [20:54:40.188] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.188] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.189] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:40.189]  length: 0 (resolved future 4)
  [20:54:40.189] Relaying remaining futures
  [20:54:40.189] signalConditionsASAP(NULL, pos=0) ...
  [20:54:40.206] - nx: 4
  [20:54:40.206] - relay: TRUE
  [20:54:40.206] - stdout: TRUE
  [20:54:40.207] - signal: TRUE
  [20:54:40.207] - resignal: FALSE
  [20:54:40.207] - force: TRUE
  [20:54:40.207] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.208] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:40.208] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.208] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.209] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:40.209] resolve() on environment ... DONE
  <environment: 0x556b11572638> 
  Dimensions: c(2, 1, 3, 1)
  [20:54:40.210] getGlobalsAndPackages() ...
  [20:54:40.210] Searching for globals...
  [20:54:40.211] 
  [20:54:40.211] Searching for globals ... DONE
  [20:54:40.211] - globals: [0] <none>
  [20:54:40.212] getGlobalsAndPackages() ... DONE
  [20:54:40.213] Packages needed by the future expression (n = 0): <none>
  [20:54:40.213] Packages needed by future strategies (n = 0): <none>
  [20:54:40.217] {
  [20:54:40.217]     {
  [20:54:40.217]         ...future.startTime <- base::Sys.time()
  [20:54:40.217]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.217]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.217]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.217]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.217]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.217]         {
  [20:54:40.217]             {
  [20:54:40.217]                 has_future <- base::requireNamespace("future", 
  [20:54:40.217]                   quietly = TRUE)
  [20:54:40.217]                 version <- if (has_future) 
  [20:54:40.217]                   utils::packageVersion("future")
  [20:54:40.217]                 else NULL
  [20:54:40.217]                 if (!has_future || version < "1.8.0") {
  [20:54:40.217]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.217]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.217]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.217]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.217]                       "release", "version")], collapse = " "), 
  [20:54:40.217]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.217]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.217]                     info)
  [20:54:40.217]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.217]                   if (!has_future) {
  [20:54:40.217]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.217]                       info)
  [20:54:40.217]                   }
  [20:54:40.217]                   else {
  [20:54:40.217]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.217]                       info, version)
  [20:54:40.217]                   }
  [20:54:40.217]                   base::stop(msg)
  [20:54:40.217]                 }
  [20:54:40.217]             }
  [20:54:40.217]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.217]         }
  [20:54:40.217]     }
  [20:54:40.217]     if (base::is.na(TRUE)) {
  [20:54:40.217]     }
  [20:54:40.217]     else {
  [20:54:40.217]         if (TRUE) {
  [20:54:40.217]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.217]                 open = "w")
  [20:54:40.217]         }
  [20:54:40.217]         else {
  [20:54:40.217]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.217]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.217]         }
  [20:54:40.217]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.217]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.217]             base::sink(type = "output", split = FALSE)
  [20:54:40.217]             base::close(...future.stdout)
  [20:54:40.217]         }, add = TRUE)
  [20:54:40.217]     }
  [20:54:40.217]     ...future.frame <- base::sys.nframe()
  [20:54:40.217]     ...future.conditions <- base::list()
  [20:54:40.217]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.217]     ...future.result <- base::tryCatch({
  [20:54:40.217]         base::withCallingHandlers({
  [20:54:40.217]             ...future.value <- base::withVisible(base::local(2))
  [20:54:40.217]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.217]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.217]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.217]                 version = "1.8")
  [20:54:40.217]         }, condition = base::local({
  [20:54:40.217]             c <- base::c
  [20:54:40.217]             inherits <- base::inherits
  [20:54:40.217]             invokeRestart <- base::invokeRestart
  [20:54:40.217]             length <- base::length
  [20:54:40.217]             list <- base::list
  [20:54:40.217]             seq.int <- base::seq.int
  [20:54:40.217]             signalCondition <- base::signalCondition
  [20:54:40.217]             sys.calls <- base::sys.calls
  [20:54:40.217]             Sys.time <- base::Sys.time
  [20:54:40.217]             `[[` <- base::`[[`
  [20:54:40.217]             `+` <- base::`+`
  [20:54:40.217]             `<<-` <- base::`<<-`
  [20:54:40.217]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.217]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.217]                   3L)]
  [20:54:40.217]             }
  [20:54:40.217]             function(cond) {
  [20:54:40.217]                 if (inherits(cond, "error")) {
  [20:54:40.217]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.217]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.217]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.217]                   signalCondition(cond)
  [20:54:40.217]                 }
  [20:54:40.217]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.217]                 ))) {
  [20:54:40.217]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.217]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.217]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.217]                   if (!signal) {
  [20:54:40.217]                     muffleCondition <- function (cond) 
  [20:54:40.217]                     {
  [20:54:40.217]                       inherits <- base::inherits
  [20:54:40.217]                       invokeRestart <- base::invokeRestart
  [20:54:40.217]                       muffled <- FALSE
  [20:54:40.217]                       if (inherits(cond, "message")) {
  [20:54:40.217]                         invokeRestart("muffleMessage")
  [20:54:40.217]                         muffled <- TRUE
  [20:54:40.217]                       }
  [20:54:40.217]                       else if (inherits(cond, "warning")) {
  [20:54:40.217]                         invokeRestart("muffleWarning")
  [20:54:40.217]                         muffled <- TRUE
  [20:54:40.217]                       }
  [20:54:40.217]                       else if (inherits(cond, "condition")) {
  [20:54:40.217]                         computeRestarts <- base::computeRestarts
  [20:54:40.217]                         grepl <- base::grepl
  [20:54:40.217]                         is.null <- base::is.null
  [20:54:40.217]                         restarts <- computeRestarts(cond)
  [20:54:40.217]                         for (restart in restarts) {
  [20:54:40.217]                           name <- restart$name
  [20:54:40.217]                           if (is.null(name)) 
  [20:54:40.217]                             next
  [20:54:40.217]                           if (!grepl("^muffle", name)) 
  [20:54:40.217]                             next
  [20:54:40.217]                           invokeRestart(restart)
  [20:54:40.217]                           muffled <- TRUE
  [20:54:40.217]                           break
  [20:54:40.217]                         }
  [20:54:40.217]                       }
  [20:54:40.217]                       invisible(muffled)
  [20:54:40.217]                     }
  [20:54:40.217]                     muffleCondition(cond)
  [20:54:40.217]                   }
  [20:54:40.217]                 }
  [20:54:40.217]             }
  [20:54:40.217]         }))
  [20:54:40.217]     }, error = function(ex) {
  [20:54:40.217]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.217]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.217]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.217]     }, finally = {
  [20:54:40.217]         {
  [20:54:40.217]             NULL
  [20:54:40.217]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.217]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.217]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.217]                 label = NULL, ...) 
  [20:54:40.217]             {
  [20:54:40.217]                 if (substitute) 
  [20:54:40.217]                   expr <- substitute(expr)
  [20:54:40.217]                 local <- as.logical(local)
  [20:54:40.217]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.217]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.217]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.217]                   label = label, ...)
  [20:54:40.217]                 if (!future$lazy) 
  [20:54:40.217]                   future <- run(future)
  [20:54:40.217]                 invisible(future)
  [20:54:40.217]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.217]         }
  [20:54:40.217]         base::options(...future.oldOptions)
  [20:54:40.217]     })
  [20:54:40.217]     Sys.time
  [20:54:40.217]     if (base::is.na(TRUE)) {
  [20:54:40.217]     }
  [20:54:40.217]     else {
  [20:54:40.217]         base::sink(type = "output", split = FALSE)
  [20:54:40.217]         if (TRUE) {
  [20:54:40.217]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.217]         }
  [20:54:40.217]         else {
  [20:54:40.217]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.217]         }
  [20:54:40.217]         base::close(...future.stdout)
  [20:54:40.217]         ...future.stdout <- NULL
  [20:54:40.217]     }
  [20:54:40.217]     ...future.result$conditions <- ...future.conditions
  [20:54:40.217]     ...future.result
  [20:54:40.217] }
  [20:54:40.225] plan(): Setting new future strategy stack:
  [20:54:40.225] List of future strategies:
  [20:54:40.225] 1. sequential:
  [20:54:40.225]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.225]    - tweaked: FALSE
  [20:54:40.225]    - call: NULL
  [20:54:40.226] plan(): nbrOfWorkers() = 1
  [20:54:40.227] plan(): Setting new future strategy stack:
  [20:54:40.227] List of future strategies:
  [20:54:40.227] 1. sequential:
  [20:54:40.227]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.227]    - tweaked: FALSE
  [20:54:40.227]    - call: plan(strategy)
  [20:54:40.228] plan(): nbrOfWorkers() = 1
  [20:54:40.229] SequentialFuture started (and completed)
  [20:54:40.229] getGlobalsAndPackages() ...
  [20:54:40.229] Searching for globals...
  [20:54:40.230] 
  [20:54:40.230] Searching for globals ... DONE
  [20:54:40.230] - globals: [0] <none>
  [20:54:40.231] getGlobalsAndPackages() ... DONE
  [20:54:40.232] Packages needed by the future expression (n = 0): <none>
  [20:54:40.232] Packages needed by future strategies (n = 0): <none>
  [20:54:40.236] {
  [20:54:40.236]     {
  [20:54:40.236]         ...future.startTime <- base::Sys.time()
  [20:54:40.236]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.236]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.236]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.236]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.236]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.236]         {
  [20:54:40.236]             {
  [20:54:40.236]                 has_future <- base::requireNamespace("future", 
  [20:54:40.236]                   quietly = TRUE)
  [20:54:40.236]                 version <- if (has_future) 
  [20:54:40.236]                   utils::packageVersion("future")
  [20:54:40.236]                 else NULL
  [20:54:40.236]                 if (!has_future || version < "1.8.0") {
  [20:54:40.236]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.236]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.236]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.236]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.236]                       "release", "version")], collapse = " "), 
  [20:54:40.236]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.236]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.236]                     info)
  [20:54:40.236]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.236]                   if (!has_future) {
  [20:54:40.236]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.236]                       info)
  [20:54:40.236]                   }
  [20:54:40.236]                   else {
  [20:54:40.236]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.236]                       info, version)
  [20:54:40.236]                   }
  [20:54:40.236]                   base::stop(msg)
  [20:54:40.236]                 }
  [20:54:40.236]             }
  [20:54:40.236]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.236]         }
  [20:54:40.236]     }
  [20:54:40.236]     if (base::is.na(TRUE)) {
  [20:54:40.236]     }
  [20:54:40.236]     else {
  [20:54:40.236]         if (TRUE) {
  [20:54:40.236]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.236]                 open = "w")
  [20:54:40.236]         }
  [20:54:40.236]         else {
  [20:54:40.236]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.236]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.236]         }
  [20:54:40.236]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.236]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.236]             base::sink(type = "output", split = FALSE)
  [20:54:40.236]             base::close(...future.stdout)
  [20:54:40.236]         }, add = TRUE)
  [20:54:40.236]     }
  [20:54:40.236]     ...future.frame <- base::sys.nframe()
  [20:54:40.236]     ...future.conditions <- base::list()
  [20:54:40.236]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.236]     ...future.result <- base::tryCatch({
  [20:54:40.236]         base::withCallingHandlers({
  [20:54:40.236]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:40.236]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.236]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.236]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.236]                 version = "1.8")
  [20:54:40.236]         }, condition = base::local({
  [20:54:40.236]             c <- base::c
  [20:54:40.236]             inherits <- base::inherits
  [20:54:40.236]             invokeRestart <- base::invokeRestart
  [20:54:40.236]             length <- base::length
  [20:54:40.236]             list <- base::list
  [20:54:40.236]             seq.int <- base::seq.int
  [20:54:40.236]             signalCondition <- base::signalCondition
  [20:54:40.236]             sys.calls <- base::sys.calls
  [20:54:40.236]             Sys.time <- base::Sys.time
  [20:54:40.236]             `[[` <- base::`[[`
  [20:54:40.236]             `+` <- base::`+`
  [20:54:40.236]             `<<-` <- base::`<<-`
  [20:54:40.236]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.236]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.236]                   3L)]
  [20:54:40.236]             }
  [20:54:40.236]             function(cond) {
  [20:54:40.236]                 if (inherits(cond, "error")) {
  [20:54:40.236]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.236]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.236]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.236]                   signalCondition(cond)
  [20:54:40.236]                 }
  [20:54:40.236]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.236]                 ))) {
  [20:54:40.236]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.236]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.236]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.236]                   if (!signal) {
  [20:54:40.236]                     muffleCondition <- function (cond) 
  [20:54:40.236]                     {
  [20:54:40.236]                       inherits <- base::inherits
  [20:54:40.236]                       invokeRestart <- base::invokeRestart
  [20:54:40.236]                       muffled <- FALSE
  [20:54:40.236]                       if (inherits(cond, "message")) {
  [20:54:40.236]                         invokeRestart("muffleMessage")
  [20:54:40.236]                         muffled <- TRUE
  [20:54:40.236]                       }
  [20:54:40.236]                       else if (inherits(cond, "warning")) {
  [20:54:40.236]                         invokeRestart("muffleWarning")
  [20:54:40.236]                         muffled <- TRUE
  [20:54:40.236]                       }
  [20:54:40.236]                       else if (inherits(cond, "condition")) {
  [20:54:40.236]                         computeRestarts <- base::computeRestarts
  [20:54:40.236]                         grepl <- base::grepl
  [20:54:40.236]                         is.null <- base::is.null
  [20:54:40.236]                         restarts <- computeRestarts(cond)
  [20:54:40.236]                         for (restart in restarts) {
  [20:54:40.236]                           name <- restart$name
  [20:54:40.236]                           if (is.null(name)) 
  [20:54:40.236]                             next
  [20:54:40.236]                           if (!grepl("^muffle", name)) 
  [20:54:40.236]                             next
  [20:54:40.236]                           invokeRestart(restart)
  [20:54:40.236]                           muffled <- TRUE
  [20:54:40.236]                           break
  [20:54:40.236]                         }
  [20:54:40.236]                       }
  [20:54:40.236]                       invisible(muffled)
  [20:54:40.236]                     }
  [20:54:40.236]                     muffleCondition(cond)
  [20:54:40.236]                   }
  [20:54:40.236]                 }
  [20:54:40.236]             }
  [20:54:40.236]         }))
  [20:54:40.236]     }, error = function(ex) {
  [20:54:40.236]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.236]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.236]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.236]     }, finally = {
  [20:54:40.236]         {
  [20:54:40.236]             NULL
  [20:54:40.236]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.236]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.236]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.236]                 label = NULL, ...) 
  [20:54:40.236]             {
  [20:54:40.236]                 if (substitute) 
  [20:54:40.236]                   expr <- substitute(expr)
  [20:54:40.236]                 local <- as.logical(local)
  [20:54:40.236]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.236]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.236]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.236]                   label = label, ...)
  [20:54:40.236]                 if (!future$lazy) 
  [20:54:40.236]                   future <- run(future)
  [20:54:40.236]                 invisible(future)
  [20:54:40.236]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.236]         }
  [20:54:40.236]         base::options(...future.oldOptions)
  [20:54:40.236]     })
  [20:54:40.236]     Sys.time
  [20:54:40.236]     if (base::is.na(TRUE)) {
  [20:54:40.236]     }
  [20:54:40.236]     else {
  [20:54:40.236]         base::sink(type = "output", split = FALSE)
  [20:54:40.236]         if (TRUE) {
  [20:54:40.236]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.236]         }
  [20:54:40.236]         else {
  [20:54:40.236]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.236]         }
  [20:54:40.236]         base::close(...future.stdout)
  [20:54:40.236]         ...future.stdout <- NULL
  [20:54:40.236]     }
  [20:54:40.236]     ...future.result$conditions <- ...future.conditions
  [20:54:40.236]     ...future.result
  [20:54:40.236] }
  [20:54:40.241] plan(): Setting new future strategy stack:
  [20:54:40.241] List of future strategies:
  [20:54:40.241] 1. sequential:
  [20:54:40.241]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.241]    - tweaked: FALSE
  [20:54:40.241]    - call: NULL
  [20:54:40.242] plan(): nbrOfWorkers() = 1
  [20:54:40.243] plan(): Setting new future strategy stack:
  [20:54:40.243] List of future strategies:
  [20:54:40.243] 1. sequential:
  [20:54:40.243]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.243]    - tweaked: FALSE
  [20:54:40.243]    - call: plan(strategy)
  [20:54:40.244] plan(): nbrOfWorkers() = 1
  [20:54:40.245] SequentialFuture started (and completed)
  [20:54:40.246] getGlobalsAndPackages() ...
  [20:54:40.246] Searching for globals...
  [20:54:40.247] - globals found: [1] '{'
  [20:54:40.248] Searching for globals ... DONE
  [20:54:40.248] Resolving globals: FALSE
  [20:54:40.249] 
  [20:54:40.249] 
  [20:54:40.249] getGlobalsAndPackages() ... DONE
  [20:54:40.252] Packages needed by the future expression (n = 0): <none>
  [20:54:40.252] Packages needed by future strategies (n = 0): <none>
  [20:54:40.265] {
  [20:54:40.265]     {
  [20:54:40.265]         ...future.startTime <- base::Sys.time()
  [20:54:40.265]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:40.265]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:40.265]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:40.265]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:40.265]             future.resolve.recursive = NULL, width = 80L)
  [20:54:40.265]         {
  [20:54:40.265]             {
  [20:54:40.265]                 has_future <- base::requireNamespace("future", 
  [20:54:40.265]                   quietly = TRUE)
  [20:54:40.265]                 version <- if (has_future) 
  [20:54:40.265]                   utils::packageVersion("future")
  [20:54:40.265]                 else NULL
  [20:54:40.265]                 if (!has_future || version < "1.8.0") {
  [20:54:40.265]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:40.265]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:40.265]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:40.265]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:40.265]                       "release", "version")], collapse = " "), 
  [20:54:40.265]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:40.265]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:40.265]                     info)
  [20:54:40.265]                   info <- base::paste(info, collapse = "; ")
  [20:54:40.265]                   if (!has_future) {
  [20:54:40.265]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:40.265]                       info)
  [20:54:40.265]                   }
  [20:54:40.265]                   else {
  [20:54:40.265]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:40.265]                       info, version)
  [20:54:40.265]                   }
  [20:54:40.265]                   base::stop(msg)
  [20:54:40.265]                 }
  [20:54:40.265]             }
  [20:54:40.265]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:40.265]         }
  [20:54:40.265]     }
  [20:54:40.265]     if (base::is.na(TRUE)) {
  [20:54:40.265]     }
  [20:54:40.265]     else {
  [20:54:40.265]         if (TRUE) {
  [20:54:40.265]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:40.265]                 open = "w")
  [20:54:40.265]         }
  [20:54:40.265]         else {
  [20:54:40.265]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:40.265]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:40.265]         }
  [20:54:40.265]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:40.265]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:40.265]             base::sink(type = "output", split = FALSE)
  [20:54:40.265]             base::close(...future.stdout)
  [20:54:40.265]         }, add = TRUE)
  [20:54:40.265]     }
  [20:54:40.265]     ...future.frame <- base::sys.nframe()
  [20:54:40.265]     ...future.conditions <- base::list()
  [20:54:40.265]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:40.265]     ...future.result <- base::tryCatch({
  [20:54:40.265]         base::withCallingHandlers({
  [20:54:40.265]             ...future.value <- base::withVisible(base::local({
  [20:54:40.265]                 4
  [20:54:40.265]             }))
  [20:54:40.265]             future::FutureResult(value = ...future.value$value, 
  [20:54:40.265]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.265]                   ...future.rng), started = ...future.startTime, 
  [20:54:40.265]                 version = "1.8")
  [20:54:40.265]         }, condition = base::local({
  [20:54:40.265]             c <- base::c
  [20:54:40.265]             inherits <- base::inherits
  [20:54:40.265]             invokeRestart <- base::invokeRestart
  [20:54:40.265]             length <- base::length
  [20:54:40.265]             list <- base::list
  [20:54:40.265]             seq.int <- base::seq.int
  [20:54:40.265]             signalCondition <- base::signalCondition
  [20:54:40.265]             sys.calls <- base::sys.calls
  [20:54:40.265]             Sys.time <- base::Sys.time
  [20:54:40.265]             `[[` <- base::`[[`
  [20:54:40.265]             `+` <- base::`+`
  [20:54:40.265]             `<<-` <- base::`<<-`
  [20:54:40.265]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:40.265]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:40.265]                   3L)]
  [20:54:40.265]             }
  [20:54:40.265]             function(cond) {
  [20:54:40.265]                 if (inherits(cond, "error")) {
  [20:54:40.265]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.265]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:40.265]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:40.265]                   signalCondition(cond)
  [20:54:40.265]                 }
  [20:54:40.265]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:40.265]                 ))) {
  [20:54:40.265]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:40.265]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:40.265]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:40.265]                   if (!signal) {
  [20:54:40.265]                     muffleCondition <- function (cond) 
  [20:54:40.265]                     {
  [20:54:40.265]                       inherits <- base::inherits
  [20:54:40.265]                       invokeRestart <- base::invokeRestart
  [20:54:40.265]                       muffled <- FALSE
  [20:54:40.265]                       if (inherits(cond, "message")) {
  [20:54:40.265]                         invokeRestart("muffleMessage")
  [20:54:40.265]                         muffled <- TRUE
  [20:54:40.265]                       }
  [20:54:40.265]                       else if (inherits(cond, "warning")) {
  [20:54:40.265]                         invokeRestart("muffleWarning")
  [20:54:40.265]                         muffled <- TRUE
  [20:54:40.265]                       }
  [20:54:40.265]                       else if (inherits(cond, "condition")) {
  [20:54:40.265]                         computeRestarts <- base::computeRestarts
  [20:54:40.265]                         grepl <- base::grepl
  [20:54:40.265]                         is.null <- base::is.null
  [20:54:40.265]                         restarts <- computeRestarts(cond)
  [20:54:40.265]                         for (restart in restarts) {
  [20:54:40.265]                           name <- restart$name
  [20:54:40.265]                           if (is.null(name)) 
  [20:54:40.265]                             next
  [20:54:40.265]                           if (!grepl("^muffle", name)) 
  [20:54:40.265]                             next
  [20:54:40.265]                           invokeRestart(restart)
  [20:54:40.265]                           muffled <- TRUE
  [20:54:40.265]                           break
  [20:54:40.265]                         }
  [20:54:40.265]                       }
  [20:54:40.265]                       invisible(muffled)
  [20:54:40.265]                     }
  [20:54:40.265]                     muffleCondition(cond)
  [20:54:40.265]                   }
  [20:54:40.265]                 }
  [20:54:40.265]             }
  [20:54:40.265]         }))
  [20:54:40.265]     }, error = function(ex) {
  [20:54:40.265]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:40.265]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:40.265]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:40.265]     }, finally = {
  [20:54:40.265]         {
  [20:54:40.265]             NULL
  [20:54:40.265]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:40.265]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:40.265]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:40.265]                 label = NULL, ...) 
  [20:54:40.265]             {
  [20:54:40.265]                 if (substitute) 
  [20:54:40.265]                   expr <- substitute(expr)
  [20:54:40.265]                 local <- as.logical(local)
  [20:54:40.265]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:40.265]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:40.265]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:40.265]                   label = label, ...)
  [20:54:40.265]                 if (!future$lazy) 
  [20:54:40.265]                   future <- run(future)
  [20:54:40.265]                 invisible(future)
  [20:54:40.265]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:40.265]         }
  [20:54:40.265]         base::options(...future.oldOptions)
  [20:54:40.265]     })
  [20:54:40.265]     Sys.time
  [20:54:40.265]     if (base::is.na(TRUE)) {
  [20:54:40.265]     }
  [20:54:40.265]     else {
  [20:54:40.265]         base::sink(type = "output", split = FALSE)
  [20:54:40.265]         if (TRUE) {
  [20:54:40.265]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:40.265]         }
  [20:54:40.265]         else {
  [20:54:40.265]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:40.265]         }
  [20:54:40.265]         base::close(...future.stdout)
  [20:54:40.265]         ...future.stdout <- NULL
  [20:54:40.265]     }
  [20:54:40.265]     ...future.result$conditions <- ...future.conditions
  [20:54:40.265]     ...future.result
  [20:54:40.265] }
  [20:54:40.269] plan(): Setting new future strategy stack:
  [20:54:40.269] List of future strategies:
  [20:54:40.269] 1. sequential:
  [20:54:40.269]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.269]    - tweaked: FALSE
  [20:54:40.269]    - call: NULL
  [20:54:40.270] plan(): nbrOfWorkers() = 1
  [20:54:40.271] plan(): Setting new future strategy stack:
  [20:54:40.271] List of future strategies:
  [20:54:40.271] 1. sequential:
  [20:54:40.271]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:40.271]    - tweaked: FALSE
  [20:54:40.271]    - call: plan(strategy)
  [20:54:40.272] plan(): nbrOfWorkers() = 1
  [20:54:40.273] SequentialFuture started (and completed)
  <environment: 0x556b10503d18> 
  <environment: 0x556b10114be8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:40.278] resolve() on environment ...
  [20:54:40.279]  recursive: 0
  [20:54:40.280]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:40.280] signalConditionsASAP(numeric, pos=1) ...
  [20:54:40.280] - nx: 4
  [20:54:40.280] - relay: TRUE
  [20:54:40.281] - stdout: TRUE
  [20:54:40.281] - signal: TRUE
  [20:54:40.281] - resignal: FALSE
  [20:54:40.281] - force: TRUE
  [20:54:40.281] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.282] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.282]  - until=2
  [20:54:40.282]  - relaying element #2
  [20:54:40.282] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.283] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.283] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:40.283]  length: 3 (resolved future 1)
  [20:54:40.283] Future #2
  [20:54:40.284] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:40.284] - nx: 4
  [20:54:40.284] - relay: TRUE
  [20:54:40.284] - stdout: TRUE
  [20:54:40.285] - signal: TRUE
  [20:54:40.285] - resignal: FALSE
  [20:54:40.285] - force: TRUE
  [20:54:40.285] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:40.285] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:40.286]  - until=2
  [20:54:40.286]  - relaying element #2
  [20:54:40.286] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.287] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.287] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:40.287]  length: 2 (resolved future 2)
  [20:54:40.287] Future #3
  [20:54:40.288] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:40.288] - nx: 4
  [20:54:40.288] - relay: TRUE
  [20:54:40.288] - stdout: TRUE
  [20:54:40.289] - signal: TRUE
  [20:54:40.289] - resignal: FALSE
  [20:54:40.289] - force: TRUE
  [20:54:40.289] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:40.289] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:40.290]  - until=3
  [20:54:40.290]  - relaying element #3
  [20:54:40.290] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.291] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.291] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:40.291]  length: 1 (resolved future 3)
  [20:54:40.291] Future #4
  [20:54:40.292] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:40.292] - nx: 4
  [20:54:40.292] - relay: TRUE
  [20:54:40.292] - stdout: TRUE
  [20:54:40.293] - signal: TRUE
  [20:54:40.293] - resignal: FALSE
  [20:54:40.293] - force: TRUE
  [20:54:40.293] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:40.293] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:40.294]  - until=4
  [20:54:40.294]  - relaying element #4
  [20:54:40.294] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.295] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.295] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:40.295]  length: 0 (resolved future 4)
  [20:54:40.295] Relaying remaining futures
  [20:54:40.296] signalConditionsASAP(NULL, pos=0) ...
  [20:54:40.296] - nx: 4
  [20:54:40.296] - relay: TRUE
  [20:54:40.296] - stdout: TRUE
  [20:54:40.296] - signal: TRUE
  [20:54:40.297] - resignal: FALSE
  [20:54:40.297] - force: TRUE
  [20:54:40.297] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.297] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:40.298] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:40.298] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:40.298] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:40.298] resolve() on environment ... DONE
  <environment: 0x556b0fd5e718> 
  Type of future: cluster
  [20:54:40.300] plan(): Setting new future strategy stack:
  [20:54:40.300] List of future strategies:
  [20:54:40.300] 1. cluster:
  [20:54:40.300]    - 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, ...)
  [20:54:40.300]    - tweaked: FALSE
  [20:54:40.300]    - call: plan(strategy)
  [20:54:40.301] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [20:54:40.301] cluster:
  [20:54:40.301] - 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, ...)
  [20:54:40.301] - tweaked: FALSE
  [20:54:40.301] - call: plan(strategy)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 39924
  [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/RtmpmXdcvf/future.parent=13459.3493db96e36.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmXdcvf/future.parent=13459.3493db96e36.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:13459' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmXdcvf/future.parent=13459.3493db96e36.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=39924 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
  [20:54:48.140] getGlobalsAndPackages() ...
  [20:54:48.141] Not searching for globals
  [20:54:48.141] - globals: [0] <none>
  [20:54:48.141] getGlobalsAndPackages() ... DONE
  [20:54:48.145] Packages needed by the future expression (n = 0): <none>
  [20:54:48.146] Packages needed by future strategies (n = 0): <none>
  [20:54:48.157] {
  [20:54:48.157]     {
  [20:54:48.157]         ...future.startTime <- base::Sys.time()
  [20:54:48.157]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.157]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.157]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.157]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.157]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.157]         {
  [20:54:48.157]             {
  [20:54:48.157]                 has_future <- base::requireNamespace("future", 
  [20:54:48.157]                   quietly = TRUE)
  [20:54:48.157]                 version <- if (has_future) 
  [20:54:48.157]                   utils::packageVersion("future")
  [20:54:48.157]                 else NULL
  [20:54:48.157]                 if (!has_future || version < "1.8.0") {
  [20:54:48.157]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.157]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.157]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.157]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.157]                       "release", "version")], collapse = " "), 
  [20:54:48.157]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.157]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.157]                     info)
  [20:54:48.157]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.157]                   if (!has_future) {
  [20:54:48.157]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.157]                       info)
  [20:54:48.157]                   }
  [20:54:48.157]                   else {
  [20:54:48.157]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.157]                       info, version)
  [20:54:48.157]                   }
  [20:54:48.157]                   base::stop(msg)
  [20:54:48.157]                 }
  [20:54:48.157]             }
  [20:54:48.157]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.157]         }
  [20:54:48.157]     }
  [20:54:48.157]     if (base::is.na(TRUE)) {
  [20:54:48.157]     }
  [20:54:48.157]     else {
  [20:54:48.157]         if (TRUE) {
  [20:54:48.157]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.157]                 open = "w")
  [20:54:48.157]         }
  [20:54:48.157]         else {
  [20:54:48.157]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.157]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.157]         }
  [20:54:48.157]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.157]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.157]             base::sink(type = "output", split = FALSE)
  [20:54:48.157]             base::close(...future.stdout)
  [20:54:48.157]         }, add = TRUE)
  [20:54:48.157]     }
  [20:54:48.157]     ...future.frame <- base::sys.nframe()
  [20:54:48.157]     ...future.conditions <- base::list()
  [20:54:48.157]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.157]     ...future.result <- base::tryCatch({
  [20:54:48.157]         base::withCallingHandlers({
  [20:54:48.157]             ...future.value <- base::withVisible(base::local({
  [20:54:48.157]                 ...future.sendCondition <- local({
  [20:54:48.157]                   sendCondition <- NULL
  [20:54:48.157]                   function(frame = 1L) {
  [20:54:48.157]                     if (is.function(sendCondition)) 
  [20:54:48.157]                       return(sendCondition)
  [20:54:48.157]                     ns <- getNamespace("parallel")
  [20:54:48.157]                     if (exists("sendData", mode = "function", 
  [20:54:48.157]                       envir = ns)) {
  [20:54:48.157]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.157]                         envir = ns)
  [20:54:48.157]                       envir <- sys.frame(frame)
  [20:54:48.157]                       master <- NULL
  [20:54:48.157]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.157]                         !identical(envir, emptyenv())) {
  [20:54:48.157]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.157]                           inherits = FALSE)) {
  [20:54:48.157]                           master <- get("master", mode = "list", 
  [20:54:48.157]                             envir = envir, inherits = FALSE)
  [20:54:48.157]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.157]                             sendCondition <<- function(cond) {
  [20:54:48.157]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.157]                                 success = TRUE)
  [20:54:48.157]                               parallel_sendData(master, data)
  [20:54:48.157]                             }
  [20:54:48.157]                             return(sendCondition)
  [20:54:48.157]                           }
  [20:54:48.157]                         }
  [20:54:48.157]                         frame <- frame + 1L
  [20:54:48.157]                         envir <- sys.frame(frame)
  [20:54:48.157]                       }
  [20:54:48.157]                     }
  [20:54:48.157]                     sendCondition <<- function(cond) NULL
  [20:54:48.157]                   }
  [20:54:48.157]                 })
  [20:54:48.157]                 withCallingHandlers({
  [20:54:48.157]                   NA
  [20:54:48.157]                 }, immediateCondition = function(cond) {
  [20:54:48.157]                   sendCondition <- ...future.sendCondition()
  [20:54:48.157]                   sendCondition(cond)
  [20:54:48.157]                   muffleCondition <- function (cond) 
  [20:54:48.157]                   {
  [20:54:48.157]                     inherits <- base::inherits
  [20:54:48.157]                     invokeRestart <- base::invokeRestart
  [20:54:48.157]                     muffled <- FALSE
  [20:54:48.157]                     if (inherits(cond, "message")) {
  [20:54:48.157]                       invokeRestart("muffleMessage")
  [20:54:48.157]                       muffled <- TRUE
  [20:54:48.157]                     }
  [20:54:48.157]                     else if (inherits(cond, "warning")) {
  [20:54:48.157]                       invokeRestart("muffleWarning")
  [20:54:48.157]                       muffled <- TRUE
  [20:54:48.157]                     }
  [20:54:48.157]                     else if (inherits(cond, "condition")) {
  [20:54:48.157]                       computeRestarts <- base::computeRestarts
  [20:54:48.157]                       grepl <- base::grepl
  [20:54:48.157]                       is.null <- base::is.null
  [20:54:48.157]                       restarts <- computeRestarts(cond)
  [20:54:48.157]                       for (restart in restarts) {
  [20:54:48.157]                         name <- restart$name
  [20:54:48.157]                         if (is.null(name)) 
  [20:54:48.157]                           next
  [20:54:48.157]                         if (!grepl("^muffle", name)) 
  [20:54:48.157]                           next
  [20:54:48.157]                         invokeRestart(restart)
  [20:54:48.157]                         muffled <- TRUE
  [20:54:48.157]                         break
  [20:54:48.157]                       }
  [20:54:48.157]                     }
  [20:54:48.157]                     invisible(muffled)
  [20:54:48.157]                   }
  [20:54:48.157]                   muffleCondition(cond)
  [20:54:48.157]                 })
  [20:54:48.157]             }))
  [20:54:48.157]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.157]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.157]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.157]                 version = "1.8")
  [20:54:48.157]         }, condition = base::local({
  [20:54:48.157]             c <- base::c
  [20:54:48.157]             inherits <- base::inherits
  [20:54:48.157]             invokeRestart <- base::invokeRestart
  [20:54:48.157]             length <- base::length
  [20:54:48.157]             list <- base::list
  [20:54:48.157]             seq.int <- base::seq.int
  [20:54:48.157]             signalCondition <- base::signalCondition
  [20:54:48.157]             sys.calls <- base::sys.calls
  [20:54:48.157]             Sys.time <- base::Sys.time
  [20:54:48.157]             `[[` <- base::`[[`
  [20:54:48.157]             `+` <- base::`+`
  [20:54:48.157]             `<<-` <- base::`<<-`
  [20:54:48.157]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.157]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.157]                   3L)]
  [20:54:48.157]             }
  [20:54:48.157]             function(cond) {
  [20:54:48.157]                 if (inherits(cond, "error")) {
  [20:54:48.157]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.157]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.157]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.157]                   signalCondition(cond)
  [20:54:48.157]                 }
  [20:54:48.157]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.157]                 ))) {
  [20:54:48.157]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.157]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.157]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.157]                   if (!signal) {
  [20:54:48.157]                     muffleCondition <- function (cond) 
  [20:54:48.157]                     {
  [20:54:48.157]                       inherits <- base::inherits
  [20:54:48.157]                       invokeRestart <- base::invokeRestart
  [20:54:48.157]                       muffled <- FALSE
  [20:54:48.157]                       if (inherits(cond, "message")) {
  [20:54:48.157]                         invokeRestart("muffleMessage")
  [20:54:48.157]                         muffled <- TRUE
  [20:54:48.157]                       }
  [20:54:48.157]                       else if (inherits(cond, "warning")) {
  [20:54:48.157]                         invokeRestart("muffleWarning")
  [20:54:48.157]                         muffled <- TRUE
  [20:54:48.157]                       }
  [20:54:48.157]                       else if (inherits(cond, "condition")) {
  [20:54:48.157]                         computeRestarts <- base::computeRestarts
  [20:54:48.157]                         grepl <- base::grepl
  [20:54:48.157]                         is.null <- base::is.null
  [20:54:48.157]                         restarts <- computeRestarts(cond)
  [20:54:48.157]                         for (restart in restarts) {
  [20:54:48.157]                           name <- restart$name
  [20:54:48.157]                           if (is.null(name)) 
  [20:54:48.157]                             next
  [20:54:48.157]                           if (!grepl("^muffle", name)) 
  [20:54:48.157]                             next
  [20:54:48.157]                           invokeRestart(restart)
  [20:54:48.157]                           muffled <- TRUE
  [20:54:48.157]                           break
  [20:54:48.157]                         }
  [20:54:48.157]                       }
  [20:54:48.157]                       invisible(muffled)
  [20:54:48.157]                     }
  [20:54:48.157]                     muffleCondition(cond)
  [20:54:48.157]                   }
  [20:54:48.157]                 }
  [20:54:48.157]             }
  [20:54:48.157]         }))
  [20:54:48.157]     }, error = function(ex) {
  [20:54:48.157]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.157]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.157]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.157]     }, finally = {
  [20:54:48.157]         {
  [20:54:48.157]             NULL
  [20:54:48.157]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.157]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.157]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.157]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.157]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.157]                 ...) 
  [20:54:48.157]             {
  [20:54:48.157]                 if (substitute) 
  [20:54:48.157]                   expr <- substitute(expr)
  [20:54:48.157]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.157]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.157]                   globals = globals, persistent = persistent, 
  [20:54:48.157]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.157]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.157]                   label = label, ...)
  [20:54:48.157]                 if (!future$lazy) 
  [20:54:48.157]                   future <- run(future)
  [20:54:48.157]                 invisible(future)
  [20:54:48.157]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.157]         }
  [20:54:48.157]         base::options(...future.oldOptions)
  [20:54:48.157]     })
  [20:54:48.157]     Sys.time
  [20:54:48.157]     if (base::is.na(TRUE)) {
  [20:54:48.157]     }
  [20:54:48.157]     else {
  [20:54:48.157]         base::sink(type = "output", split = FALSE)
  [20:54:48.157]         if (TRUE) {
  [20:54:48.157]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.157]         }
  [20:54:48.157]         else {
  [20:54:48.157]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.157]         }
  [20:54:48.157]         base::close(...future.stdout)
  [20:54:48.157]         ...future.stdout <- NULL
  [20:54:48.157]     }
  [20:54:48.157]     ...future.result$conditions <- ...future.conditions
  [20:54:48.157]     ...future.result
  [20:54:48.157] }
  [20:54:48.166] ClusterFuture started
  [20:54:48.166] result() for ClusterFuture ...
  [20:54:48.167] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.167] - Validating connection of ClusterFuture
  [20:54:48.377] - received message: FutureResult
  [20:54:48.377] - Received FutureResult
  [20:54:48.378] - Erased future from FutureRegistry
  [20:54:48.378] result() for ClusterFuture ...
  [20:54:48.378] - result already collected: FutureResult
  [20:54:48.379] result() for ClusterFuture ... done
  [20:54:48.379] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:48.379] result() for ClusterFuture ... done
  [20:54:48.380] result() for ClusterFuture ...
  [20:54:48.380] - result already collected: FutureResult
  [20:54:48.380] result() for ClusterFuture ... done
  [20:54:48.381] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:54:48.382] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [20:54:48.387] getGlobalsAndPackages() ...
  [20:54:48.388] Searching for globals...
  [20:54:48.389] 
  [20:54:48.389] Searching for globals ... DONE
  [20:54:48.389] - globals: [0] <none>
  [20:54:48.389] getGlobalsAndPackages() ... DONE
  [20:54:48.409] Packages needed by the future expression (n = 0): <none>
  [20:54:48.410] Packages needed by future strategies (n = 0): <none>
  [20:54:48.414] {
  [20:54:48.414]     {
  [20:54:48.414]         ...future.startTime <- base::Sys.time()
  [20:54:48.414]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.414]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.414]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.414]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.414]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.414]         {
  [20:54:48.414]             {
  [20:54:48.414]                 has_future <- base::requireNamespace("future", 
  [20:54:48.414]                   quietly = TRUE)
  [20:54:48.414]                 version <- if (has_future) 
  [20:54:48.414]                   utils::packageVersion("future")
  [20:54:48.414]                 else NULL
  [20:54:48.414]                 if (!has_future || version < "1.8.0") {
  [20:54:48.414]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.414]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.414]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.414]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.414]                       "release", "version")], collapse = " "), 
  [20:54:48.414]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.414]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.414]                     info)
  [20:54:48.414]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.414]                   if (!has_future) {
  [20:54:48.414]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.414]                       info)
  [20:54:48.414]                   }
  [20:54:48.414]                   else {
  [20:54:48.414]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.414]                       info, version)
  [20:54:48.414]                   }
  [20:54:48.414]                   base::stop(msg)
  [20:54:48.414]                 }
  [20:54:48.414]             }
  [20:54:48.414]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.414]         }
  [20:54:48.414]     }
  [20:54:48.414]     if (base::is.na(TRUE)) {
  [20:54:48.414]     }
  [20:54:48.414]     else {
  [20:54:48.414]         if (TRUE) {
  [20:54:48.414]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.414]                 open = "w")
  [20:54:48.414]         }
  [20:54:48.414]         else {
  [20:54:48.414]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.414]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.414]         }
  [20:54:48.414]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.414]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.414]             base::sink(type = "output", split = FALSE)
  [20:54:48.414]             base::close(...future.stdout)
  [20:54:48.414]         }, add = TRUE)
  [20:54:48.414]     }
  [20:54:48.414]     ...future.frame <- base::sys.nframe()
  [20:54:48.414]     ...future.conditions <- base::list()
  [20:54:48.414]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.414]     ...future.result <- base::tryCatch({
  [20:54:48.414]         base::withCallingHandlers({
  [20:54:48.414]             ...future.value <- base::withVisible(base::local({
  [20:54:48.414]                 ...future.sendCondition <- local({
  [20:54:48.414]                   sendCondition <- NULL
  [20:54:48.414]                   function(frame = 1L) {
  [20:54:48.414]                     if (is.function(sendCondition)) 
  [20:54:48.414]                       return(sendCondition)
  [20:54:48.414]                     ns <- getNamespace("parallel")
  [20:54:48.414]                     if (exists("sendData", mode = "function", 
  [20:54:48.414]                       envir = ns)) {
  [20:54:48.414]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.414]                         envir = ns)
  [20:54:48.414]                       envir <- sys.frame(frame)
  [20:54:48.414]                       master <- NULL
  [20:54:48.414]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.414]                         !identical(envir, emptyenv())) {
  [20:54:48.414]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.414]                           inherits = FALSE)) {
  [20:54:48.414]                           master <- get("master", mode = "list", 
  [20:54:48.414]                             envir = envir, inherits = FALSE)
  [20:54:48.414]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.414]                             sendCondition <<- function(cond) {
  [20:54:48.414]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.414]                                 success = TRUE)
  [20:54:48.414]                               parallel_sendData(master, data)
  [20:54:48.414]                             }
  [20:54:48.414]                             return(sendCondition)
  [20:54:48.414]                           }
  [20:54:48.414]                         }
  [20:54:48.414]                         frame <- frame + 1L
  [20:54:48.414]                         envir <- sys.frame(frame)
  [20:54:48.414]                       }
  [20:54:48.414]                     }
  [20:54:48.414]                     sendCondition <<- function(cond) NULL
  [20:54:48.414]                   }
  [20:54:48.414]                 })
  [20:54:48.414]                 withCallingHandlers({
  [20:54:48.414]                   2
  [20:54:48.414]                 }, immediateCondition = function(cond) {
  [20:54:48.414]                   sendCondition <- ...future.sendCondition()
  [20:54:48.414]                   sendCondition(cond)
  [20:54:48.414]                   muffleCondition <- function (cond) 
  [20:54:48.414]                   {
  [20:54:48.414]                     inherits <- base::inherits
  [20:54:48.414]                     invokeRestart <- base::invokeRestart
  [20:54:48.414]                     muffled <- FALSE
  [20:54:48.414]                     if (inherits(cond, "message")) {
  [20:54:48.414]                       invokeRestart("muffleMessage")
  [20:54:48.414]                       muffled <- TRUE
  [20:54:48.414]                     }
  [20:54:48.414]                     else if (inherits(cond, "warning")) {
  [20:54:48.414]                       invokeRestart("muffleWarning")
  [20:54:48.414]                       muffled <- TRUE
  [20:54:48.414]                     }
  [20:54:48.414]                     else if (inherits(cond, "condition")) {
  [20:54:48.414]                       computeRestarts <- base::computeRestarts
  [20:54:48.414]                       grepl <- base::grepl
  [20:54:48.414]                       is.null <- base::is.null
  [20:54:48.414]                       restarts <- computeRestarts(cond)
  [20:54:48.414]                       for (restart in restarts) {
  [20:54:48.414]                         name <- restart$name
  [20:54:48.414]                         if (is.null(name)) 
  [20:54:48.414]                           next
  [20:54:48.414]                         if (!grepl("^muffle", name)) 
  [20:54:48.414]                           next
  [20:54:48.414]                         invokeRestart(restart)
  [20:54:48.414]                         muffled <- TRUE
  [20:54:48.414]                         break
  [20:54:48.414]                       }
  [20:54:48.414]                     }
  [20:54:48.414]                     invisible(muffled)
  [20:54:48.414]                   }
  [20:54:48.414]                   muffleCondition(cond)
  [20:54:48.414]                 })
  [20:54:48.414]             }))
  [20:54:48.414]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.414]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.414]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.414]                 version = "1.8")
  [20:54:48.414]         }, condition = base::local({
  [20:54:48.414]             c <- base::c
  [20:54:48.414]             inherits <- base::inherits
  [20:54:48.414]             invokeRestart <- base::invokeRestart
  [20:54:48.414]             length <- base::length
  [20:54:48.414]             list <- base::list
  [20:54:48.414]             seq.int <- base::seq.int
  [20:54:48.414]             signalCondition <- base::signalCondition
  [20:54:48.414]             sys.calls <- base::sys.calls
  [20:54:48.414]             Sys.time <- base::Sys.time
  [20:54:48.414]             `[[` <- base::`[[`
  [20:54:48.414]             `+` <- base::`+`
  [20:54:48.414]             `<<-` <- base::`<<-`
  [20:54:48.414]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.414]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.414]                   3L)]
  [20:54:48.414]             }
  [20:54:48.414]             function(cond) {
  [20:54:48.414]                 if (inherits(cond, "error")) {
  [20:54:48.414]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.414]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.414]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.414]                   signalCondition(cond)
  [20:54:48.414]                 }
  [20:54:48.414]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.414]                 ))) {
  [20:54:48.414]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.414]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.414]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.414]                   if (!signal) {
  [20:54:48.414]                     muffleCondition <- function (cond) 
  [20:54:48.414]                     {
  [20:54:48.414]                       inherits <- base::inherits
  [20:54:48.414]                       invokeRestart <- base::invokeRestart
  [20:54:48.414]                       muffled <- FALSE
  [20:54:48.414]                       if (inherits(cond, "message")) {
  [20:54:48.414]                         invokeRestart("muffleMessage")
  [20:54:48.414]                         muffled <- TRUE
  [20:54:48.414]                       }
  [20:54:48.414]                       else if (inherits(cond, "warning")) {
  [20:54:48.414]                         invokeRestart("muffleWarning")
  [20:54:48.414]                         muffled <- TRUE
  [20:54:48.414]                       }
  [20:54:48.414]                       else if (inherits(cond, "condition")) {
  [20:54:48.414]                         computeRestarts <- base::computeRestarts
  [20:54:48.414]                         grepl <- base::grepl
  [20:54:48.414]                         is.null <- base::is.null
  [20:54:48.414]                         restarts <- computeRestarts(cond)
  [20:54:48.414]                         for (restart in restarts) {
  [20:54:48.414]                           name <- restart$name
  [20:54:48.414]                           if (is.null(name)) 
  [20:54:48.414]                             next
  [20:54:48.414]                           if (!grepl("^muffle", name)) 
  [20:54:48.414]                             next
  [20:54:48.414]                           invokeRestart(restart)
  [20:54:48.414]                           muffled <- TRUE
  [20:54:48.414]                           break
  [20:54:48.414]                         }
  [20:54:48.414]                       }
  [20:54:48.414]                       invisible(muffled)
  [20:54:48.414]                     }
  [20:54:48.414]                     muffleCondition(cond)
  [20:54:48.414]                   }
  [20:54:48.414]                 }
  [20:54:48.414]             }
  [20:54:48.414]         }))
  [20:54:48.414]     }, error = function(ex) {
  [20:54:48.414]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.414]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.414]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.414]     }, finally = {
  [20:54:48.414]         {
  [20:54:48.414]             NULL
  [20:54:48.414]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.414]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.414]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.414]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.414]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.414]                 ...) 
  [20:54:48.414]             {
  [20:54:48.414]                 if (substitute) 
  [20:54:48.414]                   expr <- substitute(expr)
  [20:54:48.414]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.414]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.414]                   globals = globals, persistent = persistent, 
  [20:54:48.414]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.414]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.414]                   label = label, ...)
  [20:54:48.414]                 if (!future$lazy) 
  [20:54:48.414]                   future <- run(future)
  [20:54:48.414]                 invisible(future)
  [20:54:48.414]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.414]         }
  [20:54:48.414]         base::options(...future.oldOptions)
  [20:54:48.414]     })
  [20:54:48.414]     Sys.time
  [20:54:48.414]     if (base::is.na(TRUE)) {
  [20:54:48.414]     }
  [20:54:48.414]     else {
  [20:54:48.414]         base::sink(type = "output", split = FALSE)
  [20:54:48.414]         if (TRUE) {
  [20:54:48.414]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.414]         }
  [20:54:48.414]         else {
  [20:54:48.414]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.414]         }
  [20:54:48.414]         base::close(...future.stdout)
  [20:54:48.414]         ...future.stdout <- NULL
  [20:54:48.414]     }
  [20:54:48.414]     ...future.result$conditions <- ...future.conditions
  [20:54:48.414]     ...future.result
  [20:54:48.414] }
  [20:54:48.421] ClusterFuture started
  [20:54:48.441] getGlobalsAndPackages() ...
  [20:54:48.441] Searching for globals...
  [20:54:48.442] 
  [20:54:48.442] Searching for globals ... DONE
  [20:54:48.443] - globals: [0] <none>
  [20:54:48.443] getGlobalsAndPackages() ... DONE
  [20:54:48.446] Packages needed by the future expression (n = 0): <none>
  [20:54:48.447] Packages needed by future strategies (n = 0): <none>
  [20:54:48.452] {
  [20:54:48.452]     {
  [20:54:48.452]         ...future.startTime <- base::Sys.time()
  [20:54:48.452]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.452]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.452]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.452]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.452]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.452]         {
  [20:54:48.452]             {
  [20:54:48.452]                 has_future <- base::requireNamespace("future", 
  [20:54:48.452]                   quietly = TRUE)
  [20:54:48.452]                 version <- if (has_future) 
  [20:54:48.452]                   utils::packageVersion("future")
  [20:54:48.452]                 else NULL
  [20:54:48.452]                 if (!has_future || version < "1.8.0") {
  [20:54:48.452]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.452]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.452]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.452]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.452]                       "release", "version")], collapse = " "), 
  [20:54:48.452]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.452]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.452]                     info)
  [20:54:48.452]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.452]                   if (!has_future) {
  [20:54:48.452]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.452]                       info)
  [20:54:48.452]                   }
  [20:54:48.452]                   else {
  [20:54:48.452]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.452]                       info, version)
  [20:54:48.452]                   }
  [20:54:48.452]                   base::stop(msg)
  [20:54:48.452]                 }
  [20:54:48.452]             }
  [20:54:48.452]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.452]         }
  [20:54:48.452]     }
  [20:54:48.452]     if (base::is.na(TRUE)) {
  [20:54:48.452]     }
  [20:54:48.452]     else {
  [20:54:48.452]         if (TRUE) {
  [20:54:48.452]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.452]                 open = "w")
  [20:54:48.452]         }
  [20:54:48.452]         else {
  [20:54:48.452]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.452]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.452]         }
  [20:54:48.452]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.452]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.452]             base::sink(type = "output", split = FALSE)
  [20:54:48.452]             base::close(...future.stdout)
  [20:54:48.452]         }, add = TRUE)
  [20:54:48.452]     }
  [20:54:48.452]     ...future.frame <- base::sys.nframe()
  [20:54:48.452]     ...future.conditions <- base::list()
  [20:54:48.452]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.452]     ...future.result <- base::tryCatch({
  [20:54:48.452]         base::withCallingHandlers({
  [20:54:48.452]             ...future.value <- base::withVisible(base::local({
  [20:54:48.452]                 ...future.sendCondition <- local({
  [20:54:48.452]                   sendCondition <- NULL
  [20:54:48.452]                   function(frame = 1L) {
  [20:54:48.452]                     if (is.function(sendCondition)) 
  [20:54:48.452]                       return(sendCondition)
  [20:54:48.452]                     ns <- getNamespace("parallel")
  [20:54:48.452]                     if (exists("sendData", mode = "function", 
  [20:54:48.452]                       envir = ns)) {
  [20:54:48.452]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.452]                         envir = ns)
  [20:54:48.452]                       envir <- sys.frame(frame)
  [20:54:48.452]                       master <- NULL
  [20:54:48.452]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.452]                         !identical(envir, emptyenv())) {
  [20:54:48.452]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.452]                           inherits = FALSE)) {
  [20:54:48.452]                           master <- get("master", mode = "list", 
  [20:54:48.452]                             envir = envir, inherits = FALSE)
  [20:54:48.452]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.452]                             sendCondition <<- function(cond) {
  [20:54:48.452]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.452]                                 success = TRUE)
  [20:54:48.452]                               parallel_sendData(master, data)
  [20:54:48.452]                             }
  [20:54:48.452]                             return(sendCondition)
  [20:54:48.452]                           }
  [20:54:48.452]                         }
  [20:54:48.452]                         frame <- frame + 1L
  [20:54:48.452]                         envir <- sys.frame(frame)
  [20:54:48.452]                       }
  [20:54:48.452]                     }
  [20:54:48.452]                     sendCondition <<- function(cond) NULL
  [20:54:48.452]                   }
  [20:54:48.452]                 })
  [20:54:48.452]                 withCallingHandlers({
  [20:54:48.452]                   NULL
  [20:54:48.452]                 }, immediateCondition = function(cond) {
  [20:54:48.452]                   sendCondition <- ...future.sendCondition()
  [20:54:48.452]                   sendCondition(cond)
  [20:54:48.452]                   muffleCondition <- function (cond) 
  [20:54:48.452]                   {
  [20:54:48.452]                     inherits <- base::inherits
  [20:54:48.452]                     invokeRestart <- base::invokeRestart
  [20:54:48.452]                     muffled <- FALSE
  [20:54:48.452]                     if (inherits(cond, "message")) {
  [20:54:48.452]                       invokeRestart("muffleMessage")
  [20:54:48.452]                       muffled <- TRUE
  [20:54:48.452]                     }
  [20:54:48.452]                     else if (inherits(cond, "warning")) {
  [20:54:48.452]                       invokeRestart("muffleWarning")
  [20:54:48.452]                       muffled <- TRUE
  [20:54:48.452]                     }
  [20:54:48.452]                     else if (inherits(cond, "condition")) {
  [20:54:48.452]                       computeRestarts <- base::computeRestarts
  [20:54:48.452]                       grepl <- base::grepl
  [20:54:48.452]                       is.null <- base::is.null
  [20:54:48.452]                       restarts <- computeRestarts(cond)
  [20:54:48.452]                       for (restart in restarts) {
  [20:54:48.452]                         name <- restart$name
  [20:54:48.452]                         if (is.null(name)) 
  [20:54:48.452]                           next
  [20:54:48.452]                         if (!grepl("^muffle", name)) 
  [20:54:48.452]                           next
  [20:54:48.452]                         invokeRestart(restart)
  [20:54:48.452]                         muffled <- TRUE
  [20:54:48.452]                         break
  [20:54:48.452]                       }
  [20:54:48.452]                     }
  [20:54:48.452]                     invisible(muffled)
  [20:54:48.452]                   }
  [20:54:48.452]                   muffleCondition(cond)
  [20:54:48.452]                 })
  [20:54:48.452]             }))
  [20:54:48.452]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.452]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.452]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.452]                 version = "1.8")
  [20:54:48.452]         }, condition = base::local({
  [20:54:48.452]             c <- base::c
  [20:54:48.452]             inherits <- base::inherits
  [20:54:48.452]             invokeRestart <- base::invokeRestart
  [20:54:48.452]             length <- base::length
  [20:54:48.452]             list <- base::list
  [20:54:48.452]             seq.int <- base::seq.int
  [20:54:48.452]             signalCondition <- base::signalCondition
  [20:54:48.452]             sys.calls <- base::sys.calls
  [20:54:48.452]             Sys.time <- base::Sys.time
  [20:54:48.452]             `[[` <- base::`[[`
  [20:54:48.452]             `+` <- base::`+`
  [20:54:48.452]             `<<-` <- base::`<<-`
  [20:54:48.452]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.452]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.452]                   3L)]
  [20:54:48.452]             }
  [20:54:48.452]             function(cond) {
  [20:54:48.452]                 if (inherits(cond, "error")) {
  [20:54:48.452]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.452]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.452]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.452]                   signalCondition(cond)
  [20:54:48.452]                 }
  [20:54:48.452]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.452]                 ))) {
  [20:54:48.452]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.452]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.452]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.452]                   if (!signal) {
  [20:54:48.452]                     muffleCondition <- function (cond) 
  [20:54:48.452]                     {
  [20:54:48.452]                       inherits <- base::inherits
  [20:54:48.452]                       invokeRestart <- base::invokeRestart
  [20:54:48.452]                       muffled <- FALSE
  [20:54:48.452]                       if (inherits(cond, "message")) {
  [20:54:48.452]                         invokeRestart("muffleMessage")
  [20:54:48.452]                         muffled <- TRUE
  [20:54:48.452]                       }
  [20:54:48.452]                       else if (inherits(cond, "warning")) {
  [20:54:48.452]                         invokeRestart("muffleWarning")
  [20:54:48.452]                         muffled <- TRUE
  [20:54:48.452]                       }
  [20:54:48.452]                       else if (inherits(cond, "condition")) {
  [20:54:48.452]                         computeRestarts <- base::computeRestarts
  [20:54:48.452]                         grepl <- base::grepl
  [20:54:48.452]                         is.null <- base::is.null
  [20:54:48.452]                         restarts <- computeRestarts(cond)
  [20:54:48.452]                         for (restart in restarts) {
  [20:54:48.452]                           name <- restart$name
  [20:54:48.452]                           if (is.null(name)) 
  [20:54:48.452]                             next
  [20:54:48.452]                           if (!grepl("^muffle", name)) 
  [20:54:48.452]                             next
  [20:54:48.452]                           invokeRestart(restart)
  [20:54:48.452]                           muffled <- TRUE
  [20:54:48.452]                           break
  [20:54:48.452]                         }
  [20:54:48.452]                       }
  [20:54:48.452]                       invisible(muffled)
  [20:54:48.452]                     }
  [20:54:48.452]                     muffleCondition(cond)
  [20:54:48.452]                   }
  [20:54:48.452]                 }
  [20:54:48.452]             }
  [20:54:48.452]         }))
  [20:54:48.452]     }, error = function(ex) {
  [20:54:48.452]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.452]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.452]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.452]     }, finally = {
  [20:54:48.452]         {
  [20:54:48.452]             NULL
  [20:54:48.452]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.452]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.452]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.452]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.452]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.452]                 ...) 
  [20:54:48.452]             {
  [20:54:48.452]                 if (substitute) 
  [20:54:48.452]                   expr <- substitute(expr)
  [20:54:48.452]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.452]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.452]                   globals = globals, persistent = persistent, 
  [20:54:48.452]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.452]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.452]                   label = label, ...)
  [20:54:48.452]                 if (!future$lazy) 
  [20:54:48.452]                   future <- run(future)
  [20:54:48.452]                 invisible(future)
  [20:54:48.452]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.452]         }
  [20:54:48.452]         base::options(...future.oldOptions)
  [20:54:48.452]     })
  [20:54:48.452]     Sys.time
  [20:54:48.452]     if (base::is.na(TRUE)) {
  [20:54:48.452]     }
  [20:54:48.452]     else {
  [20:54:48.452]         base::sink(type = "output", split = FALSE)
  [20:54:48.452]         if (TRUE) {
  [20:54:48.452]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.452]         }
  [20:54:48.452]         else {
  [20:54:48.452]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.452]         }
  [20:54:48.452]         base::close(...future.stdout)
  [20:54:48.452]         ...future.stdout <- NULL
  [20:54:48.452]     }
  [20:54:48.452]     ...future.result$conditions <- ...future.conditions
  [20:54:48.452]     ...future.result
  [20:54:48.452] }
  [20:54:48.469] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:48.481] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.481] - Validating connection of ClusterFuture
  [20:54:48.481] - received message: FutureResult
  [20:54:48.482] - Received FutureResult
  [20:54:48.482] - Erased future from FutureRegistry
  [20:54:48.482] result() for ClusterFuture ...
  [20:54:48.483] - result already collected: FutureResult
  [20:54:48.483] result() for ClusterFuture ... done
  [20:54:48.483] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:48.484] result() for ClusterFuture ...
  [20:54:48.484] - result already collected: FutureResult
  [20:54:48.484] result() for ClusterFuture ... done
  [20:54:48.485] result() for ClusterFuture ...
  [20:54:48.485] - result already collected: FutureResult
  [20:54:48.485] result() for ClusterFuture ... done
  [20:54:48.487] ClusterFuture started
  [20:54:48.493] getGlobalsAndPackages() ...
  [20:54:48.493] Searching for globals...
  [20:54:48.501] - globals found: [1] '{'
  [20:54:48.501] Searching for globals ... DONE
  [20:54:48.526] Resolving globals: FALSE
  [20:54:48.527] 
  [20:54:48.527] 
  [20:54:48.528] getGlobalsAndPackages() ... DONE
  [20:54:48.532] Packages needed by the future expression (n = 0): <none>
  [20:54:48.532] Packages needed by future strategies (n = 0): <none>
  [20:54:48.537] {
  [20:54:48.537]     {
  [20:54:48.537]         ...future.startTime <- base::Sys.time()
  [20:54:48.537]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.537]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.537]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.537]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.537]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.537]         {
  [20:54:48.537]             {
  [20:54:48.537]                 has_future <- base::requireNamespace("future", 
  [20:54:48.537]                   quietly = TRUE)
  [20:54:48.537]                 version <- if (has_future) 
  [20:54:48.537]                   utils::packageVersion("future")
  [20:54:48.537]                 else NULL
  [20:54:48.537]                 if (!has_future || version < "1.8.0") {
  [20:54:48.537]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.537]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.537]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.537]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.537]                       "release", "version")], collapse = " "), 
  [20:54:48.537]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.537]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.537]                     info)
  [20:54:48.537]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.537]                   if (!has_future) {
  [20:54:48.537]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.537]                       info)
  [20:54:48.537]                   }
  [20:54:48.537]                   else {
  [20:54:48.537]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.537]                       info, version)
  [20:54:48.537]                   }
  [20:54:48.537]                   base::stop(msg)
  [20:54:48.537]                 }
  [20:54:48.537]             }
  [20:54:48.537]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.537]         }
  [20:54:48.537]     }
  [20:54:48.537]     if (base::is.na(TRUE)) {
  [20:54:48.537]     }
  [20:54:48.537]     else {
  [20:54:48.537]         if (TRUE) {
  [20:54:48.537]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.537]                 open = "w")
  [20:54:48.537]         }
  [20:54:48.537]         else {
  [20:54:48.537]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.537]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.537]         }
  [20:54:48.537]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.537]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.537]             base::sink(type = "output", split = FALSE)
  [20:54:48.537]             base::close(...future.stdout)
  [20:54:48.537]         }, add = TRUE)
  [20:54:48.537]     }
  [20:54:48.537]     ...future.frame <- base::sys.nframe()
  [20:54:48.537]     ...future.conditions <- base::list()
  [20:54:48.537]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.537]     ...future.result <- base::tryCatch({
  [20:54:48.537]         base::withCallingHandlers({
  [20:54:48.537]             ...future.value <- base::withVisible(base::local({
  [20:54:48.537]                 ...future.sendCondition <- local({
  [20:54:48.537]                   sendCondition <- NULL
  [20:54:48.537]                   function(frame = 1L) {
  [20:54:48.537]                     if (is.function(sendCondition)) 
  [20:54:48.537]                       return(sendCondition)
  [20:54:48.537]                     ns <- getNamespace("parallel")
  [20:54:48.537]                     if (exists("sendData", mode = "function", 
  [20:54:48.537]                       envir = ns)) {
  [20:54:48.537]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.537]                         envir = ns)
  [20:54:48.537]                       envir <- sys.frame(frame)
  [20:54:48.537]                       master <- NULL
  [20:54:48.537]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.537]                         !identical(envir, emptyenv())) {
  [20:54:48.537]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.537]                           inherits = FALSE)) {
  [20:54:48.537]                           master <- get("master", mode = "list", 
  [20:54:48.537]                             envir = envir, inherits = FALSE)
  [20:54:48.537]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.537]                             sendCondition <<- function(cond) {
  [20:54:48.537]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.537]                                 success = TRUE)
  [20:54:48.537]                               parallel_sendData(master, data)
  [20:54:48.537]                             }
  [20:54:48.537]                             return(sendCondition)
  [20:54:48.537]                           }
  [20:54:48.537]                         }
  [20:54:48.537]                         frame <- frame + 1L
  [20:54:48.537]                         envir <- sys.frame(frame)
  [20:54:48.537]                       }
  [20:54:48.537]                     }
  [20:54:48.537]                     sendCondition <<- function(cond) NULL
  [20:54:48.537]                   }
  [20:54:48.537]                 })
  [20:54:48.537]                 withCallingHandlers({
  [20:54:48.537]                   {
  [20:54:48.537]                     4
  [20:54:48.537]                   }
  [20:54:48.537]                 }, immediateCondition = function(cond) {
  [20:54:48.537]                   sendCondition <- ...future.sendCondition()
  [20:54:48.537]                   sendCondition(cond)
  [20:54:48.537]                   muffleCondition <- function (cond) 
  [20:54:48.537]                   {
  [20:54:48.537]                     inherits <- base::inherits
  [20:54:48.537]                     invokeRestart <- base::invokeRestart
  [20:54:48.537]                     muffled <- FALSE
  [20:54:48.537]                     if (inherits(cond, "message")) {
  [20:54:48.537]                       invokeRestart("muffleMessage")
  [20:54:48.537]                       muffled <- TRUE
  [20:54:48.537]                     }
  [20:54:48.537]                     else if (inherits(cond, "warning")) {
  [20:54:48.537]                       invokeRestart("muffleWarning")
  [20:54:48.537]                       muffled <- TRUE
  [20:54:48.537]                     }
  [20:54:48.537]                     else if (inherits(cond, "condition")) {
  [20:54:48.537]                       computeRestarts <- base::computeRestarts
  [20:54:48.537]                       grepl <- base::grepl
  [20:54:48.537]                       is.null <- base::is.null
  [20:54:48.537]                       restarts <- computeRestarts(cond)
  [20:54:48.537]                       for (restart in restarts) {
  [20:54:48.537]                         name <- restart$name
  [20:54:48.537]                         if (is.null(name)) 
  [20:54:48.537]                           next
  [20:54:48.537]                         if (!grepl("^muffle", name)) 
  [20:54:48.537]                           next
  [20:54:48.537]                         invokeRestart(restart)
  [20:54:48.537]                         muffled <- TRUE
  [20:54:48.537]                         break
  [20:54:48.537]                       }
  [20:54:48.537]                     }
  [20:54:48.537]                     invisible(muffled)
  [20:54:48.537]                   }
  [20:54:48.537]                   muffleCondition(cond)
  [20:54:48.537]                 })
  [20:54:48.537]             }))
  [20:54:48.537]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.537]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.537]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.537]                 version = "1.8")
  [20:54:48.537]         }, condition = base::local({
  [20:54:48.537]             c <- base::c
  [20:54:48.537]             inherits <- base::inherits
  [20:54:48.537]             invokeRestart <- base::invokeRestart
  [20:54:48.537]             length <- base::length
  [20:54:48.537]             list <- base::list
  [20:54:48.537]             seq.int <- base::seq.int
  [20:54:48.537]             signalCondition <- base::signalCondition
  [20:54:48.537]             sys.calls <- base::sys.calls
  [20:54:48.537]             Sys.time <- base::Sys.time
  [20:54:48.537]             `[[` <- base::`[[`
  [20:54:48.537]             `+` <- base::`+`
  [20:54:48.537]             `<<-` <- base::`<<-`
  [20:54:48.537]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.537]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.537]                   3L)]
  [20:54:48.537]             }
  [20:54:48.537]             function(cond) {
  [20:54:48.537]                 if (inherits(cond, "error")) {
  [20:54:48.537]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.537]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.537]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.537]                   signalCondition(cond)
  [20:54:48.537]                 }
  [20:54:48.537]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.537]                 ))) {
  [20:54:48.537]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.537]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.537]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.537]                   if (!signal) {
  [20:54:48.537]                     muffleCondition <- function (cond) 
  [20:54:48.537]                     {
  [20:54:48.537]                       inherits <- base::inherits
  [20:54:48.537]                       invokeRestart <- base::invokeRestart
  [20:54:48.537]                       muffled <- FALSE
  [20:54:48.537]                       if (inherits(cond, "message")) {
  [20:54:48.537]                         invokeRestart("muffleMessage")
  [20:54:48.537]                         muffled <- TRUE
  [20:54:48.537]                       }
  [20:54:48.537]                       else if (inherits(cond, "warning")) {
  [20:54:48.537]                         invokeRestart("muffleWarning")
  [20:54:48.537]                         muffled <- TRUE
  [20:54:48.537]                       }
  [20:54:48.537]                       else if (inherits(cond, "condition")) {
  [20:54:48.537]                         computeRestarts <- base::computeRestarts
  [20:54:48.537]                         grepl <- base::grepl
  [20:54:48.537]                         is.null <- base::is.null
  [20:54:48.537]                         restarts <- computeRestarts(cond)
  [20:54:48.537]                         for (restart in restarts) {
  [20:54:48.537]                           name <- restart$name
  [20:54:48.537]                           if (is.null(name)) 
  [20:54:48.537]                             next
  [20:54:48.537]                           if (!grepl("^muffle", name)) 
  [20:54:48.537]                             next
  [20:54:48.537]                           invokeRestart(restart)
  [20:54:48.537]                           muffled <- TRUE
  [20:54:48.537]                           break
  [20:54:48.537]                         }
  [20:54:48.537]                       }
  [20:54:48.537]                       invisible(muffled)
  [20:54:48.537]                     }
  [20:54:48.537]                     muffleCondition(cond)
  [20:54:48.537]                   }
  [20:54:48.537]                 }
  [20:54:48.537]             }
  [20:54:48.537]         }))
  [20:54:48.537]     }, error = function(ex) {
  [20:54:48.537]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.537]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.537]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.537]     }, finally = {
  [20:54:48.537]         {
  [20:54:48.537]             NULL
  [20:54:48.537]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.537]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.537]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.537]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.537]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.537]                 ...) 
  [20:54:48.537]             {
  [20:54:48.537]                 if (substitute) 
  [20:54:48.537]                   expr <- substitute(expr)
  [20:54:48.537]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.537]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.537]                   globals = globals, persistent = persistent, 
  [20:54:48.537]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.537]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.537]                   label = label, ...)
  [20:54:48.537]                 if (!future$lazy) 
  [20:54:48.537]                   future <- run(future)
  [20:54:48.537]                 invisible(future)
  [20:54:48.537]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.537]         }
  [20:54:48.537]         base::options(...future.oldOptions)
  [20:54:48.537]     })
  [20:54:48.537]     Sys.time
  [20:54:48.537]     if (base::is.na(TRUE)) {
  [20:54:48.537]     }
  [20:54:48.537]     else {
  [20:54:48.537]         base::sink(type = "output", split = FALSE)
  [20:54:48.537]         if (TRUE) {
  [20:54:48.537]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.537]         }
  [20:54:48.537]         else {
  [20:54:48.537]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.537]         }
  [20:54:48.537]         base::close(...future.stdout)
  [20:54:48.537]         ...future.stdout <- NULL
  [20:54:48.537]     }
  [20:54:48.537]     ...future.result$conditions <- ...future.conditions
  [20:54:48.537]     ...future.result
  [20:54:48.537] }
  [20:54:48.541] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:48.570] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.570] - Validating connection of ClusterFuture
  [20:54:48.571] - received message: FutureResult
  [20:54:48.571] - Received FutureResult
  [20:54:48.572] - Erased future from FutureRegistry
  [20:54:48.572] result() for ClusterFuture ...
  [20:54:48.572] - result already collected: FutureResult
  [20:54:48.573] result() for ClusterFuture ... done
  [20:54:48.573] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:48.573] result() for ClusterFuture ...
  [20:54:48.574] - result already collected: FutureResult
  [20:54:48.574] result() for ClusterFuture ... done
  [20:54:48.574] result() for ClusterFuture ...
  [20:54:48.575] - result already collected: FutureResult
  [20:54:48.575] result() for ClusterFuture ... done
  [20:54:48.577] ClusterFuture started
  <environment: 0x556b0feabb40> 
  <environment: 0x556b1058dd58> 
  [20:54:48.650] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.651] - Validating connection of ClusterFuture
  [20:54:48.652] - received message: FutureResult
  [20:54:48.652] - Received FutureResult
  [20:54:48.652] - Erased future from FutureRegistry
  [20:54:48.653] result() for ClusterFuture ...
  [20:54:48.653] - result already collected: FutureResult
  [20:54:48.653] result() for ClusterFuture ... done
  [20:54:48.654] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:48.657] resolve() on environment ...
  [20:54:48.657]  recursive: 0
  [20:54:48.659]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:48.659] signalConditionsASAP(numeric, pos=1) ...
  [20:54:48.659] - nx: 4
  [20:54:48.660] - relay: TRUE
  [20:54:48.660] - stdout: TRUE
  [20:54:48.660] - signal: TRUE
  [20:54:48.660] - resignal: FALSE
  [20:54:48.661] - force: TRUE
  [20:54:48.661] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:48.661] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:48.661]  - until=2
  [20:54:48.662]  - relaying element #2
  [20:54:48.662] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:48.662] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:48.663] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:48.663]  length: 3 (resolved future 1)
  [20:54:48.663] Future #2
  [20:54:48.664] result() for ClusterFuture ...
  [20:54:48.664] - result already collected: FutureResult
  [20:54:48.664] result() for ClusterFuture ... done
  [20:54:48.664] result() for ClusterFuture ...
  [20:54:48.665] - result already collected: FutureResult
  [20:54:48.665] result() for ClusterFuture ... done
  [20:54:48.665] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:48.666] - nx: 4
  [20:54:48.666] - relay: TRUE
  [20:54:48.666] - stdout: TRUE
  [20:54:48.667] - signal: TRUE
  [20:54:48.667] - resignal: FALSE
  [20:54:48.667] - force: TRUE
  [20:54:48.667] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:48.668] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:48.668]  - until=2
  [20:54:48.668]  - relaying element #2
  [20:54:48.669] result() for ClusterFuture ...
  [20:54:48.669] - result already collected: FutureResult
  [20:54:48.669] result() for ClusterFuture ... done
  [20:54:48.669] result() for ClusterFuture ...
  [20:54:48.670] - result already collected: FutureResult
  [20:54:48.670] result() for ClusterFuture ... done
  [20:54:48.670] result() for ClusterFuture ...
  [20:54:48.671] - result already collected: FutureResult
  [20:54:48.671] result() for ClusterFuture ... done
  [20:54:48.671] result() for ClusterFuture ...
  [20:54:48.672] - result already collected: FutureResult
  [20:54:48.672] result() for ClusterFuture ... done
  [20:54:48.672] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:48.673] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:48.673] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:48.673]  length: 2 (resolved future 2)
  [20:54:48.673] Future #3
  [20:54:48.674] result() for ClusterFuture ...
  [20:54:48.674] - result already collected: FutureResult
  [20:54:48.674] result() for ClusterFuture ... done
  [20:54:48.675] result() for ClusterFuture ...
  [20:54:48.675] - result already collected: FutureResult
  [20:54:48.675] result() for ClusterFuture ... done
  [20:54:48.676] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:48.676] - nx: 4
  [20:54:48.676] - relay: TRUE
  [20:54:48.676] - stdout: TRUE
  [20:54:48.677] - signal: TRUE
  [20:54:48.677] - resignal: FALSE
  [20:54:48.677] - force: TRUE
  [20:54:48.677] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:48.694] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:48.694]  - until=3
  [20:54:48.695]  - relaying element #3
  [20:54:48.695] result() for ClusterFuture ...
  [20:54:48.695] - result already collected: FutureResult
  [20:54:48.696] result() for ClusterFuture ... done
  [20:54:48.696] result() for ClusterFuture ...
  [20:54:48.696] - result already collected: FutureResult
  [20:54:48.697] result() for ClusterFuture ... done
  [20:54:48.697] result() for ClusterFuture ...
  [20:54:48.697] - result already collected: FutureResult
  [20:54:48.698] result() for ClusterFuture ... done
  [20:54:48.698] result() for ClusterFuture ...
  [20:54:48.705] - result already collected: FutureResult
  [20:54:48.705] result() for ClusterFuture ... done
  [20:54:48.705] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:48.706] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:48.706] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:48.706]  length: 1 (resolved future 3)
  [20:54:48.707] Future #4
  [20:54:48.707] result() for ClusterFuture ...
  [20:54:48.707] - result already collected: FutureResult
  [20:54:48.708] result() for ClusterFuture ... done
  [20:54:48.708] result() for ClusterFuture ...
  [20:54:48.708] - result already collected: FutureResult
  [20:54:48.709] result() for ClusterFuture ... done
  [20:54:48.709] signalConditionsASAP(ClusterFuture, pos=4) ...
  [20:54:48.709] - nx: 4
  [20:54:48.710] - relay: TRUE
  [20:54:48.717] - stdout: TRUE
  [20:54:48.717] - signal: TRUE
  [20:54:48.717] - resignal: FALSE
  [20:54:48.717] - force: TRUE
  [20:54:48.718] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:48.718] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:48.718]  - until=4
  [20:54:48.719]  - relaying element #4
  [20:54:48.719] result() for ClusterFuture ...
  [20:54:48.719] - result already collected: FutureResult
  [20:54:48.720] result() for ClusterFuture ... done
  [20:54:48.720] result() for ClusterFuture ...
  [20:54:48.720] - result already collected: FutureResult
  [20:54:48.721] result() for ClusterFuture ... done
  [20:54:48.721] result() for ClusterFuture ...
  [20:54:48.721] - result already collected: FutureResult
  [20:54:48.722] result() for ClusterFuture ... done
  [20:54:48.722] result() for ClusterFuture ...
  [20:54:48.722] - result already collected: FutureResult
  [20:54:48.723] result() for ClusterFuture ... done
  [20:54:48.723] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:48.723] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:48.724] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [20:54:48.724]  length: 0 (resolved future 4)
  [20:54:48.724] Relaying remaining futures
  [20:54:48.724] signalConditionsASAP(NULL, pos=0) ...
  [20:54:48.725] - nx: 4
  [20:54:48.725] - relay: TRUE
  [20:54:48.725] - stdout: TRUE
  [20:54:48.726] - signal: TRUE
  [20:54:48.726] - resignal: FALSE
  [20:54:48.726] - force: TRUE
  [20:54:48.726] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:48.727] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:48.727] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:48.727] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:48.728] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:48.728] resolve() on environment ... DONE
  [20:54:48.728] result() for ClusterFuture ...
  [20:54:48.729] - result already collected: FutureResult
  [20:54:48.729] result() for ClusterFuture ... done
  [20:54:48.729] result() for ClusterFuture ...
  [20:54:48.729] - result already collected: FutureResult
  [20:54:48.730] result() for ClusterFuture ... done
  [20:54:48.730] result() for ClusterFuture ...
  [20:54:48.730] - result already collected: FutureResult
  [20:54:48.731] result() for ClusterFuture ... done
  [20:54:48.731] result() for ClusterFuture ...
  [20:54:48.731] - result already collected: FutureResult
  [20:54:48.732] result() for ClusterFuture ... done
  [20:54:48.732] result() for ClusterFuture ...
  [20:54:48.732] - result already collected: FutureResult
  [20:54:48.733] result() for ClusterFuture ... done
  [20:54:48.733] result() for ClusterFuture ...
  [20:54:48.733] - result already collected: FutureResult
  [20:54:48.733] result() for ClusterFuture ... done
  <environment: 0x556b112edb78> 
  Dimensions: c(1, 6)
  [20:54:48.741] getGlobalsAndPackages() ...
  [20:54:48.741] Searching for globals...
  [20:54:48.742] 
  [20:54:48.743] Searching for globals ... DONE
  [20:54:48.743] - globals: [0] <none>
  [20:54:48.743] getGlobalsAndPackages() ... DONE
  [20:54:48.747] Packages needed by the future expression (n = 0): <none>
  [20:54:48.748] Packages needed by future strategies (n = 0): <none>
  [20:54:48.753] {
  [20:54:48.753]     {
  [20:54:48.753]         ...future.startTime <- base::Sys.time()
  [20:54:48.753]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.753]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.753]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.753]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.753]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.753]         {
  [20:54:48.753]             {
  [20:54:48.753]                 has_future <- base::requireNamespace("future", 
  [20:54:48.753]                   quietly = TRUE)
  [20:54:48.753]                 version <- if (has_future) 
  [20:54:48.753]                   utils::packageVersion("future")
  [20:54:48.753]                 else NULL
  [20:54:48.753]                 if (!has_future || version < "1.8.0") {
  [20:54:48.753]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.753]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.753]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.753]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.753]                       "release", "version")], collapse = " "), 
  [20:54:48.753]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.753]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.753]                     info)
  [20:54:48.753]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.753]                   if (!has_future) {
  [20:54:48.753]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.753]                       info)
  [20:54:48.753]                   }
  [20:54:48.753]                   else {
  [20:54:48.753]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.753]                       info, version)
  [20:54:48.753]                   }
  [20:54:48.753]                   base::stop(msg)
  [20:54:48.753]                 }
  [20:54:48.753]             }
  [20:54:48.753]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.753]         }
  [20:54:48.753]     }
  [20:54:48.753]     if (base::is.na(TRUE)) {
  [20:54:48.753]     }
  [20:54:48.753]     else {
  [20:54:48.753]         if (TRUE) {
  [20:54:48.753]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.753]                 open = "w")
  [20:54:48.753]         }
  [20:54:48.753]         else {
  [20:54:48.753]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.753]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.753]         }
  [20:54:48.753]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.753]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.753]             base::sink(type = "output", split = FALSE)
  [20:54:48.753]             base::close(...future.stdout)
  [20:54:48.753]         }, add = TRUE)
  [20:54:48.753]     }
  [20:54:48.753]     ...future.frame <- base::sys.nframe()
  [20:54:48.753]     ...future.conditions <- base::list()
  [20:54:48.753]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.753]     ...future.result <- base::tryCatch({
  [20:54:48.753]         base::withCallingHandlers({
  [20:54:48.753]             ...future.value <- base::withVisible(base::local({
  [20:54:48.753]                 ...future.sendCondition <- local({
  [20:54:48.753]                   sendCondition <- NULL
  [20:54:48.753]                   function(frame = 1L) {
  [20:54:48.753]                     if (is.function(sendCondition)) 
  [20:54:48.753]                       return(sendCondition)
  [20:54:48.753]                     ns <- getNamespace("parallel")
  [20:54:48.753]                     if (exists("sendData", mode = "function", 
  [20:54:48.753]                       envir = ns)) {
  [20:54:48.753]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.753]                         envir = ns)
  [20:54:48.753]                       envir <- sys.frame(frame)
  [20:54:48.753]                       master <- NULL
  [20:54:48.753]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.753]                         !identical(envir, emptyenv())) {
  [20:54:48.753]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.753]                           inherits = FALSE)) {
  [20:54:48.753]                           master <- get("master", mode = "list", 
  [20:54:48.753]                             envir = envir, inherits = FALSE)
  [20:54:48.753]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.753]                             sendCondition <<- function(cond) {
  [20:54:48.753]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.753]                                 success = TRUE)
  [20:54:48.753]                               parallel_sendData(master, data)
  [20:54:48.753]                             }
  [20:54:48.753]                             return(sendCondition)
  [20:54:48.753]                           }
  [20:54:48.753]                         }
  [20:54:48.753]                         frame <- frame + 1L
  [20:54:48.753]                         envir <- sys.frame(frame)
  [20:54:48.753]                       }
  [20:54:48.753]                     }
  [20:54:48.753]                     sendCondition <<- function(cond) NULL
  [20:54:48.753]                   }
  [20:54:48.753]                 })
  [20:54:48.753]                 withCallingHandlers({
  [20:54:48.753]                   2
  [20:54:48.753]                 }, immediateCondition = function(cond) {
  [20:54:48.753]                   sendCondition <- ...future.sendCondition()
  [20:54:48.753]                   sendCondition(cond)
  [20:54:48.753]                   muffleCondition <- function (cond) 
  [20:54:48.753]                   {
  [20:54:48.753]                     inherits <- base::inherits
  [20:54:48.753]                     invokeRestart <- base::invokeRestart
  [20:54:48.753]                     muffled <- FALSE
  [20:54:48.753]                     if (inherits(cond, "message")) {
  [20:54:48.753]                       invokeRestart("muffleMessage")
  [20:54:48.753]                       muffled <- TRUE
  [20:54:48.753]                     }
  [20:54:48.753]                     else if (inherits(cond, "warning")) {
  [20:54:48.753]                       invokeRestart("muffleWarning")
  [20:54:48.753]                       muffled <- TRUE
  [20:54:48.753]                     }
  [20:54:48.753]                     else if (inherits(cond, "condition")) {
  [20:54:48.753]                       computeRestarts <- base::computeRestarts
  [20:54:48.753]                       grepl <- base::grepl
  [20:54:48.753]                       is.null <- base::is.null
  [20:54:48.753]                       restarts <- computeRestarts(cond)
  [20:54:48.753]                       for (restart in restarts) {
  [20:54:48.753]                         name <- restart$name
  [20:54:48.753]                         if (is.null(name)) 
  [20:54:48.753]                           next
  [20:54:48.753]                         if (!grepl("^muffle", name)) 
  [20:54:48.753]                           next
  [20:54:48.753]                         invokeRestart(restart)
  [20:54:48.753]                         muffled <- TRUE
  [20:54:48.753]                         break
  [20:54:48.753]                       }
  [20:54:48.753]                     }
  [20:54:48.753]                     invisible(muffled)
  [20:54:48.753]                   }
  [20:54:48.753]                   muffleCondition(cond)
  [20:54:48.753]                 })
  [20:54:48.753]             }))
  [20:54:48.753]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.753]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.753]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.753]                 version = "1.8")
  [20:54:48.753]         }, condition = base::local({
  [20:54:48.753]             c <- base::c
  [20:54:48.753]             inherits <- base::inherits
  [20:54:48.753]             invokeRestart <- base::invokeRestart
  [20:54:48.753]             length <- base::length
  [20:54:48.753]             list <- base::list
  [20:54:48.753]             seq.int <- base::seq.int
  [20:54:48.753]             signalCondition <- base::signalCondition
  [20:54:48.753]             sys.calls <- base::sys.calls
  [20:54:48.753]             Sys.time <- base::Sys.time
  [20:54:48.753]             `[[` <- base::`[[`
  [20:54:48.753]             `+` <- base::`+`
  [20:54:48.753]             `<<-` <- base::`<<-`
  [20:54:48.753]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.753]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.753]                   3L)]
  [20:54:48.753]             }
  [20:54:48.753]             function(cond) {
  [20:54:48.753]                 if (inherits(cond, "error")) {
  [20:54:48.753]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.753]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.753]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.753]                   signalCondition(cond)
  [20:54:48.753]                 }
  [20:54:48.753]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.753]                 ))) {
  [20:54:48.753]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.753]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.753]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.753]                   if (!signal) {
  [20:54:48.753]                     muffleCondition <- function (cond) 
  [20:54:48.753]                     {
  [20:54:48.753]                       inherits <- base::inherits
  [20:54:48.753]                       invokeRestart <- base::invokeRestart
  [20:54:48.753]                       muffled <- FALSE
  [20:54:48.753]                       if (inherits(cond, "message")) {
  [20:54:48.753]                         invokeRestart("muffleMessage")
  [20:54:48.753]                         muffled <- TRUE
  [20:54:48.753]                       }
  [20:54:48.753]                       else if (inherits(cond, "warning")) {
  [20:54:48.753]                         invokeRestart("muffleWarning")
  [20:54:48.753]                         muffled <- TRUE
  [20:54:48.753]                       }
  [20:54:48.753]                       else if (inherits(cond, "condition")) {
  [20:54:48.753]                         computeRestarts <- base::computeRestarts
  [20:54:48.753]                         grepl <- base::grepl
  [20:54:48.753]                         is.null <- base::is.null
  [20:54:48.753]                         restarts <- computeRestarts(cond)
  [20:54:48.753]                         for (restart in restarts) {
  [20:54:48.753]                           name <- restart$name
  [20:54:48.753]                           if (is.null(name)) 
  [20:54:48.753]                             next
  [20:54:48.753]                           if (!grepl("^muffle", name)) 
  [20:54:48.753]                             next
  [20:54:48.753]                           invokeRestart(restart)
  [20:54:48.753]                           muffled <- TRUE
  [20:54:48.753]                           break
  [20:54:48.753]                         }
  [20:54:48.753]                       }
  [20:54:48.753]                       invisible(muffled)
  [20:54:48.753]                     }
  [20:54:48.753]                     muffleCondition(cond)
  [20:54:48.753]                   }
  [20:54:48.753]                 }
  [20:54:48.753]             }
  [20:54:48.753]         }))
  [20:54:48.753]     }, error = function(ex) {
  [20:54:48.753]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.753]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.753]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.753]     }, finally = {
  [20:54:48.753]         {
  [20:54:48.753]             NULL
  [20:54:48.753]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.753]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.753]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.753]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.753]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.753]                 ...) 
  [20:54:48.753]             {
  [20:54:48.753]                 if (substitute) 
  [20:54:48.753]                   expr <- substitute(expr)
  [20:54:48.753]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.753]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.753]                   globals = globals, persistent = persistent, 
  [20:54:48.753]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.753]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.753]                   label = label, ...)
  [20:54:48.753]                 if (!future$lazy) 
  [20:54:48.753]                   future <- run(future)
  [20:54:48.753]                 invisible(future)
  [20:54:48.753]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.753]         }
  [20:54:48.753]         base::options(...future.oldOptions)
  [20:54:48.753]     })
  [20:54:48.753]     Sys.time
  [20:54:48.753]     if (base::is.na(TRUE)) {
  [20:54:48.753]     }
  [20:54:48.753]     else {
  [20:54:48.753]         base::sink(type = "output", split = FALSE)
  [20:54:48.753]         if (TRUE) {
  [20:54:48.753]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.753]         }
  [20:54:48.753]         else {
  [20:54:48.753]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.753]         }
  [20:54:48.753]         base::close(...future.stdout)
  [20:54:48.753]         ...future.stdout <- NULL
  [20:54:48.753]     }
  [20:54:48.753]     ...future.result$conditions <- ...future.conditions
  [20:54:48.753]     ...future.result
  [20:54:48.753] }
  [20:54:48.760] ClusterFuture started
  [20:54:48.766] getGlobalsAndPackages() ...
  [20:54:48.766] Searching for globals...
  [20:54:48.767] 
  [20:54:48.768] Searching for globals ... DONE
  [20:54:48.768] - globals: [0] <none>
  [20:54:48.768] getGlobalsAndPackages() ... DONE
  [20:54:48.791] Packages needed by the future expression (n = 0): <none>
  [20:54:48.792] Packages needed by future strategies (n = 0): <none>
  [20:54:48.797] {
  [20:54:48.797]     {
  [20:54:48.797]         ...future.startTime <- base::Sys.time()
  [20:54:48.797]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.797]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.797]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.797]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.797]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.797]         {
  [20:54:48.797]             {
  [20:54:48.797]                 has_future <- base::requireNamespace("future", 
  [20:54:48.797]                   quietly = TRUE)
  [20:54:48.797]                 version <- if (has_future) 
  [20:54:48.797]                   utils::packageVersion("future")
  [20:54:48.797]                 else NULL
  [20:54:48.797]                 if (!has_future || version < "1.8.0") {
  [20:54:48.797]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.797]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.797]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.797]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.797]                       "release", "version")], collapse = " "), 
  [20:54:48.797]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.797]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.797]                     info)
  [20:54:48.797]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.797]                   if (!has_future) {
  [20:54:48.797]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.797]                       info)
  [20:54:48.797]                   }
  [20:54:48.797]                   else {
  [20:54:48.797]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.797]                       info, version)
  [20:54:48.797]                   }
  [20:54:48.797]                   base::stop(msg)
  [20:54:48.797]                 }
  [20:54:48.797]             }
  [20:54:48.797]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.797]         }
  [20:54:48.797]     }
  [20:54:48.797]     if (base::is.na(TRUE)) {
  [20:54:48.797]     }
  [20:54:48.797]     else {
  [20:54:48.797]         if (TRUE) {
  [20:54:48.797]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.797]                 open = "w")
  [20:54:48.797]         }
  [20:54:48.797]         else {
  [20:54:48.797]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.797]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.797]         }
  [20:54:48.797]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.797]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.797]             base::sink(type = "output", split = FALSE)
  [20:54:48.797]             base::close(...future.stdout)
  [20:54:48.797]         }, add = TRUE)
  [20:54:48.797]     }
  [20:54:48.797]     ...future.frame <- base::sys.nframe()
  [20:54:48.797]     ...future.conditions <- base::list()
  [20:54:48.797]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.797]     ...future.result <- base::tryCatch({
  [20:54:48.797]         base::withCallingHandlers({
  [20:54:48.797]             ...future.value <- base::withVisible(base::local({
  [20:54:48.797]                 ...future.sendCondition <- local({
  [20:54:48.797]                   sendCondition <- NULL
  [20:54:48.797]                   function(frame = 1L) {
  [20:54:48.797]                     if (is.function(sendCondition)) 
  [20:54:48.797]                       return(sendCondition)
  [20:54:48.797]                     ns <- getNamespace("parallel")
  [20:54:48.797]                     if (exists("sendData", mode = "function", 
  [20:54:48.797]                       envir = ns)) {
  [20:54:48.797]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.797]                         envir = ns)
  [20:54:48.797]                       envir <- sys.frame(frame)
  [20:54:48.797]                       master <- NULL
  [20:54:48.797]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.797]                         !identical(envir, emptyenv())) {
  [20:54:48.797]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.797]                           inherits = FALSE)) {
  [20:54:48.797]                           master <- get("master", mode = "list", 
  [20:54:48.797]                             envir = envir, inherits = FALSE)
  [20:54:48.797]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.797]                             sendCondition <<- function(cond) {
  [20:54:48.797]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.797]                                 success = TRUE)
  [20:54:48.797]                               parallel_sendData(master, data)
  [20:54:48.797]                             }
  [20:54:48.797]                             return(sendCondition)
  [20:54:48.797]                           }
  [20:54:48.797]                         }
  [20:54:48.797]                         frame <- frame + 1L
  [20:54:48.797]                         envir <- sys.frame(frame)
  [20:54:48.797]                       }
  [20:54:48.797]                     }
  [20:54:48.797]                     sendCondition <<- function(cond) NULL
  [20:54:48.797]                   }
  [20:54:48.797]                 })
  [20:54:48.797]                 withCallingHandlers({
  [20:54:48.797]                   NULL
  [20:54:48.797]                 }, immediateCondition = function(cond) {
  [20:54:48.797]                   sendCondition <- ...future.sendCondition()
  [20:54:48.797]                   sendCondition(cond)
  [20:54:48.797]                   muffleCondition <- function (cond) 
  [20:54:48.797]                   {
  [20:54:48.797]                     inherits <- base::inherits
  [20:54:48.797]                     invokeRestart <- base::invokeRestart
  [20:54:48.797]                     muffled <- FALSE
  [20:54:48.797]                     if (inherits(cond, "message")) {
  [20:54:48.797]                       invokeRestart("muffleMessage")
  [20:54:48.797]                       muffled <- TRUE
  [20:54:48.797]                     }
  [20:54:48.797]                     else if (inherits(cond, "warning")) {
  [20:54:48.797]                       invokeRestart("muffleWarning")
  [20:54:48.797]                       muffled <- TRUE
  [20:54:48.797]                     }
  [20:54:48.797]                     else if (inherits(cond, "condition")) {
  [20:54:48.797]                       computeRestarts <- base::computeRestarts
  [20:54:48.797]                       grepl <- base::grepl
  [20:54:48.797]                       is.null <- base::is.null
  [20:54:48.797]                       restarts <- computeRestarts(cond)
  [20:54:48.797]                       for (restart in restarts) {
  [20:54:48.797]                         name <- restart$name
  [20:54:48.797]                         if (is.null(name)) 
  [20:54:48.797]                           next
  [20:54:48.797]                         if (!grepl("^muffle", name)) 
  [20:54:48.797]                           next
  [20:54:48.797]                         invokeRestart(restart)
  [20:54:48.797]                         muffled <- TRUE
  [20:54:48.797]                         break
  [20:54:48.797]                       }
  [20:54:48.797]                     }
  [20:54:48.797]                     invisible(muffled)
  [20:54:48.797]                   }
  [20:54:48.797]                   muffleCondition(cond)
  [20:54:48.797]                 })
  [20:54:48.797]             }))
  [20:54:48.797]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.797]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.797]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.797]                 version = "1.8")
  [20:54:48.797]         }, condition = base::local({
  [20:54:48.797]             c <- base::c
  [20:54:48.797]             inherits <- base::inherits
  [20:54:48.797]             invokeRestart <- base::invokeRestart
  [20:54:48.797]             length <- base::length
  [20:54:48.797]             list <- base::list
  [20:54:48.797]             seq.int <- base::seq.int
  [20:54:48.797]             signalCondition <- base::signalCondition
  [20:54:48.797]             sys.calls <- base::sys.calls
  [20:54:48.797]             Sys.time <- base::Sys.time
  [20:54:48.797]             `[[` <- base::`[[`
  [20:54:48.797]             `+` <- base::`+`
  [20:54:48.797]             `<<-` <- base::`<<-`
  [20:54:48.797]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.797]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.797]                   3L)]
  [20:54:48.797]             }
  [20:54:48.797]             function(cond) {
  [20:54:48.797]                 if (inherits(cond, "error")) {
  [20:54:48.797]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.797]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.797]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.797]                   signalCondition(cond)
  [20:54:48.797]                 }
  [20:54:48.797]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.797]                 ))) {
  [20:54:48.797]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.797]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.797]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.797]                   if (!signal) {
  [20:54:48.797]                     muffleCondition <- function (cond) 
  [20:54:48.797]                     {
  [20:54:48.797]                       inherits <- base::inherits
  [20:54:48.797]                       invokeRestart <- base::invokeRestart
  [20:54:48.797]                       muffled <- FALSE
  [20:54:48.797]                       if (inherits(cond, "message")) {
  [20:54:48.797]                         invokeRestart("muffleMessage")
  [20:54:48.797]                         muffled <- TRUE
  [20:54:48.797]                       }
  [20:54:48.797]                       else if (inherits(cond, "warning")) {
  [20:54:48.797]                         invokeRestart("muffleWarning")
  [20:54:48.797]                         muffled <- TRUE
  [20:54:48.797]                       }
  [20:54:48.797]                       else if (inherits(cond, "condition")) {
  [20:54:48.797]                         computeRestarts <- base::computeRestarts
  [20:54:48.797]                         grepl <- base::grepl
  [20:54:48.797]                         is.null <- base::is.null
  [20:54:48.797]                         restarts <- computeRestarts(cond)
  [20:54:48.797]                         for (restart in restarts) {
  [20:54:48.797]                           name <- restart$name
  [20:54:48.797]                           if (is.null(name)) 
  [20:54:48.797]                             next
  [20:54:48.797]                           if (!grepl("^muffle", name)) 
  [20:54:48.797]                             next
  [20:54:48.797]                           invokeRestart(restart)
  [20:54:48.797]                           muffled <- TRUE
  [20:54:48.797]                           break
  [20:54:48.797]                         }
  [20:54:48.797]                       }
  [20:54:48.797]                       invisible(muffled)
  [20:54:48.797]                     }
  [20:54:48.797]                     muffleCondition(cond)
  [20:54:48.797]                   }
  [20:54:48.797]                 }
  [20:54:48.797]             }
  [20:54:48.797]         }))
  [20:54:48.797]     }, error = function(ex) {
  [20:54:48.797]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.797]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.797]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.797]     }, finally = {
  [20:54:48.797]         {
  [20:54:48.797]             NULL
  [20:54:48.797]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.797]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.797]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.797]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.797]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.797]                 ...) 
  [20:54:48.797]             {
  [20:54:48.797]                 if (substitute) 
  [20:54:48.797]                   expr <- substitute(expr)
  [20:54:48.797]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.797]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.797]                   globals = globals, persistent = persistent, 
  [20:54:48.797]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.797]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.797]                   label = label, ...)
  [20:54:48.797]                 if (!future$lazy) 
  [20:54:48.797]                   future <- run(future)
  [20:54:48.797]                 invisible(future)
  [20:54:48.797]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.797]         }
  [20:54:48.797]         base::options(...future.oldOptions)
  [20:54:48.797]     })
  [20:54:48.797]     Sys.time
  [20:54:48.797]     if (base::is.na(TRUE)) {
  [20:54:48.797]     }
  [20:54:48.797]     else {
  [20:54:48.797]         base::sink(type = "output", split = FALSE)
  [20:54:48.797]         if (TRUE) {
  [20:54:48.797]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.797]         }
  [20:54:48.797]         else {
  [20:54:48.797]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.797]         }
  [20:54:48.797]         base::close(...future.stdout)
  [20:54:48.797]         ...future.stdout <- NULL
  [20:54:48.797]     }
  [20:54:48.797]     ...future.result$conditions <- ...future.conditions
  [20:54:48.797]     ...future.result
  [20:54:48.797] }
  [20:54:48.825] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:48.838] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.838] - Validating connection of ClusterFuture
  [20:54:48.839] - received message: FutureResult
  [20:54:48.839] - Received FutureResult
  [20:54:48.839] - Erased future from FutureRegistry
  [20:54:48.840] result() for ClusterFuture ...
  [20:54:48.840] - result already collected: FutureResult
  [20:54:48.840] result() for ClusterFuture ... done
  [20:54:48.841] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:48.841] result() for ClusterFuture ...
  [20:54:48.841] - result already collected: FutureResult
  [20:54:48.842] result() for ClusterFuture ... done
  [20:54:48.842] result() for ClusterFuture ...
  [20:54:48.842] - result already collected: FutureResult
  [20:54:48.843] result() for ClusterFuture ... done
  [20:54:48.859] ClusterFuture started
  [20:54:48.865] getGlobalsAndPackages() ...
  [20:54:48.866] Searching for globals...
  [20:54:48.867] - globals found: [1] '{'
  [20:54:48.868] Searching for globals ... DONE
  [20:54:48.868] Resolving globals: FALSE
  [20:54:48.869] 
  [20:54:48.869] 
  [20:54:48.870] getGlobalsAndPackages() ... DONE
  [20:54:48.873] Packages needed by the future expression (n = 0): <none>
  [20:54:48.890] Packages needed by future strategies (n = 0): <none>
  [20:54:48.895] {
  [20:54:48.895]     {
  [20:54:48.895]         ...future.startTime <- base::Sys.time()
  [20:54:48.895]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:48.895]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:48.895]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:48.895]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:48.895]             future.resolve.recursive = NULL, width = 80L)
  [20:54:48.895]         {
  [20:54:48.895]             {
  [20:54:48.895]                 has_future <- base::requireNamespace("future", 
  [20:54:48.895]                   quietly = TRUE)
  [20:54:48.895]                 version <- if (has_future) 
  [20:54:48.895]                   utils::packageVersion("future")
  [20:54:48.895]                 else NULL
  [20:54:48.895]                 if (!has_future || version < "1.8.0") {
  [20:54:48.895]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:48.895]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:48.895]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:48.895]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:48.895]                       "release", "version")], collapse = " "), 
  [20:54:48.895]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:48.895]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:48.895]                     info)
  [20:54:48.895]                   info <- base::paste(info, collapse = "; ")
  [20:54:48.895]                   if (!has_future) {
  [20:54:48.895]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:48.895]                       info)
  [20:54:48.895]                   }
  [20:54:48.895]                   else {
  [20:54:48.895]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:48.895]                       info, version)
  [20:54:48.895]                   }
  [20:54:48.895]                   base::stop(msg)
  [20:54:48.895]                 }
  [20:54:48.895]             }
  [20:54:48.895]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:48.895]         }
  [20:54:48.895]     }
  [20:54:48.895]     if (base::is.na(TRUE)) {
  [20:54:48.895]     }
  [20:54:48.895]     else {
  [20:54:48.895]         if (TRUE) {
  [20:54:48.895]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:48.895]                 open = "w")
  [20:54:48.895]         }
  [20:54:48.895]         else {
  [20:54:48.895]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:48.895]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:48.895]         }
  [20:54:48.895]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:48.895]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:48.895]             base::sink(type = "output", split = FALSE)
  [20:54:48.895]             base::close(...future.stdout)
  [20:54:48.895]         }, add = TRUE)
  [20:54:48.895]     }
  [20:54:48.895]     ...future.frame <- base::sys.nframe()
  [20:54:48.895]     ...future.conditions <- base::list()
  [20:54:48.895]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:48.895]     ...future.result <- base::tryCatch({
  [20:54:48.895]         base::withCallingHandlers({
  [20:54:48.895]             ...future.value <- base::withVisible(base::local({
  [20:54:48.895]                 ...future.sendCondition <- local({
  [20:54:48.895]                   sendCondition <- NULL
  [20:54:48.895]                   function(frame = 1L) {
  [20:54:48.895]                     if (is.function(sendCondition)) 
  [20:54:48.895]                       return(sendCondition)
  [20:54:48.895]                     ns <- getNamespace("parallel")
  [20:54:48.895]                     if (exists("sendData", mode = "function", 
  [20:54:48.895]                       envir = ns)) {
  [20:54:48.895]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:48.895]                         envir = ns)
  [20:54:48.895]                       envir <- sys.frame(frame)
  [20:54:48.895]                       master <- NULL
  [20:54:48.895]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:48.895]                         !identical(envir, emptyenv())) {
  [20:54:48.895]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:48.895]                           inherits = FALSE)) {
  [20:54:48.895]                           master <- get("master", mode = "list", 
  [20:54:48.895]                             envir = envir, inherits = FALSE)
  [20:54:48.895]                           if (inherits(master, "SOCKnode")) {
  [20:54:48.895]                             sendCondition <<- function(cond) {
  [20:54:48.895]                               data <- list(type = "VALUE", value = cond, 
  [20:54:48.895]                                 success = TRUE)
  [20:54:48.895]                               parallel_sendData(master, data)
  [20:54:48.895]                             }
  [20:54:48.895]                             return(sendCondition)
  [20:54:48.895]                           }
  [20:54:48.895]                         }
  [20:54:48.895]                         frame <- frame + 1L
  [20:54:48.895]                         envir <- sys.frame(frame)
  [20:54:48.895]                       }
  [20:54:48.895]                     }
  [20:54:48.895]                     sendCondition <<- function(cond) NULL
  [20:54:48.895]                   }
  [20:54:48.895]                 })
  [20:54:48.895]                 withCallingHandlers({
  [20:54:48.895]                   {
  [20:54:48.895]                     4
  [20:54:48.895]                   }
  [20:54:48.895]                 }, immediateCondition = function(cond) {
  [20:54:48.895]                   sendCondition <- ...future.sendCondition()
  [20:54:48.895]                   sendCondition(cond)
  [20:54:48.895]                   muffleCondition <- function (cond) 
  [20:54:48.895]                   {
  [20:54:48.895]                     inherits <- base::inherits
  [20:54:48.895]                     invokeRestart <- base::invokeRestart
  [20:54:48.895]                     muffled <- FALSE
  [20:54:48.895]                     if (inherits(cond, "message")) {
  [20:54:48.895]                       invokeRestart("muffleMessage")
  [20:54:48.895]                       muffled <- TRUE
  [20:54:48.895]                     }
  [20:54:48.895]                     else if (inherits(cond, "warning")) {
  [20:54:48.895]                       invokeRestart("muffleWarning")
  [20:54:48.895]                       muffled <- TRUE
  [20:54:48.895]                     }
  [20:54:48.895]                     else if (inherits(cond, "condition")) {
  [20:54:48.895]                       computeRestarts <- base::computeRestarts
  [20:54:48.895]                       grepl <- base::grepl
  [20:54:48.895]                       is.null <- base::is.null
  [20:54:48.895]                       restarts <- computeRestarts(cond)
  [20:54:48.895]                       for (restart in restarts) {
  [20:54:48.895]                         name <- restart$name
  [20:54:48.895]                         if (is.null(name)) 
  [20:54:48.895]                           next
  [20:54:48.895]                         if (!grepl("^muffle", name)) 
  [20:54:48.895]                           next
  [20:54:48.895]                         invokeRestart(restart)
  [20:54:48.895]                         muffled <- TRUE
  [20:54:48.895]                         break
  [20:54:48.895]                       }
  [20:54:48.895]                     }
  [20:54:48.895]                     invisible(muffled)
  [20:54:48.895]                   }
  [20:54:48.895]                   muffleCondition(cond)
  [20:54:48.895]                 })
  [20:54:48.895]             }))
  [20:54:48.895]             future::FutureResult(value = ...future.value$value, 
  [20:54:48.895]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.895]                   ...future.rng), started = ...future.startTime, 
  [20:54:48.895]                 version = "1.8")
  [20:54:48.895]         }, condition = base::local({
  [20:54:48.895]             c <- base::c
  [20:54:48.895]             inherits <- base::inherits
  [20:54:48.895]             invokeRestart <- base::invokeRestart
  [20:54:48.895]             length <- base::length
  [20:54:48.895]             list <- base::list
  [20:54:48.895]             seq.int <- base::seq.int
  [20:54:48.895]             signalCondition <- base::signalCondition
  [20:54:48.895]             sys.calls <- base::sys.calls
  [20:54:48.895]             Sys.time <- base::Sys.time
  [20:54:48.895]             `[[` <- base::`[[`
  [20:54:48.895]             `+` <- base::`+`
  [20:54:48.895]             `<<-` <- base::`<<-`
  [20:54:48.895]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:48.895]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:48.895]                   3L)]
  [20:54:48.895]             }
  [20:54:48.895]             function(cond) {
  [20:54:48.895]                 if (inherits(cond, "error")) {
  [20:54:48.895]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.895]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:48.895]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:48.895]                   signalCondition(cond)
  [20:54:48.895]                 }
  [20:54:48.895]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:48.895]                 ))) {
  [20:54:48.895]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:48.895]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:48.895]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:48.895]                   if (!signal) {
  [20:54:48.895]                     muffleCondition <- function (cond) 
  [20:54:48.895]                     {
  [20:54:48.895]                       inherits <- base::inherits
  [20:54:48.895]                       invokeRestart <- base::invokeRestart
  [20:54:48.895]                       muffled <- FALSE
  [20:54:48.895]                       if (inherits(cond, "message")) {
  [20:54:48.895]                         invokeRestart("muffleMessage")
  [20:54:48.895]                         muffled <- TRUE
  [20:54:48.895]                       }
  [20:54:48.895]                       else if (inherits(cond, "warning")) {
  [20:54:48.895]                         invokeRestart("muffleWarning")
  [20:54:48.895]                         muffled <- TRUE
  [20:54:48.895]                       }
  [20:54:48.895]                       else if (inherits(cond, "condition")) {
  [20:54:48.895]                         computeRestarts <- base::computeRestarts
  [20:54:48.895]                         grepl <- base::grepl
  [20:54:48.895]                         is.null <- base::is.null
  [20:54:48.895]                         restarts <- computeRestarts(cond)
  [20:54:48.895]                         for (restart in restarts) {
  [20:54:48.895]                           name <- restart$name
  [20:54:48.895]                           if (is.null(name)) 
  [20:54:48.895]                             next
  [20:54:48.895]                           if (!grepl("^muffle", name)) 
  [20:54:48.895]                             next
  [20:54:48.895]                           invokeRestart(restart)
  [20:54:48.895]                           muffled <- TRUE
  [20:54:48.895]                           break
  [20:54:48.895]                         }
  [20:54:48.895]                       }
  [20:54:48.895]                       invisible(muffled)
  [20:54:48.895]                     }
  [20:54:48.895]                     muffleCondition(cond)
  [20:54:48.895]                   }
  [20:54:48.895]                 }
  [20:54:48.895]             }
  [20:54:48.895]         }))
  [20:54:48.895]     }, error = function(ex) {
  [20:54:48.895]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:48.895]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:48.895]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:48.895]     }, finally = {
  [20:54:48.895]         {
  [20:54:48.895]             NULL
  [20:54:48.895]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:48.895]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:48.895]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:48.895]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:48.895]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:48.895]                 ...) 
  [20:54:48.895]             {
  [20:54:48.895]                 if (substitute) 
  [20:54:48.895]                   expr <- substitute(expr)
  [20:54:48.895]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:48.895]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:48.895]                   globals = globals, persistent = persistent, 
  [20:54:48.895]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:48.895]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:48.895]                   label = label, ...)
  [20:54:48.895]                 if (!future$lazy) 
  [20:54:48.895]                   future <- run(future)
  [20:54:48.895]                 invisible(future)
  [20:54:48.895]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:48.895]         }
  [20:54:48.895]         base::options(...future.oldOptions)
  [20:54:48.895]     })
  [20:54:48.895]     Sys.time
  [20:54:48.895]     if (base::is.na(TRUE)) {
  [20:54:48.895]     }
  [20:54:48.895]     else {
  [20:54:48.895]         base::sink(type = "output", split = FALSE)
  [20:54:48.895]         if (TRUE) {
  [20:54:48.895]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:48.895]         }
  [20:54:48.895]         else {
  [20:54:48.895]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:48.895]         }
  [20:54:48.895]         base::close(...future.stdout)
  [20:54:48.895]         ...future.stdout <- NULL
  [20:54:48.895]     }
  [20:54:48.895]     ...future.result$conditions <- ...future.conditions
  [20:54:48.895]     ...future.result
  [20:54:48.895] }
  [20:54:48.900] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:48.912] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.913] - Validating connection of ClusterFuture
  [20:54:48.913] - received message: FutureResult
  [20:54:48.914] - Received FutureResult
  [20:54:48.914] - Erased future from FutureRegistry
  [20:54:48.915] result() for ClusterFuture ...
  [20:54:48.915] - result already collected: FutureResult
  [20:54:48.915] result() for ClusterFuture ... done
  [20:54:48.916] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:48.916] result() for ClusterFuture ...
  [20:54:48.916] - result already collected: FutureResult
  [20:54:48.917] result() for ClusterFuture ... done
  [20:54:48.917] result() for ClusterFuture ...
  [20:54:48.918] - result already collected: FutureResult
  [20:54:48.918] result() for ClusterFuture ... done
  [20:54:48.943] ClusterFuture started
  <environment: 0x556b1095f8f0> 
  <environment: 0x556b11349d58> 
  [20:54:48.990] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:48.991] - Validating connection of ClusterFuture
  [20:54:48.991] - received message: FutureResult
  [20:54:48.991] - Received FutureResult
  [20:54:48.992] - Erased future from FutureRegistry
  [20:54:48.992] result() for ClusterFuture ...
  [20:54:48.993] - result already collected: FutureResult
  [20:54:48.993] result() for ClusterFuture ... done
  [20:54:48.993] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:48.997] resolve() on environment ...
  [20:54:48.997]  recursive: 0
  [20:54:48.999]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:48.999] signalConditionsASAP(numeric, pos=1) ...
  [20:54:49.000] - nx: 4
  [20:54:49.000] - relay: TRUE
  [20:54:49.000] - stdout: TRUE
  [20:54:49.000] - signal: TRUE
  [20:54:49.001] - resignal: FALSE
  [20:54:49.001] - force: TRUE
  [20:54:49.001] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.001] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.002]  - until=2
  [20:54:49.002]  - relaying element #2
  [20:54:49.002] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.002] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.003] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:49.003]  length: 3 (resolved future 1)
  [20:54:49.003] Future #2
  [20:54:49.004] result() for ClusterFuture ...
  [20:54:49.004] - result already collected: FutureResult
  [20:54:49.004] result() for ClusterFuture ... done
  [20:54:49.005] result() for ClusterFuture ...
  [20:54:49.005] - result already collected: FutureResult
  [20:54:49.005] result() for ClusterFuture ... done
  [20:54:49.006] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:49.006] - nx: 4
  [20:54:49.006] - relay: TRUE
  [20:54:49.006] - stdout: TRUE
  [20:54:49.007] - signal: TRUE
  [20:54:49.007] - resignal: FALSE
  [20:54:49.007] - force: TRUE
  [20:54:49.008] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.008] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.008]  - until=2
  [20:54:49.008]  - relaying element #2
  [20:54:49.009] result() for ClusterFuture ...
  [20:54:49.009] - result already collected: FutureResult
  [20:54:49.036] result() for ClusterFuture ... done
  [20:54:49.036] result() for ClusterFuture ...
  [20:54:49.037] - result already collected: FutureResult
  [20:54:49.037] result() for ClusterFuture ... done
  [20:54:49.037] result() for ClusterFuture ...
  [20:54:49.046] - result already collected: FutureResult
  [20:54:49.046] result() for ClusterFuture ... done
  [20:54:49.047] result() for ClusterFuture ...
  [20:54:49.047] - result already collected: FutureResult
  [20:54:49.047] result() for ClusterFuture ... done
  [20:54:49.048] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.048] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.048] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:49.049]  length: 2 (resolved future 2)
  [20:54:49.049] Future #3
  [20:54:49.050] result() for ClusterFuture ...
  [20:54:49.050] - result already collected: FutureResult
  [20:54:49.050] result() for ClusterFuture ... done
  [20:54:49.050] result() for ClusterFuture ...
  [20:54:49.051] - result already collected: FutureResult
  [20:54:49.051] result() for ClusterFuture ... done
  [20:54:49.051] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:49.052] - nx: 4
  [20:54:49.052] - relay: TRUE
  [20:54:49.052] - stdout: TRUE
  [20:54:49.052] - signal: TRUE
  [20:54:49.053] - resignal: FALSE
  [20:54:49.053] - force: TRUE
  [20:54:49.053] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.062] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.062]  - until=3
  [20:54:49.062]  - relaying element #3
  [20:54:49.063] result() for ClusterFuture ...
  [20:54:49.063] - result already collected: FutureResult
  [20:54:49.063] result() for ClusterFuture ... done
  [20:54:49.064] result() for ClusterFuture ...
  [20:54:49.064] - result already collected: FutureResult
  [20:54:49.064] result() for ClusterFuture ... done
  [20:54:49.064] result() for ClusterFuture ...
  [20:54:49.065] - result already collected: FutureResult
  [20:54:49.065] result() for ClusterFuture ... done
  [20:54:49.065] result() for ClusterFuture ...
  [20:54:49.065] - result already collected: FutureResult
  [20:54:49.066] result() for ClusterFuture ... done
  [20:54:49.066] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.066] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.067] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:49.067]  length: 1 (resolved future 3)
  [20:54:49.067] Future #4
  [20:54:49.067] result() for ClusterFuture ...
  [20:54:49.068] - result already collected: FutureResult
  [20:54:49.068] result() for ClusterFuture ... done
  [20:54:49.068] result() for ClusterFuture ...
  [20:54:49.069] - result already collected: FutureResult
  [20:54:49.069] result() for ClusterFuture ... done
  [20:54:49.069] signalConditionsASAP(ClusterFuture, pos=4) ...
  [20:54:49.069] - nx: 4
  [20:54:49.078] - relay: TRUE
  [20:54:49.078] - stdout: TRUE
  [20:54:49.078] - signal: TRUE
  [20:54:49.079] - resignal: FALSE
  [20:54:49.079] - force: TRUE
  [20:54:49.079] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.080] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.080]  - until=4
  [20:54:49.080]  - relaying element #4
  [20:54:49.080] result() for ClusterFuture ...
  [20:54:49.081] - result already collected: FutureResult
  [20:54:49.081] result() for ClusterFuture ... done
  [20:54:49.081] result() for ClusterFuture ...
  [20:54:49.082] - result already collected: FutureResult
  [20:54:49.082] result() for ClusterFuture ... done
  [20:54:49.082] result() for ClusterFuture ...
  [20:54:49.083] - result already collected: FutureResult
  [20:54:49.083] result() for ClusterFuture ... done
  [20:54:49.083] result() for ClusterFuture ...
  [20:54:49.083] - result already collected: FutureResult
  [20:54:49.084] result() for ClusterFuture ... done
  [20:54:49.084] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.084] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.085] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [20:54:49.085]  length: 0 (resolved future 4)
  [20:54:49.085] Relaying remaining futures
  [20:54:49.085] signalConditionsASAP(NULL, pos=0) ...
  [20:54:49.094] - nx: 4
  [20:54:49.094] - relay: TRUE
  [20:54:49.095] - stdout: TRUE
  [20:54:49.095] - signal: TRUE
  [20:54:49.095] - resignal: FALSE
  [20:54:49.095] - force: TRUE
  [20:54:49.095] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.096] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:49.096] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.096] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.097] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:49.097] resolve() on environment ... DONE
  [20:54:49.097] result() for ClusterFuture ...
  [20:54:49.098] - result already collected: FutureResult
  [20:54:49.098] result() for ClusterFuture ... done
  [20:54:49.098] result() for ClusterFuture ...
  [20:54:49.098] - result already collected: FutureResult
  [20:54:49.099] result() for ClusterFuture ... done
  [20:54:49.099] result() for ClusterFuture ...
  [20:54:49.099] - result already collected: FutureResult
  [20:54:49.099] result() for ClusterFuture ... done
  [20:54:49.100] result() for ClusterFuture ...
  [20:54:49.100] - result already collected: FutureResult
  [20:54:49.100] result() for ClusterFuture ... done
  [20:54:49.101] result() for ClusterFuture ...
  [20:54:49.101] - result already collected: FutureResult
  [20:54:49.101] result() for ClusterFuture ... done
  [20:54:49.101] result() for ClusterFuture ...
  [20:54:49.102] - result already collected: FutureResult
  [20:54:49.110] result() for ClusterFuture ... done
  <environment: 0x556b1181db90> 
  Dimensions: c(2, 3)
  [20:54:49.116] getGlobalsAndPackages() ...
  [20:54:49.116] Searching for globals...
  [20:54:49.117] 
  [20:54:49.117] Searching for globals ... DONE
  [20:54:49.117] - globals: [0] <none>
  [20:54:49.118] getGlobalsAndPackages() ... DONE
  [20:54:49.133] Packages needed by the future expression (n = 0): <none>
  [20:54:49.134] Packages needed by future strategies (n = 0): <none>
  [20:54:49.138] {
  [20:54:49.138]     {
  [20:54:49.138]         ...future.startTime <- base::Sys.time()
  [20:54:49.138]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.138]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.138]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.138]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.138]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.138]         {
  [20:54:49.138]             {
  [20:54:49.138]                 has_future <- base::requireNamespace("future", 
  [20:54:49.138]                   quietly = TRUE)
  [20:54:49.138]                 version <- if (has_future) 
  [20:54:49.138]                   utils::packageVersion("future")
  [20:54:49.138]                 else NULL
  [20:54:49.138]                 if (!has_future || version < "1.8.0") {
  [20:54:49.138]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.138]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.138]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.138]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.138]                       "release", "version")], collapse = " "), 
  [20:54:49.138]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.138]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.138]                     info)
  [20:54:49.138]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.138]                   if (!has_future) {
  [20:54:49.138]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.138]                       info)
  [20:54:49.138]                   }
  [20:54:49.138]                   else {
  [20:54:49.138]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.138]                       info, version)
  [20:54:49.138]                   }
  [20:54:49.138]                   base::stop(msg)
  [20:54:49.138]                 }
  [20:54:49.138]             }
  [20:54:49.138]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.138]         }
  [20:54:49.138]     }
  [20:54:49.138]     if (base::is.na(TRUE)) {
  [20:54:49.138]     }
  [20:54:49.138]     else {
  [20:54:49.138]         if (TRUE) {
  [20:54:49.138]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.138]                 open = "w")
  [20:54:49.138]         }
  [20:54:49.138]         else {
  [20:54:49.138]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.138]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.138]         }
  [20:54:49.138]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.138]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.138]             base::sink(type = "output", split = FALSE)
  [20:54:49.138]             base::close(...future.stdout)
  [20:54:49.138]         }, add = TRUE)
  [20:54:49.138]     }
  [20:54:49.138]     ...future.frame <- base::sys.nframe()
  [20:54:49.138]     ...future.conditions <- base::list()
  [20:54:49.138]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.138]     ...future.result <- base::tryCatch({
  [20:54:49.138]         base::withCallingHandlers({
  [20:54:49.138]             ...future.value <- base::withVisible(base::local({
  [20:54:49.138]                 ...future.sendCondition <- local({
  [20:54:49.138]                   sendCondition <- NULL
  [20:54:49.138]                   function(frame = 1L) {
  [20:54:49.138]                     if (is.function(sendCondition)) 
  [20:54:49.138]                       return(sendCondition)
  [20:54:49.138]                     ns <- getNamespace("parallel")
  [20:54:49.138]                     if (exists("sendData", mode = "function", 
  [20:54:49.138]                       envir = ns)) {
  [20:54:49.138]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.138]                         envir = ns)
  [20:54:49.138]                       envir <- sys.frame(frame)
  [20:54:49.138]                       master <- NULL
  [20:54:49.138]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.138]                         !identical(envir, emptyenv())) {
  [20:54:49.138]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.138]                           inherits = FALSE)) {
  [20:54:49.138]                           master <- get("master", mode = "list", 
  [20:54:49.138]                             envir = envir, inherits = FALSE)
  [20:54:49.138]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.138]                             sendCondition <<- function(cond) {
  [20:54:49.138]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.138]                                 success = TRUE)
  [20:54:49.138]                               parallel_sendData(master, data)
  [20:54:49.138]                             }
  [20:54:49.138]                             return(sendCondition)
  [20:54:49.138]                           }
  [20:54:49.138]                         }
  [20:54:49.138]                         frame <- frame + 1L
  [20:54:49.138]                         envir <- sys.frame(frame)
  [20:54:49.138]                       }
  [20:54:49.138]                     }
  [20:54:49.138]                     sendCondition <<- function(cond) NULL
  [20:54:49.138]                   }
  [20:54:49.138]                 })
  [20:54:49.138]                 withCallingHandlers({
  [20:54:49.138]                   2
  [20:54:49.138]                 }, immediateCondition = function(cond) {
  [20:54:49.138]                   sendCondition <- ...future.sendCondition()
  [20:54:49.138]                   sendCondition(cond)
  [20:54:49.138]                   muffleCondition <- function (cond) 
  [20:54:49.138]                   {
  [20:54:49.138]                     inherits <- base::inherits
  [20:54:49.138]                     invokeRestart <- base::invokeRestart
  [20:54:49.138]                     muffled <- FALSE
  [20:54:49.138]                     if (inherits(cond, "message")) {
  [20:54:49.138]                       invokeRestart("muffleMessage")
  [20:54:49.138]                       muffled <- TRUE
  [20:54:49.138]                     }
  [20:54:49.138]                     else if (inherits(cond, "warning")) {
  [20:54:49.138]                       invokeRestart("muffleWarning")
  [20:54:49.138]                       muffled <- TRUE
  [20:54:49.138]                     }
  [20:54:49.138]                     else if (inherits(cond, "condition")) {
  [20:54:49.138]                       computeRestarts <- base::computeRestarts
  [20:54:49.138]                       grepl <- base::grepl
  [20:54:49.138]                       is.null <- base::is.null
  [20:54:49.138]                       restarts <- computeRestarts(cond)
  [20:54:49.138]                       for (restart in restarts) {
  [20:54:49.138]                         name <- restart$name
  [20:54:49.138]                         if (is.null(name)) 
  [20:54:49.138]                           next
  [20:54:49.138]                         if (!grepl("^muffle", name)) 
  [20:54:49.138]                           next
  [20:54:49.138]                         invokeRestart(restart)
  [20:54:49.138]                         muffled <- TRUE
  [20:54:49.138]                         break
  [20:54:49.138]                       }
  [20:54:49.138]                     }
  [20:54:49.138]                     invisible(muffled)
  [20:54:49.138]                   }
  [20:54:49.138]                   muffleCondition(cond)
  [20:54:49.138]                 })
  [20:54:49.138]             }))
  [20:54:49.138]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.138]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.138]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.138]                 version = "1.8")
  [20:54:49.138]         }, condition = base::local({
  [20:54:49.138]             c <- base::c
  [20:54:49.138]             inherits <- base::inherits
  [20:54:49.138]             invokeRestart <- base::invokeRestart
  [20:54:49.138]             length <- base::length
  [20:54:49.138]             list <- base::list
  [20:54:49.138]             seq.int <- base::seq.int
  [20:54:49.138]             signalCondition <- base::signalCondition
  [20:54:49.138]             sys.calls <- base::sys.calls
  [20:54:49.138]             Sys.time <- base::Sys.time
  [20:54:49.138]             `[[` <- base::`[[`
  [20:54:49.138]             `+` <- base::`+`
  [20:54:49.138]             `<<-` <- base::`<<-`
  [20:54:49.138]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.138]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.138]                   3L)]
  [20:54:49.138]             }
  [20:54:49.138]             function(cond) {
  [20:54:49.138]                 if (inherits(cond, "error")) {
  [20:54:49.138]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.138]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.138]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.138]                   signalCondition(cond)
  [20:54:49.138]                 }
  [20:54:49.138]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.138]                 ))) {
  [20:54:49.138]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.138]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.138]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.138]                   if (!signal) {
  [20:54:49.138]                     muffleCondition <- function (cond) 
  [20:54:49.138]                     {
  [20:54:49.138]                       inherits <- base::inherits
  [20:54:49.138]                       invokeRestart <- base::invokeRestart
  [20:54:49.138]                       muffled <- FALSE
  [20:54:49.138]                       if (inherits(cond, "message")) {
  [20:54:49.138]                         invokeRestart("muffleMessage")
  [20:54:49.138]                         muffled <- TRUE
  [20:54:49.138]                       }
  [20:54:49.138]                       else if (inherits(cond, "warning")) {
  [20:54:49.138]                         invokeRestart("muffleWarning")
  [20:54:49.138]                         muffled <- TRUE
  [20:54:49.138]                       }
  [20:54:49.138]                       else if (inherits(cond, "condition")) {
  [20:54:49.138]                         computeRestarts <- base::computeRestarts
  [20:54:49.138]                         grepl <- base::grepl
  [20:54:49.138]                         is.null <- base::is.null
  [20:54:49.138]                         restarts <- computeRestarts(cond)
  [20:54:49.138]                         for (restart in restarts) {
  [20:54:49.138]                           name <- restart$name
  [20:54:49.138]                           if (is.null(name)) 
  [20:54:49.138]                             next
  [20:54:49.138]                           if (!grepl("^muffle", name)) 
  [20:54:49.138]                             next
  [20:54:49.138]                           invokeRestart(restart)
  [20:54:49.138]                           muffled <- TRUE
  [20:54:49.138]                           break
  [20:54:49.138]                         }
  [20:54:49.138]                       }
  [20:54:49.138]                       invisible(muffled)
  [20:54:49.138]                     }
  [20:54:49.138]                     muffleCondition(cond)
  [20:54:49.138]                   }
  [20:54:49.138]                 }
  [20:54:49.138]             }
  [20:54:49.138]         }))
  [20:54:49.138]     }, error = function(ex) {
  [20:54:49.138]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.138]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.138]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.138]     }, finally = {
  [20:54:49.138]         {
  [20:54:49.138]             NULL
  [20:54:49.138]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.138]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.138]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.138]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.138]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.138]                 ...) 
  [20:54:49.138]             {
  [20:54:49.138]                 if (substitute) 
  [20:54:49.138]                   expr <- substitute(expr)
  [20:54:49.138]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.138]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.138]                   globals = globals, persistent = persistent, 
  [20:54:49.138]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.138]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.138]                   label = label, ...)
  [20:54:49.138]                 if (!future$lazy) 
  [20:54:49.138]                   future <- run(future)
  [20:54:49.138]                 invisible(future)
  [20:54:49.138]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.138]         }
  [20:54:49.138]         base::options(...future.oldOptions)
  [20:54:49.138]     })
  [20:54:49.138]     Sys.time
  [20:54:49.138]     if (base::is.na(TRUE)) {
  [20:54:49.138]     }
  [20:54:49.138]     else {
  [20:54:49.138]         base::sink(type = "output", split = FALSE)
  [20:54:49.138]         if (TRUE) {
  [20:54:49.138]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.138]         }
  [20:54:49.138]         else {
  [20:54:49.138]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.138]         }
  [20:54:49.138]         base::close(...future.stdout)
  [20:54:49.138]         ...future.stdout <- NULL
  [20:54:49.138]     }
  [20:54:49.138]     ...future.result$conditions <- ...future.conditions
  [20:54:49.138]     ...future.result
  [20:54:49.138] }
  [20:54:49.166] ClusterFuture started
  [20:54:49.171] getGlobalsAndPackages() ...
  [20:54:49.172] Searching for globals...
  [20:54:49.173] 
  [20:54:49.173] Searching for globals ... DONE
  [20:54:49.173] - globals: [0] <none>
  [20:54:49.173] getGlobalsAndPackages() ... DONE
  [20:54:49.200] Packages needed by the future expression (n = 0): <none>
  [20:54:49.200] Packages needed by future strategies (n = 0): <none>
  [20:54:49.205] {
  [20:54:49.205]     {
  [20:54:49.205]         ...future.startTime <- base::Sys.time()
  [20:54:49.205]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.205]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.205]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.205]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.205]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.205]         {
  [20:54:49.205]             {
  [20:54:49.205]                 has_future <- base::requireNamespace("future", 
  [20:54:49.205]                   quietly = TRUE)
  [20:54:49.205]                 version <- if (has_future) 
  [20:54:49.205]                   utils::packageVersion("future")
  [20:54:49.205]                 else NULL
  [20:54:49.205]                 if (!has_future || version < "1.8.0") {
  [20:54:49.205]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.205]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.205]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.205]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.205]                       "release", "version")], collapse = " "), 
  [20:54:49.205]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.205]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.205]                     info)
  [20:54:49.205]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.205]                   if (!has_future) {
  [20:54:49.205]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.205]                       info)
  [20:54:49.205]                   }
  [20:54:49.205]                   else {
  [20:54:49.205]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.205]                       info, version)
  [20:54:49.205]                   }
  [20:54:49.205]                   base::stop(msg)
  [20:54:49.205]                 }
  [20:54:49.205]             }
  [20:54:49.205]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.205]         }
  [20:54:49.205]     }
  [20:54:49.205]     if (base::is.na(TRUE)) {
  [20:54:49.205]     }
  [20:54:49.205]     else {
  [20:54:49.205]         if (TRUE) {
  [20:54:49.205]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.205]                 open = "w")
  [20:54:49.205]         }
  [20:54:49.205]         else {
  [20:54:49.205]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.205]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.205]         }
  [20:54:49.205]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.205]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.205]             base::sink(type = "output", split = FALSE)
  [20:54:49.205]             base::close(...future.stdout)
  [20:54:49.205]         }, add = TRUE)
  [20:54:49.205]     }
  [20:54:49.205]     ...future.frame <- base::sys.nframe()
  [20:54:49.205]     ...future.conditions <- base::list()
  [20:54:49.205]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.205]     ...future.result <- base::tryCatch({
  [20:54:49.205]         base::withCallingHandlers({
  [20:54:49.205]             ...future.value <- base::withVisible(base::local({
  [20:54:49.205]                 ...future.sendCondition <- local({
  [20:54:49.205]                   sendCondition <- NULL
  [20:54:49.205]                   function(frame = 1L) {
  [20:54:49.205]                     if (is.function(sendCondition)) 
  [20:54:49.205]                       return(sendCondition)
  [20:54:49.205]                     ns <- getNamespace("parallel")
  [20:54:49.205]                     if (exists("sendData", mode = "function", 
  [20:54:49.205]                       envir = ns)) {
  [20:54:49.205]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.205]                         envir = ns)
  [20:54:49.205]                       envir <- sys.frame(frame)
  [20:54:49.205]                       master <- NULL
  [20:54:49.205]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.205]                         !identical(envir, emptyenv())) {
  [20:54:49.205]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.205]                           inherits = FALSE)) {
  [20:54:49.205]                           master <- get("master", mode = "list", 
  [20:54:49.205]                             envir = envir, inherits = FALSE)
  [20:54:49.205]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.205]                             sendCondition <<- function(cond) {
  [20:54:49.205]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.205]                                 success = TRUE)
  [20:54:49.205]                               parallel_sendData(master, data)
  [20:54:49.205]                             }
  [20:54:49.205]                             return(sendCondition)
  [20:54:49.205]                           }
  [20:54:49.205]                         }
  [20:54:49.205]                         frame <- frame + 1L
  [20:54:49.205]                         envir <- sys.frame(frame)
  [20:54:49.205]                       }
  [20:54:49.205]                     }
  [20:54:49.205]                     sendCondition <<- function(cond) NULL
  [20:54:49.205]                   }
  [20:54:49.205]                 })
  [20:54:49.205]                 withCallingHandlers({
  [20:54:49.205]                   NULL
  [20:54:49.205]                 }, immediateCondition = function(cond) {
  [20:54:49.205]                   sendCondition <- ...future.sendCondition()
  [20:54:49.205]                   sendCondition(cond)
  [20:54:49.205]                   muffleCondition <- function (cond) 
  [20:54:49.205]                   {
  [20:54:49.205]                     inherits <- base::inherits
  [20:54:49.205]                     invokeRestart <- base::invokeRestart
  [20:54:49.205]                     muffled <- FALSE
  [20:54:49.205]                     if (inherits(cond, "message")) {
  [20:54:49.205]                       invokeRestart("muffleMessage")
  [20:54:49.205]                       muffled <- TRUE
  [20:54:49.205]                     }
  [20:54:49.205]                     else if (inherits(cond, "warning")) {
  [20:54:49.205]                       invokeRestart("muffleWarning")
  [20:54:49.205]                       muffled <- TRUE
  [20:54:49.205]                     }
  [20:54:49.205]                     else if (inherits(cond, "condition")) {
  [20:54:49.205]                       computeRestarts <- base::computeRestarts
  [20:54:49.205]                       grepl <- base::grepl
  [20:54:49.205]                       is.null <- base::is.null
  [20:54:49.205]                       restarts <- computeRestarts(cond)
  [20:54:49.205]                       for (restart in restarts) {
  [20:54:49.205]                         name <- restart$name
  [20:54:49.205]                         if (is.null(name)) 
  [20:54:49.205]                           next
  [20:54:49.205]                         if (!grepl("^muffle", name)) 
  [20:54:49.205]                           next
  [20:54:49.205]                         invokeRestart(restart)
  [20:54:49.205]                         muffled <- TRUE
  [20:54:49.205]                         break
  [20:54:49.205]                       }
  [20:54:49.205]                     }
  [20:54:49.205]                     invisible(muffled)
  [20:54:49.205]                   }
  [20:54:49.205]                   muffleCondition(cond)
  [20:54:49.205]                 })
  [20:54:49.205]             }))
  [20:54:49.205]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.205]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.205]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.205]                 version = "1.8")
  [20:54:49.205]         }, condition = base::local({
  [20:54:49.205]             c <- base::c
  [20:54:49.205]             inherits <- base::inherits
  [20:54:49.205]             invokeRestart <- base::invokeRestart
  [20:54:49.205]             length <- base::length
  [20:54:49.205]             list <- base::list
  [20:54:49.205]             seq.int <- base::seq.int
  [20:54:49.205]             signalCondition <- base::signalCondition
  [20:54:49.205]             sys.calls <- base::sys.calls
  [20:54:49.205]             Sys.time <- base::Sys.time
  [20:54:49.205]             `[[` <- base::`[[`
  [20:54:49.205]             `+` <- base::`+`
  [20:54:49.205]             `<<-` <- base::`<<-`
  [20:54:49.205]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.205]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.205]                   3L)]
  [20:54:49.205]             }
  [20:54:49.205]             function(cond) {
  [20:54:49.205]                 if (inherits(cond, "error")) {
  [20:54:49.205]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.205]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.205]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.205]                   signalCondition(cond)
  [20:54:49.205]                 }
  [20:54:49.205]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.205]                 ))) {
  [20:54:49.205]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.205]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.205]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.205]                   if (!signal) {
  [20:54:49.205]                     muffleCondition <- function (cond) 
  [20:54:49.205]                     {
  [20:54:49.205]                       inherits <- base::inherits
  [20:54:49.205]                       invokeRestart <- base::invokeRestart
  [20:54:49.205]                       muffled <- FALSE
  [20:54:49.205]                       if (inherits(cond, "message")) {
  [20:54:49.205]                         invokeRestart("muffleMessage")
  [20:54:49.205]                         muffled <- TRUE
  [20:54:49.205]                       }
  [20:54:49.205]                       else if (inherits(cond, "warning")) {
  [20:54:49.205]                         invokeRestart("muffleWarning")
  [20:54:49.205]                         muffled <- TRUE
  [20:54:49.205]                       }
  [20:54:49.205]                       else if (inherits(cond, "condition")) {
  [20:54:49.205]                         computeRestarts <- base::computeRestarts
  [20:54:49.205]                         grepl <- base::grepl
  [20:54:49.205]                         is.null <- base::is.null
  [20:54:49.205]                         restarts <- computeRestarts(cond)
  [20:54:49.205]                         for (restart in restarts) {
  [20:54:49.205]                           name <- restart$name
  [20:54:49.205]                           if (is.null(name)) 
  [20:54:49.205]                             next
  [20:54:49.205]                           if (!grepl("^muffle", name)) 
  [20:54:49.205]                             next
  [20:54:49.205]                           invokeRestart(restart)
  [20:54:49.205]                           muffled <- TRUE
  [20:54:49.205]                           break
  [20:54:49.205]                         }
  [20:54:49.205]                       }
  [20:54:49.205]                       invisible(muffled)
  [20:54:49.205]                     }
  [20:54:49.205]                     muffleCondition(cond)
  [20:54:49.205]                   }
  [20:54:49.205]                 }
  [20:54:49.205]             }
  [20:54:49.205]         }))
  [20:54:49.205]     }, error = function(ex) {
  [20:54:49.205]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.205]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.205]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.205]     }, finally = {
  [20:54:49.205]         {
  [20:54:49.205]             NULL
  [20:54:49.205]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.205]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.205]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.205]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.205]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.205]                 ...) 
  [20:54:49.205]             {
  [20:54:49.205]                 if (substitute) 
  [20:54:49.205]                   expr <- substitute(expr)
  [20:54:49.205]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.205]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.205]                   globals = globals, persistent = persistent, 
  [20:54:49.205]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.205]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.205]                   label = label, ...)
  [20:54:49.205]                 if (!future$lazy) 
  [20:54:49.205]                   future <- run(future)
  [20:54:49.205]                 invisible(future)
  [20:54:49.205]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.205]         }
  [20:54:49.205]         base::options(...future.oldOptions)
  [20:54:49.205]     })
  [20:54:49.205]     Sys.time
  [20:54:49.205]     if (base::is.na(TRUE)) {
  [20:54:49.205]     }
  [20:54:49.205]     else {
  [20:54:49.205]         base::sink(type = "output", split = FALSE)
  [20:54:49.205]         if (TRUE) {
  [20:54:49.205]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.205]         }
  [20:54:49.205]         else {
  [20:54:49.205]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.205]         }
  [20:54:49.205]         base::close(...future.stdout)
  [20:54:49.205]         ...future.stdout <- NULL
  [20:54:49.205]     }
  [20:54:49.205]     ...future.result$conditions <- ...future.conditions
  [20:54:49.205]     ...future.result
  [20:54:49.205] }
  [20:54:49.226] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:49.238] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.239] - Validating connection of ClusterFuture
  [20:54:49.239] - received message: FutureResult
  [20:54:49.240] - Received FutureResult
  [20:54:49.240] - Erased future from FutureRegistry
  [20:54:49.240] result() for ClusterFuture ...
  [20:54:49.241] - result already collected: FutureResult
  [20:54:49.241] result() for ClusterFuture ... done
  [20:54:49.241] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:49.242] result() for ClusterFuture ...
  [20:54:49.242] - result already collected: FutureResult
  [20:54:49.242] result() for ClusterFuture ... done
  [20:54:49.243] result() for ClusterFuture ...
  [20:54:49.243] - result already collected: FutureResult
  [20:54:49.243] result() for ClusterFuture ... done
  [20:54:49.246] ClusterFuture started
  [20:54:49.252] getGlobalsAndPackages() ...
  [20:54:49.252] Searching for globals...
  [20:54:49.254] - globals found: [1] '{'
  [20:54:49.254] Searching for globals ... DONE
  [20:54:49.254] Resolving globals: FALSE
  [20:54:49.255] 
  [20:54:49.255] 
  [20:54:49.256] getGlobalsAndPackages() ... DONE
  [20:54:49.275] Packages needed by the future expression (n = 0): <none>
  [20:54:49.276] Packages needed by future strategies (n = 0): <none>
  [20:54:49.281] {
  [20:54:49.281]     {
  [20:54:49.281]         ...future.startTime <- base::Sys.time()
  [20:54:49.281]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.281]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.281]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.281]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.281]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.281]         {
  [20:54:49.281]             {
  [20:54:49.281]                 has_future <- base::requireNamespace("future", 
  [20:54:49.281]                   quietly = TRUE)
  [20:54:49.281]                 version <- if (has_future) 
  [20:54:49.281]                   utils::packageVersion("future")
  [20:54:49.281]                 else NULL
  [20:54:49.281]                 if (!has_future || version < "1.8.0") {
  [20:54:49.281]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.281]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.281]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.281]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.281]                       "release", "version")], collapse = " "), 
  [20:54:49.281]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.281]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.281]                     info)
  [20:54:49.281]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.281]                   if (!has_future) {
  [20:54:49.281]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.281]                       info)
  [20:54:49.281]                   }
  [20:54:49.281]                   else {
  [20:54:49.281]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.281]                       info, version)
  [20:54:49.281]                   }
  [20:54:49.281]                   base::stop(msg)
  [20:54:49.281]                 }
  [20:54:49.281]             }
  [20:54:49.281]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.281]         }
  [20:54:49.281]     }
  [20:54:49.281]     if (base::is.na(TRUE)) {
  [20:54:49.281]     }
  [20:54:49.281]     else {
  [20:54:49.281]         if (TRUE) {
  [20:54:49.281]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.281]                 open = "w")
  [20:54:49.281]         }
  [20:54:49.281]         else {
  [20:54:49.281]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.281]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.281]         }
  [20:54:49.281]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.281]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.281]             base::sink(type = "output", split = FALSE)
  [20:54:49.281]             base::close(...future.stdout)
  [20:54:49.281]         }, add = TRUE)
  [20:54:49.281]     }
  [20:54:49.281]     ...future.frame <- base::sys.nframe()
  [20:54:49.281]     ...future.conditions <- base::list()
  [20:54:49.281]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.281]     ...future.result <- base::tryCatch({
  [20:54:49.281]         base::withCallingHandlers({
  [20:54:49.281]             ...future.value <- base::withVisible(base::local({
  [20:54:49.281]                 ...future.sendCondition <- local({
  [20:54:49.281]                   sendCondition <- NULL
  [20:54:49.281]                   function(frame = 1L) {
  [20:54:49.281]                     if (is.function(sendCondition)) 
  [20:54:49.281]                       return(sendCondition)
  [20:54:49.281]                     ns <- getNamespace("parallel")
  [20:54:49.281]                     if (exists("sendData", mode = "function", 
  [20:54:49.281]                       envir = ns)) {
  [20:54:49.281]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.281]                         envir = ns)
  [20:54:49.281]                       envir <- sys.frame(frame)
  [20:54:49.281]                       master <- NULL
  [20:54:49.281]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.281]                         !identical(envir, emptyenv())) {
  [20:54:49.281]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.281]                           inherits = FALSE)) {
  [20:54:49.281]                           master <- get("master", mode = "list", 
  [20:54:49.281]                             envir = envir, inherits = FALSE)
  [20:54:49.281]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.281]                             sendCondition <<- function(cond) {
  [20:54:49.281]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.281]                                 success = TRUE)
  [20:54:49.281]                               parallel_sendData(master, data)
  [20:54:49.281]                             }
  [20:54:49.281]                             return(sendCondition)
  [20:54:49.281]                           }
  [20:54:49.281]                         }
  [20:54:49.281]                         frame <- frame + 1L
  [20:54:49.281]                         envir <- sys.frame(frame)
  [20:54:49.281]                       }
  [20:54:49.281]                     }
  [20:54:49.281]                     sendCondition <<- function(cond) NULL
  [20:54:49.281]                   }
  [20:54:49.281]                 })
  [20:54:49.281]                 withCallingHandlers({
  [20:54:49.281]                   {
  [20:54:49.281]                     4
  [20:54:49.281]                   }
  [20:54:49.281]                 }, immediateCondition = function(cond) {
  [20:54:49.281]                   sendCondition <- ...future.sendCondition()
  [20:54:49.281]                   sendCondition(cond)
  [20:54:49.281]                   muffleCondition <- function (cond) 
  [20:54:49.281]                   {
  [20:54:49.281]                     inherits <- base::inherits
  [20:54:49.281]                     invokeRestart <- base::invokeRestart
  [20:54:49.281]                     muffled <- FALSE
  [20:54:49.281]                     if (inherits(cond, "message")) {
  [20:54:49.281]                       invokeRestart("muffleMessage")
  [20:54:49.281]                       muffled <- TRUE
  [20:54:49.281]                     }
  [20:54:49.281]                     else if (inherits(cond, "warning")) {
  [20:54:49.281]                       invokeRestart("muffleWarning")
  [20:54:49.281]                       muffled <- TRUE
  [20:54:49.281]                     }
  [20:54:49.281]                     else if (inherits(cond, "condition")) {
  [20:54:49.281]                       computeRestarts <- base::computeRestarts
  [20:54:49.281]                       grepl <- base::grepl
  [20:54:49.281]                       is.null <- base::is.null
  [20:54:49.281]                       restarts <- computeRestarts(cond)
  [20:54:49.281]                       for (restart in restarts) {
  [20:54:49.281]                         name <- restart$name
  [20:54:49.281]                         if (is.null(name)) 
  [20:54:49.281]                           next
  [20:54:49.281]                         if (!grepl("^muffle", name)) 
  [20:54:49.281]                           next
  [20:54:49.281]                         invokeRestart(restart)
  [20:54:49.281]                         muffled <- TRUE
  [20:54:49.281]                         break
  [20:54:49.281]                       }
  [20:54:49.281]                     }
  [20:54:49.281]                     invisible(muffled)
  [20:54:49.281]                   }
  [20:54:49.281]                   muffleCondition(cond)
  [20:54:49.281]                 })
  [20:54:49.281]             }))
  [20:54:49.281]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.281]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.281]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.281]                 version = "1.8")
  [20:54:49.281]         }, condition = base::local({
  [20:54:49.281]             c <- base::c
  [20:54:49.281]             inherits <- base::inherits
  [20:54:49.281]             invokeRestart <- base::invokeRestart
  [20:54:49.281]             length <- base::length
  [20:54:49.281]             list <- base::list
  [20:54:49.281]             seq.int <- base::seq.int
  [20:54:49.281]             signalCondition <- base::signalCondition
  [20:54:49.281]             sys.calls <- base::sys.calls
  [20:54:49.281]             Sys.time <- base::Sys.time
  [20:54:49.281]             `[[` <- base::`[[`
  [20:54:49.281]             `+` <- base::`+`
  [20:54:49.281]             `<<-` <- base::`<<-`
  [20:54:49.281]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.281]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.281]                   3L)]
  [20:54:49.281]             }
  [20:54:49.281]             function(cond) {
  [20:54:49.281]                 if (inherits(cond, "error")) {
  [20:54:49.281]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.281]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.281]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.281]                   signalCondition(cond)
  [20:54:49.281]                 }
  [20:54:49.281]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.281]                 ))) {
  [20:54:49.281]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.281]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.281]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.281]                   if (!signal) {
  [20:54:49.281]                     muffleCondition <- function (cond) 
  [20:54:49.281]                     {
  [20:54:49.281]                       inherits <- base::inherits
  [20:54:49.281]                       invokeRestart <- base::invokeRestart
  [20:54:49.281]                       muffled <- FALSE
  [20:54:49.281]                       if (inherits(cond, "message")) {
  [20:54:49.281]                         invokeRestart("muffleMessage")
  [20:54:49.281]                         muffled <- TRUE
  [20:54:49.281]                       }
  [20:54:49.281]                       else if (inherits(cond, "warning")) {
  [20:54:49.281]                         invokeRestart("muffleWarning")
  [20:54:49.281]                         muffled <- TRUE
  [20:54:49.281]                       }
  [20:54:49.281]                       else if (inherits(cond, "condition")) {
  [20:54:49.281]                         computeRestarts <- base::computeRestarts
  [20:54:49.281]                         grepl <- base::grepl
  [20:54:49.281]                         is.null <- base::is.null
  [20:54:49.281]                         restarts <- computeRestarts(cond)
  [20:54:49.281]                         for (restart in restarts) {
  [20:54:49.281]                           name <- restart$name
  [20:54:49.281]                           if (is.null(name)) 
  [20:54:49.281]                             next
  [20:54:49.281]                           if (!grepl("^muffle", name)) 
  [20:54:49.281]                             next
  [20:54:49.281]                           invokeRestart(restart)
  [20:54:49.281]                           muffled <- TRUE
  [20:54:49.281]                           break
  [20:54:49.281]                         }
  [20:54:49.281]                       }
  [20:54:49.281]                       invisible(muffled)
  [20:54:49.281]                     }
  [20:54:49.281]                     muffleCondition(cond)
  [20:54:49.281]                   }
  [20:54:49.281]                 }
  [20:54:49.281]             }
  [20:54:49.281]         }))
  [20:54:49.281]     }, error = function(ex) {
  [20:54:49.281]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.281]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.281]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.281]     }, finally = {
  [20:54:49.281]         {
  [20:54:49.281]             NULL
  [20:54:49.281]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.281]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.281]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.281]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.281]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.281]                 ...) 
  [20:54:49.281]             {
  [20:54:49.281]                 if (substitute) 
  [20:54:49.281]                   expr <- substitute(expr)
  [20:54:49.281]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.281]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.281]                   globals = globals, persistent = persistent, 
  [20:54:49.281]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.281]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.281]                   label = label, ...)
  [20:54:49.281]                 if (!future$lazy) 
  [20:54:49.281]                   future <- run(future)
  [20:54:49.281]                 invisible(future)
  [20:54:49.281]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.281]         }
  [20:54:49.281]         base::options(...future.oldOptions)
  [20:54:49.281]     })
  [20:54:49.281]     Sys.time
  [20:54:49.281]     if (base::is.na(TRUE)) {
  [20:54:49.281]     }
  [20:54:49.281]     else {
  [20:54:49.281]         base::sink(type = "output", split = FALSE)
  [20:54:49.281]         if (TRUE) {
  [20:54:49.281]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.281]         }
  [20:54:49.281]         else {
  [20:54:49.281]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.281]         }
  [20:54:49.281]         base::close(...future.stdout)
  [20:54:49.281]         ...future.stdout <- NULL
  [20:54:49.281]     }
  [20:54:49.281]     ...future.result$conditions <- ...future.conditions
  [20:54:49.281]     ...future.result
  [20:54:49.281] }
  [20:54:49.285] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:49.314] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.314] - Validating connection of ClusterFuture
  [20:54:49.315] - received message: FutureResult
  [20:54:49.315] - Received FutureResult
  [20:54:49.315] - Erased future from FutureRegistry
  [20:54:49.316] result() for ClusterFuture ...
  [20:54:49.316] - result already collected: FutureResult
  [20:54:49.316] result() for ClusterFuture ... done
  [20:54:49.317] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:49.317] result() for ClusterFuture ...
  [20:54:49.317] - result already collected: FutureResult
  [20:54:49.318] result() for ClusterFuture ... done
  [20:54:49.318] result() for ClusterFuture ...
  [20:54:49.318] - result already collected: FutureResult
  [20:54:49.319] result() for ClusterFuture ... done
  [20:54:49.321] ClusterFuture started
  <environment: 0x556b11300ec8> 
  <environment: 0x556b118dce20> 
  [20:54:49.366] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.366] - Validating connection of ClusterFuture
  [20:54:49.367] - received message: FutureResult
  [20:54:49.367] - Received FutureResult
  [20:54:49.367] - Erased future from FutureRegistry
  [20:54:49.368] result() for ClusterFuture ...
  [20:54:49.368] - result already collected: FutureResult
  [20:54:49.368] result() for ClusterFuture ... done
  [20:54:49.368] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:49.391] resolve() on environment ...
  [20:54:49.391]  recursive: 0
  [20:54:49.393]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:49.393] signalConditionsASAP(numeric, pos=1) ...
  [20:54:49.393] - nx: 4
  [20:54:49.394] - relay: TRUE
  [20:54:49.394] - stdout: TRUE
  [20:54:49.394] - signal: TRUE
  [20:54:49.394] - resignal: FALSE
  [20:54:49.395] - force: TRUE
  [20:54:49.395] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.395] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.396]  - until=2
  [20:54:49.396]  - relaying element #2
  [20:54:49.396] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.396] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.397] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:49.397]  length: 3 (resolved future 1)
  [20:54:49.397] Future #2
  [20:54:49.398] result() for ClusterFuture ...
  [20:54:49.398] - result already collected: FutureResult
  [20:54:49.398] result() for ClusterFuture ... done
  [20:54:49.398] result() for ClusterFuture ...
  [20:54:49.399] - result already collected: FutureResult
  [20:54:49.399] result() for ClusterFuture ... done
  [20:54:49.399] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:49.399] - nx: 4
  [20:54:49.400] - relay: TRUE
  [20:54:49.400] - stdout: TRUE
  [20:54:49.400] - signal: TRUE
  [20:54:49.401] - resignal: FALSE
  [20:54:49.401] - force: TRUE
  [20:54:49.401] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.401] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.417]  - until=2
  [20:54:49.417]  - relaying element #2
  [20:54:49.417] result() for ClusterFuture ...
  [20:54:49.418] - result already collected: FutureResult
  [20:54:49.418] result() for ClusterFuture ... done
  [20:54:49.418] result() for ClusterFuture ...
  [20:54:49.419] - result already collected: FutureResult
  [20:54:49.419] result() for ClusterFuture ... done
  [20:54:49.419] result() for ClusterFuture ...
  [20:54:49.420] - result already collected: FutureResult
  [20:54:49.420] result() for ClusterFuture ... done
  [20:54:49.420] result() for ClusterFuture ...
  [20:54:49.420] - result already collected: FutureResult
  [20:54:49.421] result() for ClusterFuture ... done
  [20:54:49.421] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.421] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.422] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:49.422]  length: 2 (resolved future 2)
  [20:54:49.422] Future #3
  [20:54:49.422] result() for ClusterFuture ...
  [20:54:49.423] - result already collected: FutureResult
  [20:54:49.423] result() for ClusterFuture ... done
  [20:54:49.423] result() for ClusterFuture ...
  [20:54:49.424] - result already collected: FutureResult
  [20:54:49.424] result() for ClusterFuture ... done
  [20:54:49.424] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:49.424] - nx: 4
  [20:54:49.425] - relay: TRUE
  [20:54:49.425] - stdout: TRUE
  [20:54:49.425] - signal: TRUE
  [20:54:49.426] - resignal: FALSE
  [20:54:49.450] - force: TRUE
  [20:54:49.450] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.451] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.451]  - until=3
  [20:54:49.451]  - relaying element #3
  [20:54:49.452] result() for ClusterFuture ...
  [20:54:49.452] - result already collected: FutureResult
  [20:54:49.452] result() for ClusterFuture ... done
  [20:54:49.453] result() for ClusterFuture ...
  [20:54:49.453] - result already collected: FutureResult
  [20:54:49.453] result() for ClusterFuture ... done
  [20:54:49.454] result() for ClusterFuture ...
  [20:54:49.454] - result already collected: FutureResult
  [20:54:49.454] result() for ClusterFuture ... done
  [20:54:49.455] result() for ClusterFuture ...
  [20:54:49.455] - result already collected: FutureResult
  [20:54:49.455] result() for ClusterFuture ... done
  [20:54:49.455] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.456] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.456] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:49.456]  length: 1 (resolved future 3)
  [20:54:49.457] Future #4
  [20:54:49.457] result() for ClusterFuture ...
  [20:54:49.457] - result already collected: FutureResult
  [20:54:49.458] result() for ClusterFuture ... done
  [20:54:49.458] result() for ClusterFuture ...
  [20:54:49.458] - result already collected: FutureResult
  [20:54:49.458] result() for ClusterFuture ... done
  [20:54:49.459] signalConditionsASAP(ClusterFuture, pos=4) ...
  [20:54:49.459] - nx: 4
  [20:54:49.459] - relay: TRUE
  [20:54:49.460] - stdout: TRUE
  [20:54:49.460] - signal: TRUE
  [20:54:49.460] - resignal: FALSE
  [20:54:49.460] - force: TRUE
  [20:54:49.461] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.461] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.461]  - until=4
  [20:54:49.462]  - relaying element #4
  [20:54:49.478] result() for ClusterFuture ...
  [20:54:49.478] - result already collected: FutureResult
  [20:54:49.479] result() for ClusterFuture ... done
  [20:54:49.479] result() for ClusterFuture ...
  [20:54:49.479] - result already collected: FutureResult
  [20:54:49.480] result() for ClusterFuture ... done
  [20:54:49.480] result() for ClusterFuture ...
  [20:54:49.480] - result already collected: FutureResult
  [20:54:49.481] result() for ClusterFuture ... done
  [20:54:49.481] result() for ClusterFuture ...
  [20:54:49.481] - result already collected: FutureResult
  [20:54:49.481] result() for ClusterFuture ... done
  [20:54:49.482] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.482] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.482] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [20:54:49.483]  length: 0 (resolved future 4)
  [20:54:49.483] Relaying remaining futures
  [20:54:49.483] signalConditionsASAP(NULL, pos=0) ...
  [20:54:49.483] - nx: 4
  [20:54:49.484] - relay: TRUE
  [20:54:49.484] - stdout: TRUE
  [20:54:49.484] - signal: TRUE
  [20:54:49.484] - resignal: FALSE
  [20:54:49.484] - force: TRUE
  [20:54:49.485] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.485] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:49.485] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.494] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.494] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:49.495] resolve() on environment ... DONE
  [20:54:49.495] result() for ClusterFuture ...
  [20:54:49.495] - result already collected: FutureResult
  [20:54:49.496] result() for ClusterFuture ... done
  [20:54:49.496] result() for ClusterFuture ...
  [20:54:49.496] - result already collected: FutureResult
  [20:54:49.496] result() for ClusterFuture ... done
  [20:54:49.497] result() for ClusterFuture ...
  [20:54:49.497] - result already collected: FutureResult
  [20:54:49.497] result() for ClusterFuture ... done
  [20:54:49.498] result() for ClusterFuture ...
  [20:54:49.498] - result already collected: FutureResult
  [20:54:49.498] result() for ClusterFuture ... done
  [20:54:49.499] result() for ClusterFuture ...
  [20:54:49.499] - result already collected: FutureResult
  [20:54:49.499] result() for ClusterFuture ... done
  [20:54:49.499] result() for ClusterFuture ...
  [20:54:49.500] - result already collected: FutureResult
  [20:54:49.500] result() for ClusterFuture ... done
  <environment: 0x556b10673010> 
  Dimensions: c(2, 3, 1)
  [20:54:49.515] getGlobalsAndPackages() ...
  [20:54:49.515] Searching for globals...
  [20:54:49.516] 
  [20:54:49.517] Searching for globals ... DONE
  [20:54:49.517] - globals: [0] <none>
  [20:54:49.517] getGlobalsAndPackages() ... DONE
  [20:54:49.544] Packages needed by the future expression (n = 0): <none>
  [20:54:49.544] Packages needed by future strategies (n = 0): <none>
  [20:54:49.550] {
  [20:54:49.550]     {
  [20:54:49.550]         ...future.startTime <- base::Sys.time()
  [20:54:49.550]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.550]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.550]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.550]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.550]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.550]         {
  [20:54:49.550]             {
  [20:54:49.550]                 has_future <- base::requireNamespace("future", 
  [20:54:49.550]                   quietly = TRUE)
  [20:54:49.550]                 version <- if (has_future) 
  [20:54:49.550]                   utils::packageVersion("future")
  [20:54:49.550]                 else NULL
  [20:54:49.550]                 if (!has_future || version < "1.8.0") {
  [20:54:49.550]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.550]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.550]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.550]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.550]                       "release", "version")], collapse = " "), 
  [20:54:49.550]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.550]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.550]                     info)
  [20:54:49.550]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.550]                   if (!has_future) {
  [20:54:49.550]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.550]                       info)
  [20:54:49.550]                   }
  [20:54:49.550]                   else {
  [20:54:49.550]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.550]                       info, version)
  [20:54:49.550]                   }
  [20:54:49.550]                   base::stop(msg)
  [20:54:49.550]                 }
  [20:54:49.550]             }
  [20:54:49.550]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.550]         }
  [20:54:49.550]     }
  [20:54:49.550]     if (base::is.na(TRUE)) {
  [20:54:49.550]     }
  [20:54:49.550]     else {
  [20:54:49.550]         if (TRUE) {
  [20:54:49.550]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.550]                 open = "w")
  [20:54:49.550]         }
  [20:54:49.550]         else {
  [20:54:49.550]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.550]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.550]         }
  [20:54:49.550]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.550]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.550]             base::sink(type = "output", split = FALSE)
  [20:54:49.550]             base::close(...future.stdout)
  [20:54:49.550]         }, add = TRUE)
  [20:54:49.550]     }
  [20:54:49.550]     ...future.frame <- base::sys.nframe()
  [20:54:49.550]     ...future.conditions <- base::list()
  [20:54:49.550]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.550]     ...future.result <- base::tryCatch({
  [20:54:49.550]         base::withCallingHandlers({
  [20:54:49.550]             ...future.value <- base::withVisible(base::local({
  [20:54:49.550]                 ...future.sendCondition <- local({
  [20:54:49.550]                   sendCondition <- NULL
  [20:54:49.550]                   function(frame = 1L) {
  [20:54:49.550]                     if (is.function(sendCondition)) 
  [20:54:49.550]                       return(sendCondition)
  [20:54:49.550]                     ns <- getNamespace("parallel")
  [20:54:49.550]                     if (exists("sendData", mode = "function", 
  [20:54:49.550]                       envir = ns)) {
  [20:54:49.550]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.550]                         envir = ns)
  [20:54:49.550]                       envir <- sys.frame(frame)
  [20:54:49.550]                       master <- NULL
  [20:54:49.550]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.550]                         !identical(envir, emptyenv())) {
  [20:54:49.550]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.550]                           inherits = FALSE)) {
  [20:54:49.550]                           master <- get("master", mode = "list", 
  [20:54:49.550]                             envir = envir, inherits = FALSE)
  [20:54:49.550]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.550]                             sendCondition <<- function(cond) {
  [20:54:49.550]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.550]                                 success = TRUE)
  [20:54:49.550]                               parallel_sendData(master, data)
  [20:54:49.550]                             }
  [20:54:49.550]                             return(sendCondition)
  [20:54:49.550]                           }
  [20:54:49.550]                         }
  [20:54:49.550]                         frame <- frame + 1L
  [20:54:49.550]                         envir <- sys.frame(frame)
  [20:54:49.550]                       }
  [20:54:49.550]                     }
  [20:54:49.550]                     sendCondition <<- function(cond) NULL
  [20:54:49.550]                   }
  [20:54:49.550]                 })
  [20:54:49.550]                 withCallingHandlers({
  [20:54:49.550]                   2
  [20:54:49.550]                 }, immediateCondition = function(cond) {
  [20:54:49.550]                   sendCondition <- ...future.sendCondition()
  [20:54:49.550]                   sendCondition(cond)
  [20:54:49.550]                   muffleCondition <- function (cond) 
  [20:54:49.550]                   {
  [20:54:49.550]                     inherits <- base::inherits
  [20:54:49.550]                     invokeRestart <- base::invokeRestart
  [20:54:49.550]                     muffled <- FALSE
  [20:54:49.550]                     if (inherits(cond, "message")) {
  [20:54:49.550]                       invokeRestart("muffleMessage")
  [20:54:49.550]                       muffled <- TRUE
  [20:54:49.550]                     }
  [20:54:49.550]                     else if (inherits(cond, "warning")) {
  [20:54:49.550]                       invokeRestart("muffleWarning")
  [20:54:49.550]                       muffled <- TRUE
  [20:54:49.550]                     }
  [20:54:49.550]                     else if (inherits(cond, "condition")) {
  [20:54:49.550]                       computeRestarts <- base::computeRestarts
  [20:54:49.550]                       grepl <- base::grepl
  [20:54:49.550]                       is.null <- base::is.null
  [20:54:49.550]                       restarts <- computeRestarts(cond)
  [20:54:49.550]                       for (restart in restarts) {
  [20:54:49.550]                         name <- restart$name
  [20:54:49.550]                         if (is.null(name)) 
  [20:54:49.550]                           next
  [20:54:49.550]                         if (!grepl("^muffle", name)) 
  [20:54:49.550]                           next
  [20:54:49.550]                         invokeRestart(restart)
  [20:54:49.550]                         muffled <- TRUE
  [20:54:49.550]                         break
  [20:54:49.550]                       }
  [20:54:49.550]                     }
  [20:54:49.550]                     invisible(muffled)
  [20:54:49.550]                   }
  [20:54:49.550]                   muffleCondition(cond)
  [20:54:49.550]                 })
  [20:54:49.550]             }))
  [20:54:49.550]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.550]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.550]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.550]                 version = "1.8")
  [20:54:49.550]         }, condition = base::local({
  [20:54:49.550]             c <- base::c
  [20:54:49.550]             inherits <- base::inherits
  [20:54:49.550]             invokeRestart <- base::invokeRestart
  [20:54:49.550]             length <- base::length
  [20:54:49.550]             list <- base::list
  [20:54:49.550]             seq.int <- base::seq.int
  [20:54:49.550]             signalCondition <- base::signalCondition
  [20:54:49.550]             sys.calls <- base::sys.calls
  [20:54:49.550]             Sys.time <- base::Sys.time
  [20:54:49.550]             `[[` <- base::`[[`
  [20:54:49.550]             `+` <- base::`+`
  [20:54:49.550]             `<<-` <- base::`<<-`
  [20:54:49.550]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.550]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.550]                   3L)]
  [20:54:49.550]             }
  [20:54:49.550]             function(cond) {
  [20:54:49.550]                 if (inherits(cond, "error")) {
  [20:54:49.550]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.550]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.550]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.550]                   signalCondition(cond)
  [20:54:49.550]                 }
  [20:54:49.550]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.550]                 ))) {
  [20:54:49.550]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.550]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.550]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.550]                   if (!signal) {
  [20:54:49.550]                     muffleCondition <- function (cond) 
  [20:54:49.550]                     {
  [20:54:49.550]                       inherits <- base::inherits
  [20:54:49.550]                       invokeRestart <- base::invokeRestart
  [20:54:49.550]                       muffled <- FALSE
  [20:54:49.550]                       if (inherits(cond, "message")) {
  [20:54:49.550]                         invokeRestart("muffleMessage")
  [20:54:49.550]                         muffled <- TRUE
  [20:54:49.550]                       }
  [20:54:49.550]                       else if (inherits(cond, "warning")) {
  [20:54:49.550]                         invokeRestart("muffleWarning")
  [20:54:49.550]                         muffled <- TRUE
  [20:54:49.550]                       }
  [20:54:49.550]                       else if (inherits(cond, "condition")) {
  [20:54:49.550]                         computeRestarts <- base::computeRestarts
  [20:54:49.550]                         grepl <- base::grepl
  [20:54:49.550]                         is.null <- base::is.null
  [20:54:49.550]                         restarts <- computeRestarts(cond)
  [20:54:49.550]                         for (restart in restarts) {
  [20:54:49.550]                           name <- restart$name
  [20:54:49.550]                           if (is.null(name)) 
  [20:54:49.550]                             next
  [20:54:49.550]                           if (!grepl("^muffle", name)) 
  [20:54:49.550]                             next
  [20:54:49.550]                           invokeRestart(restart)
  [20:54:49.550]                           muffled <- TRUE
  [20:54:49.550]                           break
  [20:54:49.550]                         }
  [20:54:49.550]                       }
  [20:54:49.550]                       invisible(muffled)
  [20:54:49.550]                     }
  [20:54:49.550]                     muffleCondition(cond)
  [20:54:49.550]                   }
  [20:54:49.550]                 }
  [20:54:49.550]             }
  [20:54:49.550]         }))
  [20:54:49.550]     }, error = function(ex) {
  [20:54:49.550]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.550]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.550]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.550]     }, finally = {
  [20:54:49.550]         {
  [20:54:49.550]             NULL
  [20:54:49.550]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.550]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.550]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.550]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.550]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.550]                 ...) 
  [20:54:49.550]             {
  [20:54:49.550]                 if (substitute) 
  [20:54:49.550]                   expr <- substitute(expr)
  [20:54:49.550]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.550]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.550]                   globals = globals, persistent = persistent, 
  [20:54:49.550]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.550]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.550]                   label = label, ...)
  [20:54:49.550]                 if (!future$lazy) 
  [20:54:49.550]                   future <- run(future)
  [20:54:49.550]                 invisible(future)
  [20:54:49.550]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.550]         }
  [20:54:49.550]         base::options(...future.oldOptions)
  [20:54:49.550]     })
  [20:54:49.550]     Sys.time
  [20:54:49.550]     if (base::is.na(TRUE)) {
  [20:54:49.550]     }
  [20:54:49.550]     else {
  [20:54:49.550]         base::sink(type = "output", split = FALSE)
  [20:54:49.550]         if (TRUE) {
  [20:54:49.550]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.550]         }
  [20:54:49.550]         else {
  [20:54:49.550]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.550]         }
  [20:54:49.550]         base::close(...future.stdout)
  [20:54:49.550]         ...future.stdout <- NULL
  [20:54:49.550]     }
  [20:54:49.550]     ...future.result$conditions <- ...future.conditions
  [20:54:49.550]     ...future.result
  [20:54:49.550] }
  [20:54:49.571] ClusterFuture started
  [20:54:49.576] getGlobalsAndPackages() ...
  [20:54:49.577] Searching for globals...
  [20:54:49.578] 
  [20:54:49.578] Searching for globals ... DONE
  [20:54:49.578] - globals: [0] <none>
  [20:54:49.579] getGlobalsAndPackages() ... DONE
  [20:54:49.582] Packages needed by the future expression (n = 0): <none>
  [20:54:49.583] Packages needed by future strategies (n = 0): <none>
  [20:54:49.604] {
  [20:54:49.604]     {
  [20:54:49.604]         ...future.startTime <- base::Sys.time()
  [20:54:49.604]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.604]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.604]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.604]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.604]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.604]         {
  [20:54:49.604]             {
  [20:54:49.604]                 has_future <- base::requireNamespace("future", 
  [20:54:49.604]                   quietly = TRUE)
  [20:54:49.604]                 version <- if (has_future) 
  [20:54:49.604]                   utils::packageVersion("future")
  [20:54:49.604]                 else NULL
  [20:54:49.604]                 if (!has_future || version < "1.8.0") {
  [20:54:49.604]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.604]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.604]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.604]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.604]                       "release", "version")], collapse = " "), 
  [20:54:49.604]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.604]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.604]                     info)
  [20:54:49.604]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.604]                   if (!has_future) {
  [20:54:49.604]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.604]                       info)
  [20:54:49.604]                   }
  [20:54:49.604]                   else {
  [20:54:49.604]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.604]                       info, version)
  [20:54:49.604]                   }
  [20:54:49.604]                   base::stop(msg)
  [20:54:49.604]                 }
  [20:54:49.604]             }
  [20:54:49.604]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.604]         }
  [20:54:49.604]     }
  [20:54:49.604]     if (base::is.na(TRUE)) {
  [20:54:49.604]     }
  [20:54:49.604]     else {
  [20:54:49.604]         if (TRUE) {
  [20:54:49.604]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.604]                 open = "w")
  [20:54:49.604]         }
  [20:54:49.604]         else {
  [20:54:49.604]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.604]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.604]         }
  [20:54:49.604]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.604]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.604]             base::sink(type = "output", split = FALSE)
  [20:54:49.604]             base::close(...future.stdout)
  [20:54:49.604]         }, add = TRUE)
  [20:54:49.604]     }
  [20:54:49.604]     ...future.frame <- base::sys.nframe()
  [20:54:49.604]     ...future.conditions <- base::list()
  [20:54:49.604]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.604]     ...future.result <- base::tryCatch({
  [20:54:49.604]         base::withCallingHandlers({
  [20:54:49.604]             ...future.value <- base::withVisible(base::local({
  [20:54:49.604]                 ...future.sendCondition <- local({
  [20:54:49.604]                   sendCondition <- NULL
  [20:54:49.604]                   function(frame = 1L) {
  [20:54:49.604]                     if (is.function(sendCondition)) 
  [20:54:49.604]                       return(sendCondition)
  [20:54:49.604]                     ns <- getNamespace("parallel")
  [20:54:49.604]                     if (exists("sendData", mode = "function", 
  [20:54:49.604]                       envir = ns)) {
  [20:54:49.604]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.604]                         envir = ns)
  [20:54:49.604]                       envir <- sys.frame(frame)
  [20:54:49.604]                       master <- NULL
  [20:54:49.604]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.604]                         !identical(envir, emptyenv())) {
  [20:54:49.604]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.604]                           inherits = FALSE)) {
  [20:54:49.604]                           master <- get("master", mode = "list", 
  [20:54:49.604]                             envir = envir, inherits = FALSE)
  [20:54:49.604]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.604]                             sendCondition <<- function(cond) {
  [20:54:49.604]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.604]                                 success = TRUE)
  [20:54:49.604]                               parallel_sendData(master, data)
  [20:54:49.604]                             }
  [20:54:49.604]                             return(sendCondition)
  [20:54:49.604]                           }
  [20:54:49.604]                         }
  [20:54:49.604]                         frame <- frame + 1L
  [20:54:49.604]                         envir <- sys.frame(frame)
  [20:54:49.604]                       }
  [20:54:49.604]                     }
  [20:54:49.604]                     sendCondition <<- function(cond) NULL
  [20:54:49.604]                   }
  [20:54:49.604]                 })
  [20:54:49.604]                 withCallingHandlers({
  [20:54:49.604]                   NULL
  [20:54:49.604]                 }, immediateCondition = function(cond) {
  [20:54:49.604]                   sendCondition <- ...future.sendCondition()
  [20:54:49.604]                   sendCondition(cond)
  [20:54:49.604]                   muffleCondition <- function (cond) 
  [20:54:49.604]                   {
  [20:54:49.604]                     inherits <- base::inherits
  [20:54:49.604]                     invokeRestart <- base::invokeRestart
  [20:54:49.604]                     muffled <- FALSE
  [20:54:49.604]                     if (inherits(cond, "message")) {
  [20:54:49.604]                       invokeRestart("muffleMessage")
  [20:54:49.604]                       muffled <- TRUE
  [20:54:49.604]                     }
  [20:54:49.604]                     else if (inherits(cond, "warning")) {
  [20:54:49.604]                       invokeRestart("muffleWarning")
  [20:54:49.604]                       muffled <- TRUE
  [20:54:49.604]                     }
  [20:54:49.604]                     else if (inherits(cond, "condition")) {
  [20:54:49.604]                       computeRestarts <- base::computeRestarts
  [20:54:49.604]                       grepl <- base::grepl
  [20:54:49.604]                       is.null <- base::is.null
  [20:54:49.604]                       restarts <- computeRestarts(cond)
  [20:54:49.604]                       for (restart in restarts) {
  [20:54:49.604]                         name <- restart$name
  [20:54:49.604]                         if (is.null(name)) 
  [20:54:49.604]                           next
  [20:54:49.604]                         if (!grepl("^muffle", name)) 
  [20:54:49.604]                           next
  [20:54:49.604]                         invokeRestart(restart)
  [20:54:49.604]                         muffled <- TRUE
  [20:54:49.604]                         break
  [20:54:49.604]                       }
  [20:54:49.604]                     }
  [20:54:49.604]                     invisible(muffled)
  [20:54:49.604]                   }
  [20:54:49.604]                   muffleCondition(cond)
  [20:54:49.604]                 })
  [20:54:49.604]             }))
  [20:54:49.604]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.604]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.604]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.604]                 version = "1.8")
  [20:54:49.604]         }, condition = base::local({
  [20:54:49.604]             c <- base::c
  [20:54:49.604]             inherits <- base::inherits
  [20:54:49.604]             invokeRestart <- base::invokeRestart
  [20:54:49.604]             length <- base::length
  [20:54:49.604]             list <- base::list
  [20:54:49.604]             seq.int <- base::seq.int
  [20:54:49.604]             signalCondition <- base::signalCondition
  [20:54:49.604]             sys.calls <- base::sys.calls
  [20:54:49.604]             Sys.time <- base::Sys.time
  [20:54:49.604]             `[[` <- base::`[[`
  [20:54:49.604]             `+` <- base::`+`
  [20:54:49.604]             `<<-` <- base::`<<-`
  [20:54:49.604]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.604]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.604]                   3L)]
  [20:54:49.604]             }
  [20:54:49.604]             function(cond) {
  [20:54:49.604]                 if (inherits(cond, "error")) {
  [20:54:49.604]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.604]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.604]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.604]                   signalCondition(cond)
  [20:54:49.604]                 }
  [20:54:49.604]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.604]                 ))) {
  [20:54:49.604]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.604]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.604]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.604]                   if (!signal) {
  [20:54:49.604]                     muffleCondition <- function (cond) 
  [20:54:49.604]                     {
  [20:54:49.604]                       inherits <- base::inherits
  [20:54:49.604]                       invokeRestart <- base::invokeRestart
  [20:54:49.604]                       muffled <- FALSE
  [20:54:49.604]                       if (inherits(cond, "message")) {
  [20:54:49.604]                         invokeRestart("muffleMessage")
  [20:54:49.604]                         muffled <- TRUE
  [20:54:49.604]                       }
  [20:54:49.604]                       else if (inherits(cond, "warning")) {
  [20:54:49.604]                         invokeRestart("muffleWarning")
  [20:54:49.604]                         muffled <- TRUE
  [20:54:49.604]                       }
  [20:54:49.604]                       else if (inherits(cond, "condition")) {
  [20:54:49.604]                         computeRestarts <- base::computeRestarts
  [20:54:49.604]                         grepl <- base::grepl
  [20:54:49.604]                         is.null <- base::is.null
  [20:54:49.604]                         restarts <- computeRestarts(cond)
  [20:54:49.604]                         for (restart in restarts) {
  [20:54:49.604]                           name <- restart$name
  [20:54:49.604]                           if (is.null(name)) 
  [20:54:49.604]                             next
  [20:54:49.604]                           if (!grepl("^muffle", name)) 
  [20:54:49.604]                             next
  [20:54:49.604]                           invokeRestart(restart)
  [20:54:49.604]                           muffled <- TRUE
  [20:54:49.604]                           break
  [20:54:49.604]                         }
  [20:54:49.604]                       }
  [20:54:49.604]                       invisible(muffled)
  [20:54:49.604]                     }
  [20:54:49.604]                     muffleCondition(cond)
  [20:54:49.604]                   }
  [20:54:49.604]                 }
  [20:54:49.604]             }
  [20:54:49.604]         }))
  [20:54:49.604]     }, error = function(ex) {
  [20:54:49.604]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.604]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.604]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.604]     }, finally = {
  [20:54:49.604]         {
  [20:54:49.604]             NULL
  [20:54:49.604]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.604]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.604]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.604]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.604]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.604]                 ...) 
  [20:54:49.604]             {
  [20:54:49.604]                 if (substitute) 
  [20:54:49.604]                   expr <- substitute(expr)
  [20:54:49.604]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.604]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.604]                   globals = globals, persistent = persistent, 
  [20:54:49.604]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.604]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.604]                   label = label, ...)
  [20:54:49.604]                 if (!future$lazy) 
  [20:54:49.604]                   future <- run(future)
  [20:54:49.604]                 invisible(future)
  [20:54:49.604]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.604]         }
  [20:54:49.604]         base::options(...future.oldOptions)
  [20:54:49.604]     })
  [20:54:49.604]     Sys.time
  [20:54:49.604]     if (base::is.na(TRUE)) {
  [20:54:49.604]     }
  [20:54:49.604]     else {
  [20:54:49.604]         base::sink(type = "output", split = FALSE)
  [20:54:49.604]         if (TRUE) {
  [20:54:49.604]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.604]         }
  [20:54:49.604]         else {
  [20:54:49.604]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.604]         }
  [20:54:49.604]         base::close(...future.stdout)
  [20:54:49.604]         ...future.stdout <- NULL
  [20:54:49.604]     }
  [20:54:49.604]     ...future.result$conditions <- ...future.conditions
  [20:54:49.604]     ...future.result
  [20:54:49.604] }
  [20:54:49.617] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:49.630] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.630] - Validating connection of ClusterFuture
  [20:54:49.631] - received message: FutureResult
  [20:54:49.631] - Received FutureResult
  [20:54:49.631] - Erased future from FutureRegistry
  [20:54:49.632] result() for ClusterFuture ...
  [20:54:49.632] - result already collected: FutureResult
  [20:54:49.632] result() for ClusterFuture ... done
  [20:54:49.633] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:49.633] result() for ClusterFuture ...
  [20:54:49.633] - result already collected: FutureResult
  [20:54:49.634] result() for ClusterFuture ... done
  [20:54:49.634] result() for ClusterFuture ...
  [20:54:49.634] - result already collected: FutureResult
  [20:54:49.635] result() for ClusterFuture ... done
  [20:54:49.647] ClusterFuture started
  [20:54:49.653] getGlobalsAndPackages() ...
  [20:54:49.654] Searching for globals...
  [20:54:49.655] - globals found: [1] '{'
  [20:54:49.656] Searching for globals ... DONE
  [20:54:49.656] Resolving globals: FALSE
  [20:54:49.657] 
  [20:54:49.657] 
  [20:54:49.657] getGlobalsAndPackages() ... DONE
  [20:54:49.674] Packages needed by the future expression (n = 0): <none>
  [20:54:49.674] Packages needed by future strategies (n = 0): <none>
  [20:54:49.688] {
  [20:54:49.688]     {
  [20:54:49.688]         ...future.startTime <- base::Sys.time()
  [20:54:49.688]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.688]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.688]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.688]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.688]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.688]         {
  [20:54:49.688]             {
  [20:54:49.688]                 has_future <- base::requireNamespace("future", 
  [20:54:49.688]                   quietly = TRUE)
  [20:54:49.688]                 version <- if (has_future) 
  [20:54:49.688]                   utils::packageVersion("future")
  [20:54:49.688]                 else NULL
  [20:54:49.688]                 if (!has_future || version < "1.8.0") {
  [20:54:49.688]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.688]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.688]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.688]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.688]                       "release", "version")], collapse = " "), 
  [20:54:49.688]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.688]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.688]                     info)
  [20:54:49.688]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.688]                   if (!has_future) {
  [20:54:49.688]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.688]                       info)
  [20:54:49.688]                   }
  [20:54:49.688]                   else {
  [20:54:49.688]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.688]                       info, version)
  [20:54:49.688]                   }
  [20:54:49.688]                   base::stop(msg)
  [20:54:49.688]                 }
  [20:54:49.688]             }
  [20:54:49.688]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.688]         }
  [20:54:49.688]     }
  [20:54:49.688]     if (base::is.na(TRUE)) {
  [20:54:49.688]     }
  [20:54:49.688]     else {
  [20:54:49.688]         if (TRUE) {
  [20:54:49.688]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.688]                 open = "w")
  [20:54:49.688]         }
  [20:54:49.688]         else {
  [20:54:49.688]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.688]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.688]         }
  [20:54:49.688]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.688]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.688]             base::sink(type = "output", split = FALSE)
  [20:54:49.688]             base::close(...future.stdout)
  [20:54:49.688]         }, add = TRUE)
  [20:54:49.688]     }
  [20:54:49.688]     ...future.frame <- base::sys.nframe()
  [20:54:49.688]     ...future.conditions <- base::list()
  [20:54:49.688]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.688]     ...future.result <- base::tryCatch({
  [20:54:49.688]         base::withCallingHandlers({
  [20:54:49.688]             ...future.value <- base::withVisible(base::local({
  [20:54:49.688]                 ...future.sendCondition <- local({
  [20:54:49.688]                   sendCondition <- NULL
  [20:54:49.688]                   function(frame = 1L) {
  [20:54:49.688]                     if (is.function(sendCondition)) 
  [20:54:49.688]                       return(sendCondition)
  [20:54:49.688]                     ns <- getNamespace("parallel")
  [20:54:49.688]                     if (exists("sendData", mode = "function", 
  [20:54:49.688]                       envir = ns)) {
  [20:54:49.688]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.688]                         envir = ns)
  [20:54:49.688]                       envir <- sys.frame(frame)
  [20:54:49.688]                       master <- NULL
  [20:54:49.688]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.688]                         !identical(envir, emptyenv())) {
  [20:54:49.688]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.688]                           inherits = FALSE)) {
  [20:54:49.688]                           master <- get("master", mode = "list", 
  [20:54:49.688]                             envir = envir, inherits = FALSE)
  [20:54:49.688]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.688]                             sendCondition <<- function(cond) {
  [20:54:49.688]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.688]                                 success = TRUE)
  [20:54:49.688]                               parallel_sendData(master, data)
  [20:54:49.688]                             }
  [20:54:49.688]                             return(sendCondition)
  [20:54:49.688]                           }
  [20:54:49.688]                         }
  [20:54:49.688]                         frame <- frame + 1L
  [20:54:49.688]                         envir <- sys.frame(frame)
  [20:54:49.688]                       }
  [20:54:49.688]                     }
  [20:54:49.688]                     sendCondition <<- function(cond) NULL
  [20:54:49.688]                   }
  [20:54:49.688]                 })
  [20:54:49.688]                 withCallingHandlers({
  [20:54:49.688]                   {
  [20:54:49.688]                     4
  [20:54:49.688]                   }
  [20:54:49.688]                 }, immediateCondition = function(cond) {
  [20:54:49.688]                   sendCondition <- ...future.sendCondition()
  [20:54:49.688]                   sendCondition(cond)
  [20:54:49.688]                   muffleCondition <- function (cond) 
  [20:54:49.688]                   {
  [20:54:49.688]                     inherits <- base::inherits
  [20:54:49.688]                     invokeRestart <- base::invokeRestart
  [20:54:49.688]                     muffled <- FALSE
  [20:54:49.688]                     if (inherits(cond, "message")) {
  [20:54:49.688]                       invokeRestart("muffleMessage")
  [20:54:49.688]                       muffled <- TRUE
  [20:54:49.688]                     }
  [20:54:49.688]                     else if (inherits(cond, "warning")) {
  [20:54:49.688]                       invokeRestart("muffleWarning")
  [20:54:49.688]                       muffled <- TRUE
  [20:54:49.688]                     }
  [20:54:49.688]                     else if (inherits(cond, "condition")) {
  [20:54:49.688]                       computeRestarts <- base::computeRestarts
  [20:54:49.688]                       grepl <- base::grepl
  [20:54:49.688]                       is.null <- base::is.null
  [20:54:49.688]                       restarts <- computeRestarts(cond)
  [20:54:49.688]                       for (restart in restarts) {
  [20:54:49.688]                         name <- restart$name
  [20:54:49.688]                         if (is.null(name)) 
  [20:54:49.688]                           next
  [20:54:49.688]                         if (!grepl("^muffle", name)) 
  [20:54:49.688]                           next
  [20:54:49.688]                         invokeRestart(restart)
  [20:54:49.688]                         muffled <- TRUE
  [20:54:49.688]                         break
  [20:54:49.688]                       }
  [20:54:49.688]                     }
  [20:54:49.688]                     invisible(muffled)
  [20:54:49.688]                   }
  [20:54:49.688]                   muffleCondition(cond)
  [20:54:49.688]                 })
  [20:54:49.688]             }))
  [20:54:49.688]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.688]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.688]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.688]                 version = "1.8")
  [20:54:49.688]         }, condition = base::local({
  [20:54:49.688]             c <- base::c
  [20:54:49.688]             inherits <- base::inherits
  [20:54:49.688]             invokeRestart <- base::invokeRestart
  [20:54:49.688]             length <- base::length
  [20:54:49.688]             list <- base::list
  [20:54:49.688]             seq.int <- base::seq.int
  [20:54:49.688]             signalCondition <- base::signalCondition
  [20:54:49.688]             sys.calls <- base::sys.calls
  [20:54:49.688]             Sys.time <- base::Sys.time
  [20:54:49.688]             `[[` <- base::`[[`
  [20:54:49.688]             `+` <- base::`+`
  [20:54:49.688]             `<<-` <- base::`<<-`
  [20:54:49.688]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.688]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.688]                   3L)]
  [20:54:49.688]             }
  [20:54:49.688]             function(cond) {
  [20:54:49.688]                 if (inherits(cond, "error")) {
  [20:54:49.688]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.688]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.688]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.688]                   signalCondition(cond)
  [20:54:49.688]                 }
  [20:54:49.688]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.688]                 ))) {
  [20:54:49.688]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.688]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.688]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.688]                   if (!signal) {
  [20:54:49.688]                     muffleCondition <- function (cond) 
  [20:54:49.688]                     {
  [20:54:49.688]                       inherits <- base::inherits
  [20:54:49.688]                       invokeRestart <- base::invokeRestart
  [20:54:49.688]                       muffled <- FALSE
  [20:54:49.688]                       if (inherits(cond, "message")) {
  [20:54:49.688]                         invokeRestart("muffleMessage")
  [20:54:49.688]                         muffled <- TRUE
  [20:54:49.688]                       }
  [20:54:49.688]                       else if (inherits(cond, "warning")) {
  [20:54:49.688]                         invokeRestart("muffleWarning")
  [20:54:49.688]                         muffled <- TRUE
  [20:54:49.688]                       }
  [20:54:49.688]                       else if (inherits(cond, "condition")) {
  [20:54:49.688]                         computeRestarts <- base::computeRestarts
  [20:54:49.688]                         grepl <- base::grepl
  [20:54:49.688]                         is.null <- base::is.null
  [20:54:49.688]                         restarts <- computeRestarts(cond)
  [20:54:49.688]                         for (restart in restarts) {
  [20:54:49.688]                           name <- restart$name
  [20:54:49.688]                           if (is.null(name)) 
  [20:54:49.688]                             next
  [20:54:49.688]                           if (!grepl("^muffle", name)) 
  [20:54:49.688]                             next
  [20:54:49.688]                           invokeRestart(restart)
  [20:54:49.688]                           muffled <- TRUE
  [20:54:49.688]                           break
  [20:54:49.688]                         }
  [20:54:49.688]                       }
  [20:54:49.688]                       invisible(muffled)
  [20:54:49.688]                     }
  [20:54:49.688]                     muffleCondition(cond)
  [20:54:49.688]                   }
  [20:54:49.688]                 }
  [20:54:49.688]             }
  [20:54:49.688]         }))
  [20:54:49.688]     }, error = function(ex) {
  [20:54:49.688]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.688]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.688]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.688]     }, finally = {
  [20:54:49.688]         {
  [20:54:49.688]             NULL
  [20:54:49.688]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.688]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.688]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.688]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.688]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.688]                 ...) 
  [20:54:49.688]             {
  [20:54:49.688]                 if (substitute) 
  [20:54:49.688]                   expr <- substitute(expr)
  [20:54:49.688]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.688]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.688]                   globals = globals, persistent = persistent, 
  [20:54:49.688]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.688]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.688]                   label = label, ...)
  [20:54:49.688]                 if (!future$lazy) 
  [20:54:49.688]                   future <- run(future)
  [20:54:49.688]                 invisible(future)
  [20:54:49.688]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.688]         }
  [20:54:49.688]         base::options(...future.oldOptions)
  [20:54:49.688]     })
  [20:54:49.688]     Sys.time
  [20:54:49.688]     if (base::is.na(TRUE)) {
  [20:54:49.688]     }
  [20:54:49.688]     else {
  [20:54:49.688]         base::sink(type = "output", split = FALSE)
  [20:54:49.688]         if (TRUE) {
  [20:54:49.688]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.688]         }
  [20:54:49.688]         else {
  [20:54:49.688]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.688]         }
  [20:54:49.688]         base::close(...future.stdout)
  [20:54:49.688]         ...future.stdout <- NULL
  [20:54:49.688]     }
  [20:54:49.688]     ...future.result$conditions <- ...future.conditions
  [20:54:49.688]     ...future.result
  [20:54:49.688] }
  [20:54:49.704] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:49.719] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.720] - Validating connection of ClusterFuture
  [20:54:49.720] - received message: FutureResult
  [20:54:49.721] - Received FutureResult
  [20:54:49.721] - Erased future from FutureRegistry
  [20:54:49.722] result() for ClusterFuture ...
  [20:54:49.722] - result already collected: FutureResult
  [20:54:49.722] result() for ClusterFuture ... done
  [20:54:49.723] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:49.723] result() for ClusterFuture ...
  [20:54:49.724] - result already collected: FutureResult
  [20:54:49.724] result() for ClusterFuture ... done
  [20:54:49.724] result() for ClusterFuture ...
  [20:54:49.725] - result already collected: FutureResult
  [20:54:49.725] result() for ClusterFuture ... done
  [20:54:49.743] ClusterFuture started
  <environment: 0x556b118d5da8> 
  <environment: 0x556b1001bd38> 
  [20:54:49.880] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:49.881] - Validating connection of ClusterFuture
  [20:54:49.881] - received message: FutureResult
  [20:54:49.881] - Received FutureResult
  [20:54:49.882] - Erased future from FutureRegistry
  [20:54:49.882] result() for ClusterFuture ...
  [20:54:49.882] - result already collected: FutureResult
  [20:54:49.883] result() for ClusterFuture ... done
  [20:54:49.883] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:49.886] resolve() on environment ...
  [20:54:49.887]  recursive: 0
  [20:54:49.888]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:49.888] signalConditionsASAP(numeric, pos=1) ...
  [20:54:49.889] - nx: 4
  [20:54:49.889] - relay: TRUE
  [20:54:49.889] - stdout: TRUE
  [20:54:49.890] - signal: TRUE
  [20:54:49.890] - resignal: FALSE
  [20:54:49.890] - force: TRUE
  [20:54:49.890] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.891] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.891]  - until=2
  [20:54:49.891]  - relaying element #2
  [20:54:49.891] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.892] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.892] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:49.892]  length: 3 (resolved future 1)
  [20:54:49.893] Future #2
  [20:54:49.893] result() for ClusterFuture ...
  [20:54:49.893] - result already collected: FutureResult
  [20:54:49.894] result() for ClusterFuture ... done
  [20:54:49.894] result() for ClusterFuture ...
  [20:54:49.894] - result already collected: FutureResult
  [20:54:49.895] result() for ClusterFuture ... done
  [20:54:49.895] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:49.895] - nx: 4
  [20:54:49.896] - relay: TRUE
  [20:54:49.896] - stdout: TRUE
  [20:54:49.896] - signal: TRUE
  [20:54:49.896] - resignal: FALSE
  [20:54:49.897] - force: TRUE
  [20:54:49.897] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:49.897] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:49.898]  - until=2
  [20:54:49.898]  - relaying element #2
  [20:54:49.898] result() for ClusterFuture ...
  [20:54:49.898] - result already collected: FutureResult
  [20:54:49.899] result() for ClusterFuture ... done
  [20:54:49.899] result() for ClusterFuture ...
  [20:54:49.899] - result already collected: FutureResult
  [20:54:49.900] result() for ClusterFuture ... done
  [20:54:49.900] result() for ClusterFuture ...
  [20:54:49.900] - result already collected: FutureResult
  [20:54:49.901] result() for ClusterFuture ... done
  [20:54:49.901] result() for ClusterFuture ...
  [20:54:49.901] - result already collected: FutureResult
  [20:54:49.901] result() for ClusterFuture ... done
  [20:54:49.902] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.902] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.902] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:49.903]  length: 2 (resolved future 2)
  [20:54:49.903] Future #3
  [20:54:49.903] result() for ClusterFuture ...
  [20:54:49.904] - result already collected: FutureResult
  [20:54:49.904] result() for ClusterFuture ... done
  [20:54:49.904] result() for ClusterFuture ...
  [20:54:49.905] - result already collected: FutureResult
  [20:54:49.905] result() for ClusterFuture ... done
  [20:54:49.905] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:49.906] - nx: 4
  [20:54:49.906] - relay: TRUE
  [20:54:49.906] - stdout: TRUE
  [20:54:49.906] - signal: TRUE
  [20:54:49.907] - resignal: FALSE
  [20:54:49.907] - force: TRUE
  [20:54:49.907] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:49.908] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:49.908]  - until=3
  [20:54:49.908]  - relaying element #3
  [20:54:49.909] result() for ClusterFuture ...
  [20:54:49.909] - result already collected: FutureResult
  [20:54:49.909] result() for ClusterFuture ... done
  [20:54:49.909] result() for ClusterFuture ...
  [20:54:49.926] - result already collected: FutureResult
  [20:54:49.926] result() for ClusterFuture ... done
  [20:54:49.927] result() for ClusterFuture ...
  [20:54:49.927] - result already collected: FutureResult
  [20:54:49.927] result() for ClusterFuture ... done
  [20:54:49.928] result() for ClusterFuture ...
  [20:54:49.928] - result already collected: FutureResult
  [20:54:49.928] result() for ClusterFuture ... done
  [20:54:49.929] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.929] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.929] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:49.930]  length: 1 (resolved future 3)
  [20:54:49.930] Future #4
  [20:54:49.930] result() for ClusterFuture ...
  [20:54:49.931] - result already collected: FutureResult
  [20:54:49.931] result() for ClusterFuture ... done
  [20:54:49.931] result() for ClusterFuture ...
  [20:54:49.931] - result already collected: FutureResult
  [20:54:49.932] result() for ClusterFuture ... done
  [20:54:49.932] signalConditionsASAP(ClusterFuture, pos=4) ...
  [20:54:49.932] - nx: 4
  [20:54:49.933] - relay: TRUE
  [20:54:49.933] - stdout: TRUE
  [20:54:49.933] - signal: TRUE
  [20:54:49.933] - resignal: FALSE
  [20:54:49.934] - force: TRUE
  [20:54:49.934] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:49.934] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:49.935]  - until=4
  [20:54:49.935]  - relaying element #4
  [20:54:49.935] result() for ClusterFuture ...
  [20:54:49.936] - result already collected: FutureResult
  [20:54:49.936] result() for ClusterFuture ... done
  [20:54:49.936] result() for ClusterFuture ...
  [20:54:49.936] - result already collected: FutureResult
  [20:54:49.937] result() for ClusterFuture ... done
  [20:54:49.937] result() for ClusterFuture ...
  [20:54:49.937] - result already collected: FutureResult
  [20:54:49.938] result() for ClusterFuture ... done
  [20:54:49.938] result() for ClusterFuture ...
  [20:54:49.938] - result already collected: FutureResult
  [20:54:49.939] result() for ClusterFuture ... done
  [20:54:49.939] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.939] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.940] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [20:54:49.940]  length: 0 (resolved future 4)
  [20:54:49.949] Relaying remaining futures
  [20:54:49.949] signalConditionsASAP(NULL, pos=0) ...
  [20:54:49.950] - nx: 4
  [20:54:49.950] - relay: TRUE
  [20:54:49.950] - stdout: TRUE
  [20:54:49.950] - signal: TRUE
  [20:54:49.951] - resignal: FALSE
  [20:54:49.951] - force: TRUE
  [20:54:49.951] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.952] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:49.952] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:49.953] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:49.953] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:49.953] resolve() on environment ... DONE
  [20:54:49.953] result() for ClusterFuture ...
  [20:54:49.954] - result already collected: FutureResult
  [20:54:49.954] result() for ClusterFuture ... done
  [20:54:49.954] result() for ClusterFuture ...
  [20:54:49.955] - result already collected: FutureResult
  [20:54:49.955] result() for ClusterFuture ... done
  [20:54:49.955] result() for ClusterFuture ...
  [20:54:49.956] - result already collected: FutureResult
  [20:54:49.956] result() for ClusterFuture ... done
  [20:54:49.956] result() for ClusterFuture ...
  [20:54:49.957] - result already collected: FutureResult
  [20:54:49.957] result() for ClusterFuture ... done
  [20:54:49.957] result() for ClusterFuture ...
  [20:54:49.957] - result already collected: FutureResult
  [20:54:49.958] result() for ClusterFuture ... done
  [20:54:49.958] result() for ClusterFuture ...
  [20:54:49.958] - result already collected: FutureResult
  [20:54:49.959] result() for ClusterFuture ... done
  <environment: 0x556b109e4798> 
  Dimensions: c(2, 1, 3, 1)
  [20:54:49.965] getGlobalsAndPackages() ...
  [20:54:49.966] Searching for globals...
  [20:54:49.967] 
  [20:54:49.967] Searching for globals ... DONE
  [20:54:49.967] - globals: [0] <none>
  [20:54:49.968] getGlobalsAndPackages() ... DONE
  [20:54:49.971] Packages needed by the future expression (n = 0): <none>
  [20:54:49.972] Packages needed by future strategies (n = 0): <none>
  [20:54:49.976] {
  [20:54:49.976]     {
  [20:54:49.976]         ...future.startTime <- base::Sys.time()
  [20:54:49.976]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:49.976]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:49.976]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:49.976]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:49.976]             future.resolve.recursive = NULL, width = 80L)
  [20:54:49.976]         {
  [20:54:49.976]             {
  [20:54:49.976]                 has_future <- base::requireNamespace("future", 
  [20:54:49.976]                   quietly = TRUE)
  [20:54:49.976]                 version <- if (has_future) 
  [20:54:49.976]                   utils::packageVersion("future")
  [20:54:49.976]                 else NULL
  [20:54:49.976]                 if (!has_future || version < "1.8.0") {
  [20:54:49.976]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:49.976]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:49.976]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:49.976]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:49.976]                       "release", "version")], collapse = " "), 
  [20:54:49.976]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:49.976]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:49.976]                     info)
  [20:54:49.976]                   info <- base::paste(info, collapse = "; ")
  [20:54:49.976]                   if (!has_future) {
  [20:54:49.976]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:49.976]                       info)
  [20:54:49.976]                   }
  [20:54:49.976]                   else {
  [20:54:49.976]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:49.976]                       info, version)
  [20:54:49.976]                   }
  [20:54:49.976]                   base::stop(msg)
  [20:54:49.976]                 }
  [20:54:49.976]             }
  [20:54:49.976]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:49.976]         }
  [20:54:49.976]     }
  [20:54:49.976]     if (base::is.na(TRUE)) {
  [20:54:49.976]     }
  [20:54:49.976]     else {
  [20:54:49.976]         if (TRUE) {
  [20:54:49.976]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:49.976]                 open = "w")
  [20:54:49.976]         }
  [20:54:49.976]         else {
  [20:54:49.976]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:49.976]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:49.976]         }
  [20:54:49.976]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:49.976]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:49.976]             base::sink(type = "output", split = FALSE)
  [20:54:49.976]             base::close(...future.stdout)
  [20:54:49.976]         }, add = TRUE)
  [20:54:49.976]     }
  [20:54:49.976]     ...future.frame <- base::sys.nframe()
  [20:54:49.976]     ...future.conditions <- base::list()
  [20:54:49.976]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:49.976]     ...future.result <- base::tryCatch({
  [20:54:49.976]         base::withCallingHandlers({
  [20:54:49.976]             ...future.value <- base::withVisible(base::local({
  [20:54:49.976]                 ...future.sendCondition <- local({
  [20:54:49.976]                   sendCondition <- NULL
  [20:54:49.976]                   function(frame = 1L) {
  [20:54:49.976]                     if (is.function(sendCondition)) 
  [20:54:49.976]                       return(sendCondition)
  [20:54:49.976]                     ns <- getNamespace("parallel")
  [20:54:49.976]                     if (exists("sendData", mode = "function", 
  [20:54:49.976]                       envir = ns)) {
  [20:54:49.976]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:49.976]                         envir = ns)
  [20:54:49.976]                       envir <- sys.frame(frame)
  [20:54:49.976]                       master <- NULL
  [20:54:49.976]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:49.976]                         !identical(envir, emptyenv())) {
  [20:54:49.976]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:49.976]                           inherits = FALSE)) {
  [20:54:49.976]                           master <- get("master", mode = "list", 
  [20:54:49.976]                             envir = envir, inherits = FALSE)
  [20:54:49.976]                           if (inherits(master, "SOCKnode")) {
  [20:54:49.976]                             sendCondition <<- function(cond) {
  [20:54:49.976]                               data <- list(type = "VALUE", value = cond, 
  [20:54:49.976]                                 success = TRUE)
  [20:54:49.976]                               parallel_sendData(master, data)
  [20:54:49.976]                             }
  [20:54:49.976]                             return(sendCondition)
  [20:54:49.976]                           }
  [20:54:49.976]                         }
  [20:54:49.976]                         frame <- frame + 1L
  [20:54:49.976]                         envir <- sys.frame(frame)
  [20:54:49.976]                       }
  [20:54:49.976]                     }
  [20:54:49.976]                     sendCondition <<- function(cond) NULL
  [20:54:49.976]                   }
  [20:54:49.976]                 })
  [20:54:49.976]                 withCallingHandlers({
  [20:54:49.976]                   2
  [20:54:49.976]                 }, immediateCondition = function(cond) {
  [20:54:49.976]                   sendCondition <- ...future.sendCondition()
  [20:54:49.976]                   sendCondition(cond)
  [20:54:49.976]                   muffleCondition <- function (cond) 
  [20:54:49.976]                   {
  [20:54:49.976]                     inherits <- base::inherits
  [20:54:49.976]                     invokeRestart <- base::invokeRestart
  [20:54:49.976]                     muffled <- FALSE
  [20:54:49.976]                     if (inherits(cond, "message")) {
  [20:54:49.976]                       invokeRestart("muffleMessage")
  [20:54:49.976]                       muffled <- TRUE
  [20:54:49.976]                     }
  [20:54:49.976]                     else if (inherits(cond, "warning")) {
  [20:54:49.976]                       invokeRestart("muffleWarning")
  [20:54:49.976]                       muffled <- TRUE
  [20:54:49.976]                     }
  [20:54:49.976]                     else if (inherits(cond, "condition")) {
  [20:54:49.976]                       computeRestarts <- base::computeRestarts
  [20:54:49.976]                       grepl <- base::grepl
  [20:54:49.976]                       is.null <- base::is.null
  [20:54:49.976]                       restarts <- computeRestarts(cond)
  [20:54:49.976]                       for (restart in restarts) {
  [20:54:49.976]                         name <- restart$name
  [20:54:49.976]                         if (is.null(name)) 
  [20:54:49.976]                           next
  [20:54:49.976]                         if (!grepl("^muffle", name)) 
  [20:54:49.976]                           next
  [20:54:49.976]                         invokeRestart(restart)
  [20:54:49.976]                         muffled <- TRUE
  [20:54:49.976]                         break
  [20:54:49.976]                       }
  [20:54:49.976]                     }
  [20:54:49.976]                     invisible(muffled)
  [20:54:49.976]                   }
  [20:54:49.976]                   muffleCondition(cond)
  [20:54:49.976]                 })
  [20:54:49.976]             }))
  [20:54:49.976]             future::FutureResult(value = ...future.value$value, 
  [20:54:49.976]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.976]                   ...future.rng), started = ...future.startTime, 
  [20:54:49.976]                 version = "1.8")
  [20:54:49.976]         }, condition = base::local({
  [20:54:49.976]             c <- base::c
  [20:54:49.976]             inherits <- base::inherits
  [20:54:49.976]             invokeRestart <- base::invokeRestart
  [20:54:49.976]             length <- base::length
  [20:54:49.976]             list <- base::list
  [20:54:49.976]             seq.int <- base::seq.int
  [20:54:49.976]             signalCondition <- base::signalCondition
  [20:54:49.976]             sys.calls <- base::sys.calls
  [20:54:49.976]             Sys.time <- base::Sys.time
  [20:54:49.976]             `[[` <- base::`[[`
  [20:54:49.976]             `+` <- base::`+`
  [20:54:49.976]             `<<-` <- base::`<<-`
  [20:54:49.976]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:49.976]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:49.976]                   3L)]
  [20:54:49.976]             }
  [20:54:49.976]             function(cond) {
  [20:54:49.976]                 if (inherits(cond, "error")) {
  [20:54:49.976]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.976]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:49.976]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:49.976]                   signalCondition(cond)
  [20:54:49.976]                 }
  [20:54:49.976]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:49.976]                 ))) {
  [20:54:49.976]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:49.976]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:49.976]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:49.976]                   if (!signal) {
  [20:54:49.976]                     muffleCondition <- function (cond) 
  [20:54:49.976]                     {
  [20:54:49.976]                       inherits <- base::inherits
  [20:54:49.976]                       invokeRestart <- base::invokeRestart
  [20:54:49.976]                       muffled <- FALSE
  [20:54:49.976]                       if (inherits(cond, "message")) {
  [20:54:49.976]                         invokeRestart("muffleMessage")
  [20:54:49.976]                         muffled <- TRUE
  [20:54:49.976]                       }
  [20:54:49.976]                       else if (inherits(cond, "warning")) {
  [20:54:49.976]                         invokeRestart("muffleWarning")
  [20:54:49.976]                         muffled <- TRUE
  [20:54:49.976]                       }
  [20:54:49.976]                       else if (inherits(cond, "condition")) {
  [20:54:49.976]                         computeRestarts <- base::computeRestarts
  [20:54:49.976]                         grepl <- base::grepl
  [20:54:49.976]                         is.null <- base::is.null
  [20:54:49.976]                         restarts <- computeRestarts(cond)
  [20:54:49.976]                         for (restart in restarts) {
  [20:54:49.976]                           name <- restart$name
  [20:54:49.976]                           if (is.null(name)) 
  [20:54:49.976]                             next
  [20:54:49.976]                           if (!grepl("^muffle", name)) 
  [20:54:49.976]                             next
  [20:54:49.976]                           invokeRestart(restart)
  [20:54:49.976]                           muffled <- TRUE
  [20:54:49.976]                           break
  [20:54:49.976]                         }
  [20:54:49.976]                       }
  [20:54:49.976]                       invisible(muffled)
  [20:54:49.976]                     }
  [20:54:49.976]                     muffleCondition(cond)
  [20:54:49.976]                   }
  [20:54:49.976]                 }
  [20:54:49.976]             }
  [20:54:49.976]         }))
  [20:54:49.976]     }, error = function(ex) {
  [20:54:49.976]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:49.976]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:49.976]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:49.976]     }, finally = {
  [20:54:49.976]         {
  [20:54:49.976]             NULL
  [20:54:49.976]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:49.976]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:49.976]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:49.976]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:49.976]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:49.976]                 ...) 
  [20:54:49.976]             {
  [20:54:49.976]                 if (substitute) 
  [20:54:49.976]                   expr <- substitute(expr)
  [20:54:49.976]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:49.976]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:49.976]                   globals = globals, persistent = persistent, 
  [20:54:49.976]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:49.976]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:49.976]                   label = label, ...)
  [20:54:49.976]                 if (!future$lazy) 
  [20:54:49.976]                   future <- run(future)
  [20:54:49.976]                 invisible(future)
  [20:54:49.976]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:49.976]         }
  [20:54:49.976]         base::options(...future.oldOptions)
  [20:54:49.976]     })
  [20:54:49.976]     Sys.time
  [20:54:49.976]     if (base::is.na(TRUE)) {
  [20:54:49.976]     }
  [20:54:49.976]     else {
  [20:54:49.976]         base::sink(type = "output", split = FALSE)
  [20:54:49.976]         if (TRUE) {
  [20:54:49.976]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:49.976]         }
  [20:54:49.976]         else {
  [20:54:49.976]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:49.976]         }
  [20:54:49.976]         base::close(...future.stdout)
  [20:54:49.976]         ...future.stdout <- NULL
  [20:54:49.976]     }
  [20:54:49.976]     ...future.result$conditions <- ...future.conditions
  [20:54:49.976]     ...future.result
  [20:54:49.976] }
  [20:54:49.983] ClusterFuture started
  [20:54:49.993] getGlobalsAndPackages() ...
  [20:54:49.993] Searching for globals...
  [20:54:49.994] 
  [20:54:49.995] Searching for globals ... DONE
  [20:54:49.995] - globals: [0] <none>
  [20:54:49.995] getGlobalsAndPackages() ... DONE
  [20:54:49.999] Packages needed by the future expression (n = 0): <none>
  [20:54:49.999] Packages needed by future strategies (n = 0): <none>
  [20:54:50.004] {
  [20:54:50.004]     {
  [20:54:50.004]         ...future.startTime <- base::Sys.time()
  [20:54:50.004]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.004]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.004]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.004]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.004]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.004]         {
  [20:54:50.004]             {
  [20:54:50.004]                 has_future <- base::requireNamespace("future", 
  [20:54:50.004]                   quietly = TRUE)
  [20:54:50.004]                 version <- if (has_future) 
  [20:54:50.004]                   utils::packageVersion("future")
  [20:54:50.004]                 else NULL
  [20:54:50.004]                 if (!has_future || version < "1.8.0") {
  [20:54:50.004]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.004]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.004]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.004]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.004]                       "release", "version")], collapse = " "), 
  [20:54:50.004]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.004]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.004]                     info)
  [20:54:50.004]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.004]                   if (!has_future) {
  [20:54:50.004]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.004]                       info)
  [20:54:50.004]                   }
  [20:54:50.004]                   else {
  [20:54:50.004]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.004]                       info, version)
  [20:54:50.004]                   }
  [20:54:50.004]                   base::stop(msg)
  [20:54:50.004]                 }
  [20:54:50.004]             }
  [20:54:50.004]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.004]         }
  [20:54:50.004]     }
  [20:54:50.004]     if (base::is.na(TRUE)) {
  [20:54:50.004]     }
  [20:54:50.004]     else {
  [20:54:50.004]         if (TRUE) {
  [20:54:50.004]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.004]                 open = "w")
  [20:54:50.004]         }
  [20:54:50.004]         else {
  [20:54:50.004]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.004]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.004]         }
  [20:54:50.004]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.004]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.004]             base::sink(type = "output", split = FALSE)
  [20:54:50.004]             base::close(...future.stdout)
  [20:54:50.004]         }, add = TRUE)
  [20:54:50.004]     }
  [20:54:50.004]     ...future.frame <- base::sys.nframe()
  [20:54:50.004]     ...future.conditions <- base::list()
  [20:54:50.004]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.004]     ...future.result <- base::tryCatch({
  [20:54:50.004]         base::withCallingHandlers({
  [20:54:50.004]             ...future.value <- base::withVisible(base::local({
  [20:54:50.004]                 ...future.sendCondition <- local({
  [20:54:50.004]                   sendCondition <- NULL
  [20:54:50.004]                   function(frame = 1L) {
  [20:54:50.004]                     if (is.function(sendCondition)) 
  [20:54:50.004]                       return(sendCondition)
  [20:54:50.004]                     ns <- getNamespace("parallel")
  [20:54:50.004]                     if (exists("sendData", mode = "function", 
  [20:54:50.004]                       envir = ns)) {
  [20:54:50.004]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:50.004]                         envir = ns)
  [20:54:50.004]                       envir <- sys.frame(frame)
  [20:54:50.004]                       master <- NULL
  [20:54:50.004]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:50.004]                         !identical(envir, emptyenv())) {
  [20:54:50.004]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:50.004]                           inherits = FALSE)) {
  [20:54:50.004]                           master <- get("master", mode = "list", 
  [20:54:50.004]                             envir = envir, inherits = FALSE)
  [20:54:50.004]                           if (inherits(master, "SOCKnode")) {
  [20:54:50.004]                             sendCondition <<- function(cond) {
  [20:54:50.004]                               data <- list(type = "VALUE", value = cond, 
  [20:54:50.004]                                 success = TRUE)
  [20:54:50.004]                               parallel_sendData(master, data)
  [20:54:50.004]                             }
  [20:54:50.004]                             return(sendCondition)
  [20:54:50.004]                           }
  [20:54:50.004]                         }
  [20:54:50.004]                         frame <- frame + 1L
  [20:54:50.004]                         envir <- sys.frame(frame)
  [20:54:50.004]                       }
  [20:54:50.004]                     }
  [20:54:50.004]                     sendCondition <<- function(cond) NULL
  [20:54:50.004]                   }
  [20:54:50.004]                 })
  [20:54:50.004]                 withCallingHandlers({
  [20:54:50.004]                   NULL
  [20:54:50.004]                 }, immediateCondition = function(cond) {
  [20:54:50.004]                   sendCondition <- ...future.sendCondition()
  [20:54:50.004]                   sendCondition(cond)
  [20:54:50.004]                   muffleCondition <- function (cond) 
  [20:54:50.004]                   {
  [20:54:50.004]                     inherits <- base::inherits
  [20:54:50.004]                     invokeRestart <- base::invokeRestart
  [20:54:50.004]                     muffled <- FALSE
  [20:54:50.004]                     if (inherits(cond, "message")) {
  [20:54:50.004]                       invokeRestart("muffleMessage")
  [20:54:50.004]                       muffled <- TRUE
  [20:54:50.004]                     }
  [20:54:50.004]                     else if (inherits(cond, "warning")) {
  [20:54:50.004]                       invokeRestart("muffleWarning")
  [20:54:50.004]                       muffled <- TRUE
  [20:54:50.004]                     }
  [20:54:50.004]                     else if (inherits(cond, "condition")) {
  [20:54:50.004]                       computeRestarts <- base::computeRestarts
  [20:54:50.004]                       grepl <- base::grepl
  [20:54:50.004]                       is.null <- base::is.null
  [20:54:50.004]                       restarts <- computeRestarts(cond)
  [20:54:50.004]                       for (restart in restarts) {
  [20:54:50.004]                         name <- restart$name
  [20:54:50.004]                         if (is.null(name)) 
  [20:54:50.004]                           next
  [20:54:50.004]                         if (!grepl("^muffle", name)) 
  [20:54:50.004]                           next
  [20:54:50.004]                         invokeRestart(restart)
  [20:54:50.004]                         muffled <- TRUE
  [20:54:50.004]                         break
  [20:54:50.004]                       }
  [20:54:50.004]                     }
  [20:54:50.004]                     invisible(muffled)
  [20:54:50.004]                   }
  [20:54:50.004]                   muffleCondition(cond)
  [20:54:50.004]                 })
  [20:54:50.004]             }))
  [20:54:50.004]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.004]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.004]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.004]                 version = "1.8")
  [20:54:50.004]         }, condition = base::local({
  [20:54:50.004]             c <- base::c
  [20:54:50.004]             inherits <- base::inherits
  [20:54:50.004]             invokeRestart <- base::invokeRestart
  [20:54:50.004]             length <- base::length
  [20:54:50.004]             list <- base::list
  [20:54:50.004]             seq.int <- base::seq.int
  [20:54:50.004]             signalCondition <- base::signalCondition
  [20:54:50.004]             sys.calls <- base::sys.calls
  [20:54:50.004]             Sys.time <- base::Sys.time
  [20:54:50.004]             `[[` <- base::`[[`
  [20:54:50.004]             `+` <- base::`+`
  [20:54:50.004]             `<<-` <- base::`<<-`
  [20:54:50.004]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.004]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.004]                   3L)]
  [20:54:50.004]             }
  [20:54:50.004]             function(cond) {
  [20:54:50.004]                 if (inherits(cond, "error")) {
  [20:54:50.004]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.004]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.004]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.004]                   signalCondition(cond)
  [20:54:50.004]                 }
  [20:54:50.004]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.004]                 ))) {
  [20:54:50.004]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.004]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.004]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.004]                   if (!signal) {
  [20:54:50.004]                     muffleCondition <- function (cond) 
  [20:54:50.004]                     {
  [20:54:50.004]                       inherits <- base::inherits
  [20:54:50.004]                       invokeRestart <- base::invokeRestart
  [20:54:50.004]                       muffled <- FALSE
  [20:54:50.004]                       if (inherits(cond, "message")) {
  [20:54:50.004]                         invokeRestart("muffleMessage")
  [20:54:50.004]                         muffled <- TRUE
  [20:54:50.004]                       }
  [20:54:50.004]                       else if (inherits(cond, "warning")) {
  [20:54:50.004]                         invokeRestart("muffleWarning")
  [20:54:50.004]                         muffled <- TRUE
  [20:54:50.004]                       }
  [20:54:50.004]                       else if (inherits(cond, "condition")) {
  [20:54:50.004]                         computeRestarts <- base::computeRestarts
  [20:54:50.004]                         grepl <- base::grepl
  [20:54:50.004]                         is.null <- base::is.null
  [20:54:50.004]                         restarts <- computeRestarts(cond)
  [20:54:50.004]                         for (restart in restarts) {
  [20:54:50.004]                           name <- restart$name
  [20:54:50.004]                           if (is.null(name)) 
  [20:54:50.004]                             next
  [20:54:50.004]                           if (!grepl("^muffle", name)) 
  [20:54:50.004]                             next
  [20:54:50.004]                           invokeRestart(restart)
  [20:54:50.004]                           muffled <- TRUE
  [20:54:50.004]                           break
  [20:54:50.004]                         }
  [20:54:50.004]                       }
  [20:54:50.004]                       invisible(muffled)
  [20:54:50.004]                     }
  [20:54:50.004]                     muffleCondition(cond)
  [20:54:50.004]                   }
  [20:54:50.004]                 }
  [20:54:50.004]             }
  [20:54:50.004]         }))
  [20:54:50.004]     }, error = function(ex) {
  [20:54:50.004]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.004]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.004]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.004]     }, finally = {
  [20:54:50.004]         {
  [20:54:50.004]             NULL
  [20:54:50.004]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.004]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.004]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:50.004]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:50.004]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:50.004]                 ...) 
  [20:54:50.004]             {
  [20:54:50.004]                 if (substitute) 
  [20:54:50.004]                   expr <- substitute(expr)
  [20:54:50.004]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:50.004]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.004]                   globals = globals, persistent = persistent, 
  [20:54:50.004]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:50.004]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:50.004]                   label = label, ...)
  [20:54:50.004]                 if (!future$lazy) 
  [20:54:50.004]                   future <- run(future)
  [20:54:50.004]                 invisible(future)
  [20:54:50.004]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.004]         }
  [20:54:50.004]         base::options(...future.oldOptions)
  [20:54:50.004]     })
  [20:54:50.004]     Sys.time
  [20:54:50.004]     if (base::is.na(TRUE)) {
  [20:54:50.004]     }
  [20:54:50.004]     else {
  [20:54:50.004]         base::sink(type = "output", split = FALSE)
  [20:54:50.004]         if (TRUE) {
  [20:54:50.004]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.004]         }
  [20:54:50.004]         else {
  [20:54:50.004]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.004]         }
  [20:54:50.004]         base::close(...future.stdout)
  [20:54:50.004]         ...future.stdout <- NULL
  [20:54:50.004]     }
  [20:54:50.004]     ...future.result$conditions <- ...future.conditions
  [20:54:50.004]     ...future.result
  [20:54:50.004] }
  [20:54:50.009] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:50.030] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:50.031] - Validating connection of ClusterFuture
  [20:54:50.031] - received message: FutureResult
  [20:54:50.031] - Received FutureResult
  [20:54:50.032] - Erased future from FutureRegistry
  [20:54:50.032] result() for ClusterFuture ...
  [20:54:50.032] - result already collected: FutureResult
  [20:54:50.033] result() for ClusterFuture ... done
  [20:54:50.033] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:50.033] result() for ClusterFuture ...
  [20:54:50.034] - result already collected: FutureResult
  [20:54:50.034] result() for ClusterFuture ... done
  [20:54:50.034] result() for ClusterFuture ...
  [20:54:50.035] - result already collected: FutureResult
  [20:54:50.035] result() for ClusterFuture ... done
  [20:54:50.037] ClusterFuture started
  [20:54:50.067] getGlobalsAndPackages() ...
  [20:54:50.067] Searching for globals...
  [20:54:50.069] - globals found: [1] '{'
  [20:54:50.069] Searching for globals ... DONE
  [20:54:50.069] Resolving globals: FALSE
  [20:54:50.070] 
  [20:54:50.070] 
  [20:54:50.071] getGlobalsAndPackages() ... DONE
  [20:54:50.074] Packages needed by the future expression (n = 0): <none>
  [20:54:50.075] Packages needed by future strategies (n = 0): <none>
  [20:54:50.096] {
  [20:54:50.096]     {
  [20:54:50.096]         ...future.startTime <- base::Sys.time()
  [20:54:50.096]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.096]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.096]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.096]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.096]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.096]         {
  [20:54:50.096]             {
  [20:54:50.096]                 has_future <- base::requireNamespace("future", 
  [20:54:50.096]                   quietly = TRUE)
  [20:54:50.096]                 version <- if (has_future) 
  [20:54:50.096]                   utils::packageVersion("future")
  [20:54:50.096]                 else NULL
  [20:54:50.096]                 if (!has_future || version < "1.8.0") {
  [20:54:50.096]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.096]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.096]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.096]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.096]                       "release", "version")], collapse = " "), 
  [20:54:50.096]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.096]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.096]                     info)
  [20:54:50.096]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.096]                   if (!has_future) {
  [20:54:50.096]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.096]                       info)
  [20:54:50.096]                   }
  [20:54:50.096]                   else {
  [20:54:50.096]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.096]                       info, version)
  [20:54:50.096]                   }
  [20:54:50.096]                   base::stop(msg)
  [20:54:50.096]                 }
  [20:54:50.096]             }
  [20:54:50.096]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.096]         }
  [20:54:50.096]     }
  [20:54:50.096]     if (base::is.na(TRUE)) {
  [20:54:50.096]     }
  [20:54:50.096]     else {
  [20:54:50.096]         if (TRUE) {
  [20:54:50.096]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.096]                 open = "w")
  [20:54:50.096]         }
  [20:54:50.096]         else {
  [20:54:50.096]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.096]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.096]         }
  [20:54:50.096]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.096]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.096]             base::sink(type = "output", split = FALSE)
  [20:54:50.096]             base::close(...future.stdout)
  [20:54:50.096]         }, add = TRUE)
  [20:54:50.096]     }
  [20:54:50.096]     ...future.frame <- base::sys.nframe()
  [20:54:50.096]     ...future.conditions <- base::list()
  [20:54:50.096]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.096]     ...future.result <- base::tryCatch({
  [20:54:50.096]         base::withCallingHandlers({
  [20:54:50.096]             ...future.value <- base::withVisible(base::local({
  [20:54:50.096]                 ...future.sendCondition <- local({
  [20:54:50.096]                   sendCondition <- NULL
  [20:54:50.096]                   function(frame = 1L) {
  [20:54:50.096]                     if (is.function(sendCondition)) 
  [20:54:50.096]                       return(sendCondition)
  [20:54:50.096]                     ns <- getNamespace("parallel")
  [20:54:50.096]                     if (exists("sendData", mode = "function", 
  [20:54:50.096]                       envir = ns)) {
  [20:54:50.096]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:54:50.096]                         envir = ns)
  [20:54:50.096]                       envir <- sys.frame(frame)
  [20:54:50.096]                       master <- NULL
  [20:54:50.096]                       while (!identical(envir, .GlobalEnv) && 
  [20:54:50.096]                         !identical(envir, emptyenv())) {
  [20:54:50.096]                         if (exists("master", mode = "list", envir = envir, 
  [20:54:50.096]                           inherits = FALSE)) {
  [20:54:50.096]                           master <- get("master", mode = "list", 
  [20:54:50.096]                             envir = envir, inherits = FALSE)
  [20:54:50.096]                           if (inherits(master, "SOCKnode")) {
  [20:54:50.096]                             sendCondition <<- function(cond) {
  [20:54:50.096]                               data <- list(type = "VALUE", value = cond, 
  [20:54:50.096]                                 success = TRUE)
  [20:54:50.096]                               parallel_sendData(master, data)
  [20:54:50.096]                             }
  [20:54:50.096]                             return(sendCondition)
  [20:54:50.096]                           }
  [20:54:50.096]                         }
  [20:54:50.096]                         frame <- frame + 1L
  [20:54:50.096]                         envir <- sys.frame(frame)
  [20:54:50.096]                       }
  [20:54:50.096]                     }
  [20:54:50.096]                     sendCondition <<- function(cond) NULL
  [20:54:50.096]                   }
  [20:54:50.096]                 })
  [20:54:50.096]                 withCallingHandlers({
  [20:54:50.096]                   {
  [20:54:50.096]                     4
  [20:54:50.096]                   }
  [20:54:50.096]                 }, immediateCondition = function(cond) {
  [20:54:50.096]                   sendCondition <- ...future.sendCondition()
  [20:54:50.096]                   sendCondition(cond)
  [20:54:50.096]                   muffleCondition <- function (cond) 
  [20:54:50.096]                   {
  [20:54:50.096]                     inherits <- base::inherits
  [20:54:50.096]                     invokeRestart <- base::invokeRestart
  [20:54:50.096]                     muffled <- FALSE
  [20:54:50.096]                     if (inherits(cond, "message")) {
  [20:54:50.096]                       invokeRestart("muffleMessage")
  [20:54:50.096]                       muffled <- TRUE
  [20:54:50.096]                     }
  [20:54:50.096]                     else if (inherits(cond, "warning")) {
  [20:54:50.096]                       invokeRestart("muffleWarning")
  [20:54:50.096]                       muffled <- TRUE
  [20:54:50.096]                     }
  [20:54:50.096]                     else if (inherits(cond, "condition")) {
  [20:54:50.096]                       computeRestarts <- base::computeRestarts
  [20:54:50.096]                       grepl <- base::grepl
  [20:54:50.096]                       is.null <- base::is.null
  [20:54:50.096]                       restarts <- computeRestarts(cond)
  [20:54:50.096]                       for (restart in restarts) {
  [20:54:50.096]                         name <- restart$name
  [20:54:50.096]                         if (is.null(name)) 
  [20:54:50.096]                           next
  [20:54:50.096]                         if (!grepl("^muffle", name)) 
  [20:54:50.096]                           next
  [20:54:50.096]                         invokeRestart(restart)
  [20:54:50.096]                         muffled <- TRUE
  [20:54:50.096]                         break
  [20:54:50.096]                       }
  [20:54:50.096]                     }
  [20:54:50.096]                     invisible(muffled)
  [20:54:50.096]                   }
  [20:54:50.096]                   muffleCondition(cond)
  [20:54:50.096]                 })
  [20:54:50.096]             }))
  [20:54:50.096]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.096]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.096]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.096]                 version = "1.8")
  [20:54:50.096]         }, condition = base::local({
  [20:54:50.096]             c <- base::c
  [20:54:50.096]             inherits <- base::inherits
  [20:54:50.096]             invokeRestart <- base::invokeRestart
  [20:54:50.096]             length <- base::length
  [20:54:50.096]             list <- base::list
  [20:54:50.096]             seq.int <- base::seq.int
  [20:54:50.096]             signalCondition <- base::signalCondition
  [20:54:50.096]             sys.calls <- base::sys.calls
  [20:54:50.096]             Sys.time <- base::Sys.time
  [20:54:50.096]             `[[` <- base::`[[`
  [20:54:50.096]             `+` <- base::`+`
  [20:54:50.096]             `<<-` <- base::`<<-`
  [20:54:50.096]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.096]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.096]                   3L)]
  [20:54:50.096]             }
  [20:54:50.096]             function(cond) {
  [20:54:50.096]                 if (inherits(cond, "error")) {
  [20:54:50.096]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.096]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.096]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.096]                   signalCondition(cond)
  [20:54:50.096]                 }
  [20:54:50.096]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.096]                 ))) {
  [20:54:50.096]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.096]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.096]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.096]                   if (!signal) {
  [20:54:50.096]                     muffleCondition <- function (cond) 
  [20:54:50.096]                     {
  [20:54:50.096]                       inherits <- base::inherits
  [20:54:50.096]                       invokeRestart <- base::invokeRestart
  [20:54:50.096]                       muffled <- FALSE
  [20:54:50.096]                       if (inherits(cond, "message")) {
  [20:54:50.096]                         invokeRestart("muffleMessage")
  [20:54:50.096]                         muffled <- TRUE
  [20:54:50.096]                       }
  [20:54:50.096]                       else if (inherits(cond, "warning")) {
  [20:54:50.096]                         invokeRestart("muffleWarning")
  [20:54:50.096]                         muffled <- TRUE
  [20:54:50.096]                       }
  [20:54:50.096]                       else if (inherits(cond, "condition")) {
  [20:54:50.096]                         computeRestarts <- base::computeRestarts
  [20:54:50.096]                         grepl <- base::grepl
  [20:54:50.096]                         is.null <- base::is.null
  [20:54:50.096]                         restarts <- computeRestarts(cond)
  [20:54:50.096]                         for (restart in restarts) {
  [20:54:50.096]                           name <- restart$name
  [20:54:50.096]                           if (is.null(name)) 
  [20:54:50.096]                             next
  [20:54:50.096]                           if (!grepl("^muffle", name)) 
  [20:54:50.096]                             next
  [20:54:50.096]                           invokeRestart(restart)
  [20:54:50.096]                           muffled <- TRUE
  [20:54:50.096]                           break
  [20:54:50.096]                         }
  [20:54:50.096]                       }
  [20:54:50.096]                       invisible(muffled)
  [20:54:50.096]                     }
  [20:54:50.096]                     muffleCondition(cond)
  [20:54:50.096]                   }
  [20:54:50.096]                 }
  [20:54:50.096]             }
  [20:54:50.096]         }))
  [20:54:50.096]     }, error = function(ex) {
  [20:54:50.096]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.096]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.096]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.096]     }, finally = {
  [20:54:50.096]         {
  [20:54:50.096]             NULL
  [20:54:50.096]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.096]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.096]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:54:50.096]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:54:50.096]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:54:50.096]                 ...) 
  [20:54:50.096]             {
  [20:54:50.096]                 if (substitute) 
  [20:54:50.096]                   expr <- substitute(expr)
  [20:54:50.096]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:54:50.096]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.096]                   globals = globals, persistent = persistent, 
  [20:54:50.096]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:54:50.096]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:54:50.096]                   label = label, ...)
  [20:54:50.096]                 if (!future$lazy) 
  [20:54:50.096]                   future <- run(future)
  [20:54:50.096]                 invisible(future)
  [20:54:50.096]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.096]         }
  [20:54:50.096]         base::options(...future.oldOptions)
  [20:54:50.096]     })
  [20:54:50.096]     Sys.time
  [20:54:50.096]     if (base::is.na(TRUE)) {
  [20:54:50.096]     }
  [20:54:50.096]     else {
  [20:54:50.096]         base::sink(type = "output", split = FALSE)
  [20:54:50.096]         if (TRUE) {
  [20:54:50.096]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.096]         }
  [20:54:50.096]         else {
  [20:54:50.096]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.096]         }
  [20:54:50.096]         base::close(...future.stdout)
  [20:54:50.096]         ...future.stdout <- NULL
  [20:54:50.096]     }
  [20:54:50.096]     ...future.result$conditions <- ...future.conditions
  [20:54:50.096]     ...future.result
  [20:54:50.096] }
  [20:54:50.100] Poll #1 (0): usedNodes() = 1, workers = 1
  [20:54:50.113] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:50.113] - Validating connection of ClusterFuture
  [20:54:50.114] - received message: FutureResult
  [20:54:50.114] - Received FutureResult
  [20:54:50.114] - Erased future from FutureRegistry
  [20:54:50.115] result() for ClusterFuture ...
  [20:54:50.115] - result already collected: FutureResult
  [20:54:50.115] result() for ClusterFuture ... done
  [20:54:50.116] receiveMessageFromWorker() for ClusterFuture ... done
  [20:54:50.116] result() for ClusterFuture ...
  [20:54:50.117] - result already collected: FutureResult
  [20:54:50.117] result() for ClusterFuture ... done
  [20:54:50.117] result() for ClusterFuture ...
  [20:54:50.118] - result already collected: FutureResult
  [20:54:50.118] result() for ClusterFuture ... done
  [20:54:50.121] ClusterFuture started
  <environment: 0x556b0ff7de88> 
  <environment: 0x556b10344e40> 
  [20:54:50.166] receiveMessageFromWorker() for ClusterFuture ...
  [20:54:50.166] - Validating connection of ClusterFuture
  [20:54:50.167] - received message: FutureResult
  [20:54:50.167] - Received FutureResult
  [20:54:50.167] - Erased future from FutureRegistry
  [20:54:50.168] result() for ClusterFuture ...
  [20:54:50.168] - result already collected: FutureResult
  [20:54:50.168] result() for ClusterFuture ... done
  [20:54:50.168] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [20:54:50.172] resolve() on environment ...
  [20:54:50.172]  recursive: 0
  [20:54:50.174]  elements: [4] 'a', 'b', 'c', 'd'
  [20:54:50.174] signalConditionsASAP(numeric, pos=1) ...
  [20:54:50.174] - nx: 4
  [20:54:50.174] - relay: TRUE
  [20:54:50.175] - stdout: TRUE
  [20:54:50.175] - signal: TRUE
  [20:54:50.175] - resignal: FALSE
  [20:54:50.175] - force: TRUE
  [20:54:50.176] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:50.176] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:50.176]  - until=2
  [20:54:50.177]  - relaying element #2
  [20:54:50.177] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:50.177] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:50.177] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:50.188]  length: 3 (resolved future 1)
  [20:54:50.188] Future #2
  [20:54:50.189] result() for ClusterFuture ...
  [20:54:50.189] - result already collected: FutureResult
  [20:54:50.189] result() for ClusterFuture ... done
  [20:54:50.190] result() for ClusterFuture ...
  [20:54:50.190] - result already collected: FutureResult
  [20:54:50.190] result() for ClusterFuture ... done
  [20:54:50.191] signalConditionsASAP(ClusterFuture, pos=2) ...
  [20:54:50.191] - nx: 4
  [20:54:50.191] - relay: TRUE
  [20:54:50.192] - stdout: TRUE
  [20:54:50.192] - signal: TRUE
  [20:54:50.206] - resignal: FALSE
  [20:54:50.206] - force: TRUE
  [20:54:50.206] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [20:54:50.207] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [20:54:50.207]  - until=2
  [20:54:50.207]  - relaying element #2
  [20:54:50.208] result() for ClusterFuture ...
  [20:54:50.208] - result already collected: FutureResult
  [20:54:50.208] result() for ClusterFuture ... done
  [20:54:50.209] result() for ClusterFuture ...
  [20:54:50.209] - result already collected: FutureResult
  [20:54:50.209] result() for ClusterFuture ... done
  [20:54:50.210] result() for ClusterFuture ...
  [20:54:50.210] - result already collected: FutureResult
  [20:54:50.210] result() for ClusterFuture ... done
  [20:54:50.211] result() for ClusterFuture ...
  [20:54:50.211] - result already collected: FutureResult
  [20:54:50.211] result() for ClusterFuture ... done
  [20:54:50.211] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:50.212] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:50.212] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [20:54:50.232]  length: 2 (resolved future 2)
  [20:54:50.232] Future #3
  [20:54:50.233] result() for ClusterFuture ...
  [20:54:50.233] - result already collected: FutureResult
  [20:54:50.233] result() for ClusterFuture ... done
  [20:54:50.233] result() for ClusterFuture ...
  [20:54:50.234] - result already collected: FutureResult
  [20:54:50.234] result() for ClusterFuture ... done
  [20:54:50.234] signalConditionsASAP(ClusterFuture, pos=3) ...
  [20:54:50.235] - nx: 4
  [20:54:50.235] - relay: TRUE
  [20:54:50.235] - stdout: TRUE
  [20:54:50.235] - signal: TRUE
  [20:54:50.236] - resignal: FALSE
  [20:54:50.236] - force: TRUE
  [20:54:50.236] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [20:54:50.236] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [20:54:50.237]  - until=3
  [20:54:50.237]  - relaying element #3
  [20:54:50.237] result() for ClusterFuture ...
  [20:54:50.237] - result already collected: FutureResult
  [20:54:50.238] result() for ClusterFuture ... done
  [20:54:50.238] result() for ClusterFuture ...
  [20:54:50.238] - result already collected: FutureResult
  [20:54:50.239] result() for ClusterFuture ... done
  [20:54:50.239] result() for ClusterFuture ...
  [20:54:50.239] - result already collected: FutureResult
  [20:54:50.239] result() for ClusterFuture ... done
  [20:54:50.240] result() for ClusterFuture ...
  [20:54:50.240] - result already collected: FutureResult
  [20:54:50.240] result() for ClusterFuture ... done
  [20:54:50.240] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:50.241] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:50.241] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [20:54:50.241]  length: 1 (resolved future 3)
  [20:54:50.242] Future #4
  [20:54:50.242] result() for ClusterFuture ...
  [20:54:50.242] - result already collected: FutureResult
  [20:54:50.242] result() for ClusterFuture ... done
  [20:54:50.243] result() for ClusterFuture ...
  [20:54:50.243] - result already collected: FutureResult
  [20:54:50.243] result() for ClusterFuture ... done
  [20:54:50.243] signalConditionsASAP(ClusterFuture, pos=4) ...
  [20:54:50.244] - nx: 4
  [20:54:50.244] - relay: TRUE
  [20:54:50.244] - stdout: TRUE
  [20:54:50.244] - signal: TRUE
  [20:54:50.244] - resignal: FALSE
  [20:54:50.245] - force: TRUE
  [20:54:50.245] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [20:54:50.245] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [20:54:50.245]  - until=4
  [20:54:50.274]  - relaying element #4
  [20:54:50.274] result() for ClusterFuture ...
  [20:54:50.275] - result already collected: FutureResult
  [20:54:50.275] result() for ClusterFuture ... done
  [20:54:50.275] result() for ClusterFuture ...
  [20:54:50.276] - result already collected: FutureResult
  [20:54:50.276] result() for ClusterFuture ... done
  [20:54:50.276] result() for ClusterFuture ...
  [20:54:50.277] - result already collected: FutureResult
  [20:54:50.277] result() for ClusterFuture ... done
  [20:54:50.277] result() for ClusterFuture ...
  [20:54:50.278] - result already collected: FutureResult
  [20:54:50.278] result() for ClusterFuture ... done
  [20:54:50.278] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:50.278] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:50.279] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [20:54:50.279]  length: 0 (resolved future 4)
  [20:54:50.279] Relaying remaining futures
  [20:54:50.280] signalConditionsASAP(NULL, pos=0) ...
  [20:54:50.280] - nx: 4
  [20:54:50.280] - relay: TRUE
  [20:54:50.280] - stdout: TRUE
  [20:54:50.281] - signal: TRUE
  [20:54:50.281] - resignal: FALSE
  [20:54:50.281] - force: TRUE
  [20:54:50.281] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:50.282] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [20:54:50.282] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [20:54:50.283] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [20:54:50.283] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:50.283] resolve() on environment ... DONE
  [20:54:50.283] result() for ClusterFuture ...
  [20:54:50.284] - result already collected: FutureResult
  [20:54:50.284] result() for ClusterFuture ... done
  [20:54:50.284] result() for ClusterFuture ...
  [20:54:50.285] - result already collected: FutureResult
  [20:54:50.285] result() for ClusterFuture ... done
  [20:54:50.285] result() for ClusterFuture ...
  [20:54:50.286] - result already collected: FutureResult
  [20:54:50.286] result() for ClusterFuture ... done
  [20:54:50.286] result() for ClusterFuture ...
  [20:54:50.286] - result already collected: FutureResult
  [20:54:50.287] result() for ClusterFuture ... done
  [20:54:50.287] result() for ClusterFuture ...
  [20:54:50.287] - result already collected: FutureResult
  [20:54:50.288] result() for ClusterFuture ... done
  [20:54:50.288] result() for ClusterFuture ...
  [20:54:50.288] - result already collected: FutureResult
  [20:54:50.289] result() for ClusterFuture ... done
  <environment: 0x556b11417370> 
  *** futures() - environment ... DONE
  Type of object: listenv
  Type of future: sequential
  [20:54:50.307] plan(): Setting new future strategy stack:
  [20:54:50.307] List of future strategies:
  [20:54:50.307] 1. sequential:
  [20:54:50.307]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.307]    - tweaked: FALSE
  [20:54:50.307]    - call: plan(strategy)
  [20:54:50.309] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [20:54:50.310] getGlobalsAndPackages() ...
  [20:54:50.310] Searching for globals...
  [20:54:50.311] 
  [20:54:50.311] Searching for globals ... DONE
  [20:54:50.312] - globals: [0] <none>
  [20:54:50.312] getGlobalsAndPackages() ... DONE
  [20:54:50.314] Packages needed by the future expression (n = 0): <none>
  [20:54:50.314] Packages needed by future strategies (n = 0): <none>
  [20:54:50.340] {
  [20:54:50.340]     {
  [20:54:50.340]         ...future.startTime <- base::Sys.time()
  [20:54:50.340]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.340]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.340]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.340]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.340]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.340]         {
  [20:54:50.340]             {
  [20:54:50.340]                 has_future <- base::requireNamespace("future", 
  [20:54:50.340]                   quietly = TRUE)
  [20:54:50.340]                 version <- if (has_future) 
  [20:54:50.340]                   utils::packageVersion("future")
  [20:54:50.340]                 else NULL
  [20:54:50.340]                 if (!has_future || version < "1.8.0") {
  [20:54:50.340]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.340]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.340]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.340]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.340]                       "release", "version")], collapse = " "), 
  [20:54:50.340]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.340]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.340]                     info)
  [20:54:50.340]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.340]                   if (!has_future) {
  [20:54:50.340]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.340]                       info)
  [20:54:50.340]                   }
  [20:54:50.340]                   else {
  [20:54:50.340]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.340]                       info, version)
  [20:54:50.340]                   }
  [20:54:50.340]                   base::stop(msg)
  [20:54:50.340]                 }
  [20:54:50.340]             }
  [20:54:50.340]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.340]         }
  [20:54:50.340]     }
  [20:54:50.340]     if (base::is.na(TRUE)) {
  [20:54:50.340]     }
  [20:54:50.340]     else {
  [20:54:50.340]         if (TRUE) {
  [20:54:50.340]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.340]                 open = "w")
  [20:54:50.340]         }
  [20:54:50.340]         else {
  [20:54:50.340]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.340]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.340]         }
  [20:54:50.340]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.340]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.340]             base::sink(type = "output", split = FALSE)
  [20:54:50.340]             base::close(...future.stdout)
  [20:54:50.340]         }, add = TRUE)
  [20:54:50.340]     }
  [20:54:50.340]     ...future.frame <- base::sys.nframe()
  [20:54:50.340]     ...future.conditions <- base::list()
  [20:54:50.340]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.340]     ...future.result <- base::tryCatch({
  [20:54:50.340]         base::withCallingHandlers({
  [20:54:50.340]             ...future.value <- base::withVisible(base::local(2))
  [20:54:50.340]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.340]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.340]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.340]                 version = "1.8")
  [20:54:50.340]         }, condition = base::local({
  [20:54:50.340]             c <- base::c
  [20:54:50.340]             inherits <- base::inherits
  [20:54:50.340]             invokeRestart <- base::invokeRestart
  [20:54:50.340]             length <- base::length
  [20:54:50.340]             list <- base::list
  [20:54:50.340]             seq.int <- base::seq.int
  [20:54:50.340]             signalCondition <- base::signalCondition
  [20:54:50.340]             sys.calls <- base::sys.calls
  [20:54:50.340]             Sys.time <- base::Sys.time
  [20:54:50.340]             `[[` <- base::`[[`
  [20:54:50.340]             `+` <- base::`+`
  [20:54:50.340]             `<<-` <- base::`<<-`
  [20:54:50.340]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.340]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.340]                   3L)]
  [20:54:50.340]             }
  [20:54:50.340]             function(cond) {
  [20:54:50.340]                 if (inherits(cond, "error")) {
  [20:54:50.340]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.340]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.340]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.340]                   signalCondition(cond)
  [20:54:50.340]                 }
  [20:54:50.340]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.340]                 ))) {
  [20:54:50.340]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.340]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.340]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.340]                   if (!signal) {
  [20:54:50.340]                     muffleCondition <- function (cond) 
  [20:54:50.340]                     {
  [20:54:50.340]                       inherits <- base::inherits
  [20:54:50.340]                       invokeRestart <- base::invokeRestart
  [20:54:50.340]                       muffled <- FALSE
  [20:54:50.340]                       if (inherits(cond, "message")) {
  [20:54:50.340]                         invokeRestart("muffleMessage")
  [20:54:50.340]                         muffled <- TRUE
  [20:54:50.340]                       }
  [20:54:50.340]                       else if (inherits(cond, "warning")) {
  [20:54:50.340]                         invokeRestart("muffleWarning")
  [20:54:50.340]                         muffled <- TRUE
  [20:54:50.340]                       }
  [20:54:50.340]                       else if (inherits(cond, "condition")) {
  [20:54:50.340]                         computeRestarts <- base::computeRestarts
  [20:54:50.340]                         grepl <- base::grepl
  [20:54:50.340]                         is.null <- base::is.null
  [20:54:50.340]                         restarts <- computeRestarts(cond)
  [20:54:50.340]                         for (restart in restarts) {
  [20:54:50.340]                           name <- restart$name
  [20:54:50.340]                           if (is.null(name)) 
  [20:54:50.340]                             next
  [20:54:50.340]                           if (!grepl("^muffle", name)) 
  [20:54:50.340]                             next
  [20:54:50.340]                           invokeRestart(restart)
  [20:54:50.340]                           muffled <- TRUE
  [20:54:50.340]                           break
  [20:54:50.340]                         }
  [20:54:50.340]                       }
  [20:54:50.340]                       invisible(muffled)
  [20:54:50.340]                     }
  [20:54:50.340]                     muffleCondition(cond)
  [20:54:50.340]                   }
  [20:54:50.340]                 }
  [20:54:50.340]             }
  [20:54:50.340]         }))
  [20:54:50.340]     }, error = function(ex) {
  [20:54:50.340]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.340]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.340]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.340]     }, finally = {
  [20:54:50.340]         {
  [20:54:50.340]             NULL
  [20:54:50.340]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.340]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.340]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.340]                 label = NULL, ...) 
  [20:54:50.340]             {
  [20:54:50.340]                 if (substitute) 
  [20:54:50.340]                   expr <- substitute(expr)
  [20:54:50.340]                 local <- as.logical(local)
  [20:54:50.340]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.340]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.340]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.340]                   label = label, ...)
  [20:54:50.340]                 if (!future$lazy) 
  [20:54:50.340]                   future <- run(future)
  [20:54:50.340]                 invisible(future)
  [20:54:50.340]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.340]         }
  [20:54:50.340]         base::options(...future.oldOptions)
  [20:54:50.340]     })
  [20:54:50.340]     Sys.time
  [20:54:50.340]     if (base::is.na(TRUE)) {
  [20:54:50.340]     }
  [20:54:50.340]     else {
  [20:54:50.340]         base::sink(type = "output", split = FALSE)
  [20:54:50.340]         if (TRUE) {
  [20:54:50.340]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.340]         }
  [20:54:50.340]         else {
  [20:54:50.340]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.340]         }
  [20:54:50.340]         base::close(...future.stdout)
  [20:54:50.340]         ...future.stdout <- NULL
  [20:54:50.340]     }
  [20:54:50.340]     ...future.result$conditions <- ...future.conditions
  [20:54:50.340]     ...future.result
  [20:54:50.340] }
  [20:54:50.352] plan(): Setting new future strategy stack:
  [20:54:50.353] List of future strategies:
  [20:54:50.353] 1. sequential:
  [20:54:50.353]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.353]    - tweaked: FALSE
  [20:54:50.353]    - call: NULL
  [20:54:50.371] plan(): nbrOfWorkers() = 1
  [20:54:50.373] plan(): Setting new future strategy stack:
  [20:54:50.373] List of future strategies:
  [20:54:50.373] 1. sequential:
  [20:54:50.373]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.373]    - tweaked: FALSE
  [20:54:50.373]    - call: plan(strategy)
  [20:54:50.375] plan(): nbrOfWorkers() = 1
  [20:54:50.376] SequentialFuture started (and completed)
  [20:54:50.377] getGlobalsAndPackages() ...
  [20:54:50.377] Searching for globals...
  [20:54:50.443] 
  [20:54:50.444] Searching for globals ... DONE
  [20:54:50.444] - globals: [0] <none>
  [20:54:50.444] getGlobalsAndPackages() ... DONE
  [20:54:50.446] Packages needed by the future expression (n = 0): <none>
  [20:54:50.447] Packages needed by future strategies (n = 0): <none>
  [20:54:50.468] {
  [20:54:50.468]     {
  [20:54:50.468]         ...future.startTime <- base::Sys.time()
  [20:54:50.468]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.468]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.468]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.468]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.468]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.468]         {
  [20:54:50.468]             {
  [20:54:50.468]                 has_future <- base::requireNamespace("future", 
  [20:54:50.468]                   quietly = TRUE)
  [20:54:50.468]                 version <- if (has_future) 
  [20:54:50.468]                   utils::packageVersion("future")
  [20:54:50.468]                 else NULL
  [20:54:50.468]                 if (!has_future || version < "1.8.0") {
  [20:54:50.468]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.468]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.468]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.468]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.468]                       "release", "version")], collapse = " "), 
  [20:54:50.468]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.468]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.468]                     info)
  [20:54:50.468]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.468]                   if (!has_future) {
  [20:54:50.468]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.468]                       info)
  [20:54:50.468]                   }
  [20:54:50.468]                   else {
  [20:54:50.468]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.468]                       info, version)
  [20:54:50.468]                   }
  [20:54:50.468]                   base::stop(msg)
  [20:54:50.468]                 }
  [20:54:50.468]             }
  [20:54:50.468]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.468]         }
  [20:54:50.468]     }
  [20:54:50.468]     if (base::is.na(TRUE)) {
  [20:54:50.468]     }
  [20:54:50.468]     else {
  [20:54:50.468]         if (TRUE) {
  [20:54:50.468]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.468]                 open = "w")
  [20:54:50.468]         }
  [20:54:50.468]         else {
  [20:54:50.468]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.468]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.468]         }
  [20:54:50.468]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.468]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.468]             base::sink(type = "output", split = FALSE)
  [20:54:50.468]             base::close(...future.stdout)
  [20:54:50.468]         }, add = TRUE)
  [20:54:50.468]     }
  [20:54:50.468]     ...future.frame <- base::sys.nframe()
  [20:54:50.468]     ...future.conditions <- base::list()
  [20:54:50.468]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.468]     ...future.result <- base::tryCatch({
  [20:54:50.468]         base::withCallingHandlers({
  [20:54:50.468]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:50.468]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.468]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.468]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.468]                 version = "1.8")
  [20:54:50.468]         }, condition = base::local({
  [20:54:50.468]             c <- base::c
  [20:54:50.468]             inherits <- base::inherits
  [20:54:50.468]             invokeRestart <- base::invokeRestart
  [20:54:50.468]             length <- base::length
  [20:54:50.468]             list <- base::list
  [20:54:50.468]             seq.int <- base::seq.int
  [20:54:50.468]             signalCondition <- base::signalCondition
  [20:54:50.468]             sys.calls <- base::sys.calls
  [20:54:50.468]             Sys.time <- base::Sys.time
  [20:54:50.468]             `[[` <- base::`[[`
  [20:54:50.468]             `+` <- base::`+`
  [20:54:50.468]             `<<-` <- base::`<<-`
  [20:54:50.468]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.468]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.468]                   3L)]
  [20:54:50.468]             }
  [20:54:50.468]             function(cond) {
  [20:54:50.468]                 if (inherits(cond, "error")) {
  [20:54:50.468]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.468]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.468]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.468]                   signalCondition(cond)
  [20:54:50.468]                 }
  [20:54:50.468]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.468]                 ))) {
  [20:54:50.468]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.468]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.468]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.468]                   if (!signal) {
  [20:54:50.468]                     muffleCondition <- function (cond) 
  [20:54:50.468]                     {
  [20:54:50.468]                       inherits <- base::inherits
  [20:54:50.468]                       invokeRestart <- base::invokeRestart
  [20:54:50.468]                       muffled <- FALSE
  [20:54:50.468]                       if (inherits(cond, "message")) {
  [20:54:50.468]                         invokeRestart("muffleMessage")
  [20:54:50.468]                         muffled <- TRUE
  [20:54:50.468]                       }
  [20:54:50.468]                       else if (inherits(cond, "warning")) {
  [20:54:50.468]                         invokeRestart("muffleWarning")
  [20:54:50.468]                         muffled <- TRUE
  [20:54:50.468]                       }
  [20:54:50.468]                       else if (inherits(cond, "condition")) {
  [20:54:50.468]                         computeRestarts <- base::computeRestarts
  [20:54:50.468]                         grepl <- base::grepl
  [20:54:50.468]                         is.null <- base::is.null
  [20:54:50.468]                         restarts <- computeRestarts(cond)
  [20:54:50.468]                         for (restart in restarts) {
  [20:54:50.468]                           name <- restart$name
  [20:54:50.468]                           if (is.null(name)) 
  [20:54:50.468]                             next
  [20:54:50.468]                           if (!grepl("^muffle", name)) 
  [20:54:50.468]                             next
  [20:54:50.468]                           invokeRestart(restart)
  [20:54:50.468]                           muffled <- TRUE
  [20:54:50.468]                           break
  [20:54:50.468]                         }
  [20:54:50.468]                       }
  [20:54:50.468]                       invisible(muffled)
  [20:54:50.468]                     }
  [20:54:50.468]                     muffleCondition(cond)
  [20:54:50.468]                   }
  [20:54:50.468]                 }
  [20:54:50.468]             }
  [20:54:50.468]         }))
  [20:54:50.468]     }, error = function(ex) {
  [20:54:50.468]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.468]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.468]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.468]     }, finally = {
  [20:54:50.468]         {
  [20:54:50.468]             NULL
  [20:54:50.468]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.468]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.468]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.468]                 label = NULL, ...) 
  [20:54:50.468]             {
  [20:54:50.468]                 if (substitute) 
  [20:54:50.468]                   expr <- substitute(expr)
  [20:54:50.468]                 local <- as.logical(local)
  [20:54:50.468]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.468]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.468]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.468]                   label = label, ...)
  [20:54:50.468]                 if (!future$lazy) 
  [20:54:50.468]                   future <- run(future)
  [20:54:50.468]                 invisible(future)
  [20:54:50.468]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.468]         }
  [20:54:50.468]         base::options(...future.oldOptions)
  [20:54:50.468]     })
  [20:54:50.468]     Sys.time
  [20:54:50.468]     if (base::is.na(TRUE)) {
  [20:54:50.468]     }
  [20:54:50.468]     else {
  [20:54:50.468]         base::sink(type = "output", split = FALSE)
  [20:54:50.468]         if (TRUE) {
  [20:54:50.468]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.468]         }
  [20:54:50.468]         else {
  [20:54:50.468]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.468]         }
  [20:54:50.468]         base::close(...future.stdout)
  [20:54:50.468]         ...future.stdout <- NULL
  [20:54:50.468]     }
  [20:54:50.468]     ...future.result$conditions <- ...future.conditions
  [20:54:50.468]     ...future.result
  [20:54:50.468] }
  [20:54:50.473] plan(): Setting new future strategy stack:
  [20:54:50.474] List of future strategies:
  [20:54:50.474] 1. sequential:
  [20:54:50.474]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.474]    - tweaked: FALSE
  [20:54:50.474]    - call: NULL
  [20:54:50.475] plan(): nbrOfWorkers() = 1
  [20:54:50.476] plan(): Setting new future strategy stack:
  [20:54:50.476] List of future strategies:
  [20:54:50.476] 1. sequential:
  [20:54:50.476]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.476]    - tweaked: FALSE
  [20:54:50.476]    - call: plan(strategy)
  [20:54:50.477] plan(): nbrOfWorkers() = 1
  [20:54:50.478] SequentialFuture started (and completed)
  [20:54:50.479] getGlobalsAndPackages() ...
  [20:54:50.480] Searching for globals...
  [20:54:50.481] - globals found: [1] '{'
  [20:54:50.498] Searching for globals ... DONE
  [20:54:50.498] Resolving globals: FALSE
  [20:54:50.499] 
  [20:54:50.499] 
  [20:54:50.500] getGlobalsAndPackages() ... DONE
  [20:54:50.502] Packages needed by the future expression (n = 0): <none>
  [20:54:50.502] Packages needed by future strategies (n = 0): <none>
  [20:54:50.507] {
  [20:54:50.507]     {
  [20:54:50.507]         ...future.startTime <- base::Sys.time()
  [20:54:50.507]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.507]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.507]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.507]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.507]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.507]         {
  [20:54:50.507]             {
  [20:54:50.507]                 has_future <- base::requireNamespace("future", 
  [20:54:50.507]                   quietly = TRUE)
  [20:54:50.507]                 version <- if (has_future) 
  [20:54:50.507]                   utils::packageVersion("future")
  [20:54:50.507]                 else NULL
  [20:54:50.507]                 if (!has_future || version < "1.8.0") {
  [20:54:50.507]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.507]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.507]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.507]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.507]                       "release", "version")], collapse = " "), 
  [20:54:50.507]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.507]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.507]                     info)
  [20:54:50.507]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.507]                   if (!has_future) {
  [20:54:50.507]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.507]                       info)
  [20:54:50.507]                   }
  [20:54:50.507]                   else {
  [20:54:50.507]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.507]                       info, version)
  [20:54:50.507]                   }
  [20:54:50.507]                   base::stop(msg)
  [20:54:50.507]                 }
  [20:54:50.507]             }
  [20:54:50.507]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.507]         }
  [20:54:50.507]     }
  [20:54:50.507]     if (base::is.na(TRUE)) {
  [20:54:50.507]     }
  [20:54:50.507]     else {
  [20:54:50.507]         if (TRUE) {
  [20:54:50.507]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.507]                 open = "w")
  [20:54:50.507]         }
  [20:54:50.507]         else {
  [20:54:50.507]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.507]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.507]         }
  [20:54:50.507]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.507]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.507]             base::sink(type = "output", split = FALSE)
  [20:54:50.507]             base::close(...future.stdout)
  [20:54:50.507]         }, add = TRUE)
  [20:54:50.507]     }
  [20:54:50.507]     ...future.frame <- base::sys.nframe()
  [20:54:50.507]     ...future.conditions <- base::list()
  [20:54:50.507]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.507]     ...future.result <- base::tryCatch({
  [20:54:50.507]         base::withCallingHandlers({
  [20:54:50.507]             ...future.value <- base::withVisible(base::local({
  [20:54:50.507]                 4
  [20:54:50.507]             }))
  [20:54:50.507]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.507]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.507]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.507]                 version = "1.8")
  [20:54:50.507]         }, condition = base::local({
  [20:54:50.507]             c <- base::c
  [20:54:50.507]             inherits <- base::inherits
  [20:54:50.507]             invokeRestart <- base::invokeRestart
  [20:54:50.507]             length <- base::length
  [20:54:50.507]             list <- base::list
  [20:54:50.507]             seq.int <- base::seq.int
  [20:54:50.507]             signalCondition <- base::signalCondition
  [20:54:50.507]             sys.calls <- base::sys.calls
  [20:54:50.507]             Sys.time <- base::Sys.time
  [20:54:50.507]             `[[` <- base::`[[`
  [20:54:50.507]             `+` <- base::`+`
  [20:54:50.507]             `<<-` <- base::`<<-`
  [20:54:50.507]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.507]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.507]                   3L)]
  [20:54:50.507]             }
  [20:54:50.507]             function(cond) {
  [20:54:50.507]                 if (inherits(cond, "error")) {
  [20:54:50.507]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.507]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.507]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.507]                   signalCondition(cond)
  [20:54:50.507]                 }
  [20:54:50.507]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.507]                 ))) {
  [20:54:50.507]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.507]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.507]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.507]                   if (!signal) {
  [20:54:50.507]                     muffleCondition <- function (cond) 
  [20:54:50.507]                     {
  [20:54:50.507]                       inherits <- base::inherits
  [20:54:50.507]                       invokeRestart <- base::invokeRestart
  [20:54:50.507]                       muffled <- FALSE
  [20:54:50.507]                       if (inherits(cond, "message")) {
  [20:54:50.507]                         invokeRestart("muffleMessage")
  [20:54:50.507]                         muffled <- TRUE
  [20:54:50.507]                       }
  [20:54:50.507]                       else if (inherits(cond, "warning")) {
  [20:54:50.507]                         invokeRestart("muffleWarning")
  [20:54:50.507]                         muffled <- TRUE
  [20:54:50.507]                       }
  [20:54:50.507]                       else if (inherits(cond, "condition")) {
  [20:54:50.507]                         computeRestarts <- base::computeRestarts
  [20:54:50.507]                         grepl <- base::grepl
  [20:54:50.507]                         is.null <- base::is.null
  [20:54:50.507]                         restarts <- computeRestarts(cond)
  [20:54:50.507]                         for (restart in restarts) {
  [20:54:50.507]                           name <- restart$name
  [20:54:50.507]                           if (is.null(name)) 
  [20:54:50.507]                             next
  [20:54:50.507]                           if (!grepl("^muffle", name)) 
  [20:54:50.507]                             next
  [20:54:50.507]                           invokeRestart(restart)
  [20:54:50.507]                           muffled <- TRUE
  [20:54:50.507]                           break
  [20:54:50.507]                         }
  [20:54:50.507]                       }
  [20:54:50.507]                       invisible(muffled)
  [20:54:50.507]                     }
  [20:54:50.507]                     muffleCondition(cond)
  [20:54:50.507]                   }
  [20:54:50.507]                 }
  [20:54:50.507]             }
  [20:54:50.507]         }))
  [20:54:50.507]     }, error = function(ex) {
  [20:54:50.507]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.507]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.507]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.507]     }, finally = {
  [20:54:50.507]         {
  [20:54:50.507]             NULL
  [20:54:50.507]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.507]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.507]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.507]                 label = NULL, ...) 
  [20:54:50.507]             {
  [20:54:50.507]                 if (substitute) 
  [20:54:50.507]                   expr <- substitute(expr)
  [20:54:50.507]                 local <- as.logical(local)
  [20:54:50.507]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.507]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.507]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.507]                   label = label, ...)
  [20:54:50.507]                 if (!future$lazy) 
  [20:54:50.507]                   future <- run(future)
  [20:54:50.507]                 invisible(future)
  [20:54:50.507]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.507]         }
  [20:54:50.507]         base::options(...future.oldOptions)
  [20:54:50.507]     })
  [20:54:50.507]     Sys.time
  [20:54:50.507]     if (base::is.na(TRUE)) {
  [20:54:50.507]     }
  [20:54:50.507]     else {
  [20:54:50.507]         base::sink(type = "output", split = FALSE)
  [20:54:50.507]         if (TRUE) {
  [20:54:50.507]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.507]         }
  [20:54:50.507]         else {
  [20:54:50.507]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.507]         }
  [20:54:50.507]         base::close(...future.stdout)
  [20:54:50.507]         ...future.stdout <- NULL
  [20:54:50.507]     }
  [20:54:50.507]     ...future.result$conditions <- ...future.conditions
  [20:54:50.507]     ...future.result
  [20:54:50.507] }
  [20:54:50.511] plan(): Setting new future strategy stack:
  [20:54:50.511] List of future strategies:
  [20:54:50.511] 1. sequential:
  [20:54:50.511]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.511]    - tweaked: FALSE
  [20:54:50.511]    - call: NULL
  [20:54:50.512] plan(): nbrOfWorkers() = 1
  [20:54:50.513] plan(): Setting new future strategy stack:
  [20:54:50.515] List of future strategies:
  [20:54:50.515] 1. sequential:
  [20:54:50.515]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.515]    - tweaked: FALSE
  [20:54:50.515]    - call: plan(strategy)
  [20:54:50.517] plan(): nbrOfWorkers() = 1
  [20:54:50.517] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x556b112f89c0> 
  Classes 'listenv', 'environment' <environment: 0x556b116a3aa8> 
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [20:54:50.530] resolve() on list environment ...
  [20:54:50.530]  recursive: 0
  [20:54:50.533]  length: 6
  [20:54:50.533]  elements: 'a', 'b', 'c', 'd', '', ''
  [20:54:50.533] signalConditionsASAP(numeric, pos=1) ...
  [20:54:50.537] - nx: 6
  [20:54:50.538] - relay: TRUE
  [20:54:50.538] - stdout: TRUE
  [20:54:50.543] - signal: TRUE
  [20:54:50.543] - resignal: FALSE
  [20:54:50.543] - force: TRUE
  [20:54:50.544] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.544] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.544]  - until=2
  [20:54:50.545]  - relaying element #2
  [20:54:50.545] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.545] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.545] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:50.547]  length: 5 (resolved future 1)
  [20:54:50.548] Future #2
  [20:54:50.548] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:50.548] - nx: 6
  [20:54:50.549] - relay: TRUE
  [20:54:50.549] - stdout: TRUE
  [20:54:50.549] - signal: TRUE
  [20:54:50.550] - resignal: FALSE
  [20:54:50.550] - force: TRUE
  [20:54:50.550] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.550] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.551]  - until=2
  [20:54:50.551]  - relaying element #2
  [20:54:50.551] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.552] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.552] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:50.552]  length: 4 (resolved future 2)
  [20:54:50.553] Future #3
  [20:54:50.553] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:50.553] - nx: 6
  [20:54:50.553] - relay: TRUE
  [20:54:50.554] - stdout: TRUE
  [20:54:50.554] - signal: TRUE
  [20:54:50.554] - resignal: FALSE
  [20:54:50.554] - force: TRUE
  [20:54:50.555] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.555] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.555]  - until=3
  [20:54:50.555]  - relaying element #3
  [20:54:50.556] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.556] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.556] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:50.557]  length: 3 (resolved future 3)
  [20:54:50.557] Future #4
  [20:54:50.557] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:50.558] - nx: 6
  [20:54:50.558] - relay: TRUE
  [20:54:50.558] - stdout: TRUE
  [20:54:50.558] - signal: TRUE
  [20:54:50.559] - resignal: FALSE
  [20:54:50.559] - force: TRUE
  [20:54:50.559] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.559] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.559]  - until=4
  [20:54:50.560]  - relaying element #4
  [20:54:50.560] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.560] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.561] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:50.561]  length: 2 (resolved future 4)
  [20:54:50.561] signalConditionsASAP(NULL, pos=5) ...
  [20:54:50.561] - nx: 6
  [20:54:50.562] - relay: TRUE
  [20:54:50.562] - stdout: TRUE
  [20:54:50.562] - signal: TRUE
  [20:54:50.562] - resignal: FALSE
  [20:54:50.563] - force: TRUE
  [20:54:50.563] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.563] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.564]  - until=6
  [20:54:50.564]  - relaying element #6
  [20:54:50.564] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.564] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.565] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:50.565]  length: 1 (resolved future 5)
  [20:54:50.565] signalConditionsASAP(numeric, pos=6) ...
  [20:54:50.565] - nx: 6
  [20:54:50.566] - relay: TRUE
  [20:54:50.566] - stdout: TRUE
  [20:54:50.566] - signal: TRUE
  [20:54:50.566] - resignal: FALSE
  [20:54:50.567] - force: TRUE
  [20:54:50.567] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.567] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.567]  - until=6
  [20:54:50.568] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.568] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.568] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:50.568]  length: 0 (resolved future 6)
  [20:54:50.569] Relaying remaining futures
  [20:54:50.569] signalConditionsASAP(NULL, pos=0) ...
  [20:54:50.569] - nx: 6
  [20:54:50.569] - relay: TRUE
  [20:54:50.569] - stdout: TRUE
  [20:54:50.570] - signal: TRUE
  [20:54:50.570] - resignal: FALSE
  [20:54:50.570] - force: TRUE
  [20:54:50.570] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.571] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [20:54:50.571] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.571] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.572] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:50.572] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x556b11b48e30> 
  Dimensions: c(1, 6)
  [20:54:50.574] getGlobalsAndPackages() ...
  [20:54:50.574] Searching for globals...
  [20:54:50.575] 
  [20:54:50.575] Searching for globals ... DONE
  [20:54:50.575] - globals: [0] <none>
  [20:54:50.576] getGlobalsAndPackages() ... DONE
  [20:54:50.577] Packages needed by the future expression (n = 0): <none>
  [20:54:50.577] Packages needed by future strategies (n = 0): <none>
  [20:54:50.582] {
  [20:54:50.582]     {
  [20:54:50.582]         ...future.startTime <- base::Sys.time()
  [20:54:50.582]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.582]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.582]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.582]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.582]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.582]         {
  [20:54:50.582]             {
  [20:54:50.582]                 has_future <- base::requireNamespace("future", 
  [20:54:50.582]                   quietly = TRUE)
  [20:54:50.582]                 version <- if (has_future) 
  [20:54:50.582]                   utils::packageVersion("future")
  [20:54:50.582]                 else NULL
  [20:54:50.582]                 if (!has_future || version < "1.8.0") {
  [20:54:50.582]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.582]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.582]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.582]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.582]                       "release", "version")], collapse = " "), 
  [20:54:50.582]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.582]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.582]                     info)
  [20:54:50.582]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.582]                   if (!has_future) {
  [20:54:50.582]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.582]                       info)
  [20:54:50.582]                   }
  [20:54:50.582]                   else {
  [20:54:50.582]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.582]                       info, version)
  [20:54:50.582]                   }
  [20:54:50.582]                   base::stop(msg)
  [20:54:50.582]                 }
  [20:54:50.582]             }
  [20:54:50.582]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.582]         }
  [20:54:50.582]     }
  [20:54:50.582]     if (base::is.na(TRUE)) {
  [20:54:50.582]     }
  [20:54:50.582]     else {
  [20:54:50.582]         if (TRUE) {
  [20:54:50.582]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.582]                 open = "w")
  [20:54:50.582]         }
  [20:54:50.582]         else {
  [20:54:50.582]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.582]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.582]         }
  [20:54:50.582]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.582]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.582]             base::sink(type = "output", split = FALSE)
  [20:54:50.582]             base::close(...future.stdout)
  [20:54:50.582]         }, add = TRUE)
  [20:54:50.582]     }
  [20:54:50.582]     ...future.frame <- base::sys.nframe()
  [20:54:50.582]     ...future.conditions <- base::list()
  [20:54:50.582]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.582]     ...future.result <- base::tryCatch({
  [20:54:50.582]         base::withCallingHandlers({
  [20:54:50.582]             ...future.value <- base::withVisible(base::local(2))
  [20:54:50.582]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.582]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.582]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.582]                 version = "1.8")
  [20:54:50.582]         }, condition = base::local({
  [20:54:50.582]             c <- base::c
  [20:54:50.582]             inherits <- base::inherits
  [20:54:50.582]             invokeRestart <- base::invokeRestart
  [20:54:50.582]             length <- base::length
  [20:54:50.582]             list <- base::list
  [20:54:50.582]             seq.int <- base::seq.int
  [20:54:50.582]             signalCondition <- base::signalCondition
  [20:54:50.582]             sys.calls <- base::sys.calls
  [20:54:50.582]             Sys.time <- base::Sys.time
  [20:54:50.582]             `[[` <- base::`[[`
  [20:54:50.582]             `+` <- base::`+`
  [20:54:50.582]             `<<-` <- base::`<<-`
  [20:54:50.582]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.582]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.582]                   3L)]
  [20:54:50.582]             }
  [20:54:50.582]             function(cond) {
  [20:54:50.582]                 if (inherits(cond, "error")) {
  [20:54:50.582]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.582]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.582]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.582]                   signalCondition(cond)
  [20:54:50.582]                 }
  [20:54:50.582]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.582]                 ))) {
  [20:54:50.582]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.582]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.582]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.582]                   if (!signal) {
  [20:54:50.582]                     muffleCondition <- function (cond) 
  [20:54:50.582]                     {
  [20:54:50.582]                       inherits <- base::inherits
  [20:54:50.582]                       invokeRestart <- base::invokeRestart
  [20:54:50.582]                       muffled <- FALSE
  [20:54:50.582]                       if (inherits(cond, "message")) {
  [20:54:50.582]                         invokeRestart("muffleMessage")
  [20:54:50.582]                         muffled <- TRUE
  [20:54:50.582]                       }
  [20:54:50.582]                       else if (inherits(cond, "warning")) {
  [20:54:50.582]                         invokeRestart("muffleWarning")
  [20:54:50.582]                         muffled <- TRUE
  [20:54:50.582]                       }
  [20:54:50.582]                       else if (inherits(cond, "condition")) {
  [20:54:50.582]                         computeRestarts <- base::computeRestarts
  [20:54:50.582]                         grepl <- base::grepl
  [20:54:50.582]                         is.null <- base::is.null
  [20:54:50.582]                         restarts <- computeRestarts(cond)
  [20:54:50.582]                         for (restart in restarts) {
  [20:54:50.582]                           name <- restart$name
  [20:54:50.582]                           if (is.null(name)) 
  [20:54:50.582]                             next
  [20:54:50.582]                           if (!grepl("^muffle", name)) 
  [20:54:50.582]                             next
  [20:54:50.582]                           invokeRestart(restart)
  [20:54:50.582]                           muffled <- TRUE
  [20:54:50.582]                           break
  [20:54:50.582]                         }
  [20:54:50.582]                       }
  [20:54:50.582]                       invisible(muffled)
  [20:54:50.582]                     }
  [20:54:50.582]                     muffleCondition(cond)
  [20:54:50.582]                   }
  [20:54:50.582]                 }
  [20:54:50.582]             }
  [20:54:50.582]         }))
  [20:54:50.582]     }, error = function(ex) {
  [20:54:50.582]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.582]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.582]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.582]     }, finally = {
  [20:54:50.582]         {
  [20:54:50.582]             NULL
  [20:54:50.582]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.582]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.582]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.582]                 label = NULL, ...) 
  [20:54:50.582]             {
  [20:54:50.582]                 if (substitute) 
  [20:54:50.582]                   expr <- substitute(expr)
  [20:54:50.582]                 local <- as.logical(local)
  [20:54:50.582]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.582]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.582]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.582]                   label = label, ...)
  [20:54:50.582]                 if (!future$lazy) 
  [20:54:50.582]                   future <- run(future)
  [20:54:50.582]                 invisible(future)
  [20:54:50.582]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.582]         }
  [20:54:50.582]         base::options(...future.oldOptions)
  [20:54:50.582]     })
  [20:54:50.582]     Sys.time
  [20:54:50.582]     if (base::is.na(TRUE)) {
  [20:54:50.582]     }
  [20:54:50.582]     else {
  [20:54:50.582]         base::sink(type = "output", split = FALSE)
  [20:54:50.582]         if (TRUE) {
  [20:54:50.582]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.582]         }
  [20:54:50.582]         else {
  [20:54:50.582]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.582]         }
  [20:54:50.582]         base::close(...future.stdout)
  [20:54:50.582]         ...future.stdout <- NULL
  [20:54:50.582]     }
  [20:54:50.582]     ...future.result$conditions <- ...future.conditions
  [20:54:50.582]     ...future.result
  [20:54:50.582] }
  [20:54:50.586] plan(): Setting new future strategy stack:
  [20:54:50.586] List of future strategies:
  [20:54:50.586] 1. sequential:
  [20:54:50.586]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.586]    - tweaked: FALSE
  [20:54:50.586]    - call: NULL
  [20:54:50.587] plan(): nbrOfWorkers() = 1
  [20:54:50.588] plan(): Setting new future strategy stack:
  [20:54:50.588] List of future strategies:
  [20:54:50.588] 1. sequential:
  [20:54:50.588]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.588]    - tweaked: FALSE
  [20:54:50.588]    - call: plan(strategy)
  [20:54:50.589] plan(): nbrOfWorkers() = 1
  [20:54:50.590] SequentialFuture started (and completed)
  [20:54:50.590] getGlobalsAndPackages() ...
  [20:54:50.591] Searching for globals...
  [20:54:50.591] 
  [20:54:50.592] Searching for globals ... DONE
  [20:54:50.592] - globals: [0] <none>
  [20:54:50.592] getGlobalsAndPackages() ... DONE
  [20:54:50.594] Packages needed by the future expression (n = 0): <none>
  [20:54:50.594] Packages needed by future strategies (n = 0): <none>
  [20:54:50.604] {
  [20:54:50.604]     {
  [20:54:50.604]         ...future.startTime <- base::Sys.time()
  [20:54:50.604]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.604]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.604]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.604]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.604]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.604]         {
  [20:54:50.604]             {
  [20:54:50.604]                 has_future <- base::requireNamespace("future", 
  [20:54:50.604]                   quietly = TRUE)
  [20:54:50.604]                 version <- if (has_future) 
  [20:54:50.604]                   utils::packageVersion("future")
  [20:54:50.604]                 else NULL
  [20:54:50.604]                 if (!has_future || version < "1.8.0") {
  [20:54:50.604]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.604]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.604]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.604]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.604]                       "release", "version")], collapse = " "), 
  [20:54:50.604]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.604]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.604]                     info)
  [20:54:50.604]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.604]                   if (!has_future) {
  [20:54:50.604]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.604]                       info)
  [20:54:50.604]                   }
  [20:54:50.604]                   else {
  [20:54:50.604]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.604]                       info, version)
  [20:54:50.604]                   }
  [20:54:50.604]                   base::stop(msg)
  [20:54:50.604]                 }
  [20:54:50.604]             }
  [20:54:50.604]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.604]         }
  [20:54:50.604]     }
  [20:54:50.604]     if (base::is.na(TRUE)) {
  [20:54:50.604]     }
  [20:54:50.604]     else {
  [20:54:50.604]         if (TRUE) {
  [20:54:50.604]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.604]                 open = "w")
  [20:54:50.604]         }
  [20:54:50.604]         else {
  [20:54:50.604]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.604]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.604]         }
  [20:54:50.604]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.604]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.604]             base::sink(type = "output", split = FALSE)
  [20:54:50.604]             base::close(...future.stdout)
  [20:54:50.604]         }, add = TRUE)
  [20:54:50.604]     }
  [20:54:50.604]     ...future.frame <- base::sys.nframe()
  [20:54:50.604]     ...future.conditions <- base::list()
  [20:54:50.604]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.604]     ...future.result <- base::tryCatch({
  [20:54:50.604]         base::withCallingHandlers({
  [20:54:50.604]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:50.604]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.604]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.604]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.604]                 version = "1.8")
  [20:54:50.604]         }, condition = base::local({
  [20:54:50.604]             c <- base::c
  [20:54:50.604]             inherits <- base::inherits
  [20:54:50.604]             invokeRestart <- base::invokeRestart
  [20:54:50.604]             length <- base::length
  [20:54:50.604]             list <- base::list
  [20:54:50.604]             seq.int <- base::seq.int
  [20:54:50.604]             signalCondition <- base::signalCondition
  [20:54:50.604]             sys.calls <- base::sys.calls
  [20:54:50.604]             Sys.time <- base::Sys.time
  [20:54:50.604]             `[[` <- base::`[[`
  [20:54:50.604]             `+` <- base::`+`
  [20:54:50.604]             `<<-` <- base::`<<-`
  [20:54:50.604]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.604]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.604]                   3L)]
  [20:54:50.604]             }
  [20:54:50.604]             function(cond) {
  [20:54:50.604]                 if (inherits(cond, "error")) {
  [20:54:50.604]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.604]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.604]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.604]                   signalCondition(cond)
  [20:54:50.604]                 }
  [20:54:50.604]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.604]                 ))) {
  [20:54:50.604]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.604]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.604]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.604]                   if (!signal) {
  [20:54:50.604]                     muffleCondition <- function (cond) 
  [20:54:50.604]                     {
  [20:54:50.604]                       inherits <- base::inherits
  [20:54:50.604]                       invokeRestart <- base::invokeRestart
  [20:54:50.604]                       muffled <- FALSE
  [20:54:50.604]                       if (inherits(cond, "message")) {
  [20:54:50.604]                         invokeRestart("muffleMessage")
  [20:54:50.604]                         muffled <- TRUE
  [20:54:50.604]                       }
  [20:54:50.604]                       else if (inherits(cond, "warning")) {
  [20:54:50.604]                         invokeRestart("muffleWarning")
  [20:54:50.604]                         muffled <- TRUE
  [20:54:50.604]                       }
  [20:54:50.604]                       else if (inherits(cond, "condition")) {
  [20:54:50.604]                         computeRestarts <- base::computeRestarts
  [20:54:50.604]                         grepl <- base::grepl
  [20:54:50.604]                         is.null <- base::is.null
  [20:54:50.604]                         restarts <- computeRestarts(cond)
  [20:54:50.604]                         for (restart in restarts) {
  [20:54:50.604]                           name <- restart$name
  [20:54:50.604]                           if (is.null(name)) 
  [20:54:50.604]                             next
  [20:54:50.604]                           if (!grepl("^muffle", name)) 
  [20:54:50.604]                             next
  [20:54:50.604]                           invokeRestart(restart)
  [20:54:50.604]                           muffled <- TRUE
  [20:54:50.604]                           break
  [20:54:50.604]                         }
  [20:54:50.604]                       }
  [20:54:50.604]                       invisible(muffled)
  [20:54:50.604]                     }
  [20:54:50.604]                     muffleCondition(cond)
  [20:54:50.604]                   }
  [20:54:50.604]                 }
  [20:54:50.604]             }
  [20:54:50.604]         }))
  [20:54:50.604]     }, error = function(ex) {
  [20:54:50.604]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.604]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.604]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.604]     }, finally = {
  [20:54:50.604]         {
  [20:54:50.604]             NULL
  [20:54:50.604]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.604]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.604]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.604]                 label = NULL, ...) 
  [20:54:50.604]             {
  [20:54:50.604]                 if (substitute) 
  [20:54:50.604]                   expr <- substitute(expr)
  [20:54:50.604]                 local <- as.logical(local)
  [20:54:50.604]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.604]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.604]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.604]                   label = label, ...)
  [20:54:50.604]                 if (!future$lazy) 
  [20:54:50.604]                   future <- run(future)
  [20:54:50.604]                 invisible(future)
  [20:54:50.604]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.604]         }
  [20:54:50.604]         base::options(...future.oldOptions)
  [20:54:50.604]     })
  [20:54:50.604]     Sys.time
  [20:54:50.604]     if (base::is.na(TRUE)) {
  [20:54:50.604]     }
  [20:54:50.604]     else {
  [20:54:50.604]         base::sink(type = "output", split = FALSE)
  [20:54:50.604]         if (TRUE) {
  [20:54:50.604]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.604]         }
  [20:54:50.604]         else {
  [20:54:50.604]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.604]         }
  [20:54:50.604]         base::close(...future.stdout)
  [20:54:50.604]         ...future.stdout <- NULL
  [20:54:50.604]     }
  [20:54:50.604]     ...future.result$conditions <- ...future.conditions
  [20:54:50.604]     ...future.result
  [20:54:50.604] }
  [20:54:50.609] plan(): Setting new future strategy stack:
  [20:54:50.609] List of future strategies:
  [20:54:50.609] 1. sequential:
  [20:54:50.609]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.609]    - tweaked: FALSE
  [20:54:50.609]    - call: NULL
  [20:54:50.613] plan(): nbrOfWorkers() = 1
  [20:54:50.615] plan(): Setting new future strategy stack:
  [20:54:50.615] List of future strategies:
  [20:54:50.615] 1. sequential:
  [20:54:50.615]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.615]    - tweaked: FALSE
  [20:54:50.615]    - call: plan(strategy)
  [20:54:50.616] plan(): nbrOfWorkers() = 1
  [20:54:50.616] SequentialFuture started (and completed)
  [20:54:50.617] getGlobalsAndPackages() ...
  [20:54:50.617] Searching for globals...
  [20:54:50.619] - globals found: [1] '{'
  [20:54:50.619] Searching for globals ... DONE
  [20:54:50.619] Resolving globals: FALSE
  [20:54:50.620] 
  [20:54:50.620] 
  [20:54:50.620] getGlobalsAndPackages() ... DONE
  [20:54:50.622] Packages needed by the future expression (n = 0): <none>
  [20:54:50.622] Packages needed by future strategies (n = 0): <none>
  [20:54:50.627] {
  [20:54:50.627]     {
  [20:54:50.627]         ...future.startTime <- base::Sys.time()
  [20:54:50.627]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.627]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.627]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.627]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.627]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.627]         {
  [20:54:50.627]             {
  [20:54:50.627]                 has_future <- base::requireNamespace("future", 
  [20:54:50.627]                   quietly = TRUE)
  [20:54:50.627]                 version <- if (has_future) 
  [20:54:50.627]                   utils::packageVersion("future")
  [20:54:50.627]                 else NULL
  [20:54:50.627]                 if (!has_future || version < "1.8.0") {
  [20:54:50.627]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.627]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.627]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.627]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.627]                       "release", "version")], collapse = " "), 
  [20:54:50.627]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.627]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.627]                     info)
  [20:54:50.627]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.627]                   if (!has_future) {
  [20:54:50.627]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.627]                       info)
  [20:54:50.627]                   }
  [20:54:50.627]                   else {
  [20:54:50.627]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.627]                       info, version)
  [20:54:50.627]                   }
  [20:54:50.627]                   base::stop(msg)
  [20:54:50.627]                 }
  [20:54:50.627]             }
  [20:54:50.627]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.627]         }
  [20:54:50.627]     }
  [20:54:50.627]     if (base::is.na(TRUE)) {
  [20:54:50.627]     }
  [20:54:50.627]     else {
  [20:54:50.627]         if (TRUE) {
  [20:54:50.627]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.627]                 open = "w")
  [20:54:50.627]         }
  [20:54:50.627]         else {
  [20:54:50.627]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.627]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.627]         }
  [20:54:50.627]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.627]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.627]             base::sink(type = "output", split = FALSE)
  [20:54:50.627]             base::close(...future.stdout)
  [20:54:50.627]         }, add = TRUE)
  [20:54:50.627]     }
  [20:54:50.627]     ...future.frame <- base::sys.nframe()
  [20:54:50.627]     ...future.conditions <- base::list()
  [20:54:50.627]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.627]     ...future.result <- base::tryCatch({
  [20:54:50.627]         base::withCallingHandlers({
  [20:54:50.627]             ...future.value <- base::withVisible(base::local({
  [20:54:50.627]                 4
  [20:54:50.627]             }))
  [20:54:50.627]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.627]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.627]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.627]                 version = "1.8")
  [20:54:50.627]         }, condition = base::local({
  [20:54:50.627]             c <- base::c
  [20:54:50.627]             inherits <- base::inherits
  [20:54:50.627]             invokeRestart <- base::invokeRestart
  [20:54:50.627]             length <- base::length
  [20:54:50.627]             list <- base::list
  [20:54:50.627]             seq.int <- base::seq.int
  [20:54:50.627]             signalCondition <- base::signalCondition
  [20:54:50.627]             sys.calls <- base::sys.calls
  [20:54:50.627]             Sys.time <- base::Sys.time
  [20:54:50.627]             `[[` <- base::`[[`
  [20:54:50.627]             `+` <- base::`+`
  [20:54:50.627]             `<<-` <- base::`<<-`
  [20:54:50.627]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.627]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.627]                   3L)]
  [20:54:50.627]             }
  [20:54:50.627]             function(cond) {
  [20:54:50.627]                 if (inherits(cond, "error")) {
  [20:54:50.627]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.627]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.627]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.627]                   signalCondition(cond)
  [20:54:50.627]                 }
  [20:54:50.627]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.627]                 ))) {
  [20:54:50.627]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.627]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.627]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.627]                   if (!signal) {
  [20:54:50.627]                     muffleCondition <- function (cond) 
  [20:54:50.627]                     {
  [20:54:50.627]                       inherits <- base::inherits
  [20:54:50.627]                       invokeRestart <- base::invokeRestart
  [20:54:50.627]                       muffled <- FALSE
  [20:54:50.627]                       if (inherits(cond, "message")) {
  [20:54:50.627]                         invokeRestart("muffleMessage")
  [20:54:50.627]                         muffled <- TRUE
  [20:54:50.627]                       }
  [20:54:50.627]                       else if (inherits(cond, "warning")) {
  [20:54:50.627]                         invokeRestart("muffleWarning")
  [20:54:50.627]                         muffled <- TRUE
  [20:54:50.627]                       }
  [20:54:50.627]                       else if (inherits(cond, "condition")) {
  [20:54:50.627]                         computeRestarts <- base::computeRestarts
  [20:54:50.627]                         grepl <- base::grepl
  [20:54:50.627]                         is.null <- base::is.null
  [20:54:50.627]                         restarts <- computeRestarts(cond)
  [20:54:50.627]                         for (restart in restarts) {
  [20:54:50.627]                           name <- restart$name
  [20:54:50.627]                           if (is.null(name)) 
  [20:54:50.627]                             next
  [20:54:50.627]                           if (!grepl("^muffle", name)) 
  [20:54:50.627]                             next
  [20:54:50.627]                           invokeRestart(restart)
  [20:54:50.627]                           muffled <- TRUE
  [20:54:50.627]                           break
  [20:54:50.627]                         }
  [20:54:50.627]                       }
  [20:54:50.627]                       invisible(muffled)
  [20:54:50.627]                     }
  [20:54:50.627]                     muffleCondition(cond)
  [20:54:50.627]                   }
  [20:54:50.627]                 }
  [20:54:50.627]             }
  [20:54:50.627]         }))
  [20:54:50.627]     }, error = function(ex) {
  [20:54:50.627]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.627]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.627]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.627]     }, finally = {
  [20:54:50.627]         {
  [20:54:50.627]             NULL
  [20:54:50.627]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.627]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.627]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.627]                 label = NULL, ...) 
  [20:54:50.627]             {
  [20:54:50.627]                 if (substitute) 
  [20:54:50.627]                   expr <- substitute(expr)
  [20:54:50.627]                 local <- as.logical(local)
  [20:54:50.627]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.627]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.627]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.627]                   label = label, ...)
  [20:54:50.627]                 if (!future$lazy) 
  [20:54:50.627]                   future <- run(future)
  [20:54:50.627]                 invisible(future)
  [20:54:50.627]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.627]         }
  [20:54:50.627]         base::options(...future.oldOptions)
  [20:54:50.627]     })
  [20:54:50.627]     Sys.time
  [20:54:50.627]     if (base::is.na(TRUE)) {
  [20:54:50.627]     }
  [20:54:50.627]     else {
  [20:54:50.627]         base::sink(type = "output", split = FALSE)
  [20:54:50.627]         if (TRUE) {
  [20:54:50.627]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.627]         }
  [20:54:50.627]         else {
  [20:54:50.627]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.627]         }
  [20:54:50.627]         base::close(...future.stdout)
  [20:54:50.627]         ...future.stdout <- NULL
  [20:54:50.627]     }
  [20:54:50.627]     ...future.result$conditions <- ...future.conditions
  [20:54:50.627]     ...future.result
  [20:54:50.627] }
  [20:54:50.632] plan(): Setting new future strategy stack:
  [20:54:50.632] List of future strategies:
  [20:54:50.632] 1. sequential:
  [20:54:50.632]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.632]    - tweaked: FALSE
  [20:54:50.632]    - call: NULL
  [20:54:50.633] plan(): nbrOfWorkers() = 1
  [20:54:50.634] plan(): Setting new future strategy stack:
  [20:54:50.634] List of future strategies:
  [20:54:50.634] 1. sequential:
  [20:54:50.634]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.634]    - tweaked: FALSE
  [20:54:50.634]    - call: plan(strategy)
  [20:54:50.635] plan(): nbrOfWorkers() = 1
  [20:54:50.636] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x556b1034c4d8> 
  Classes 'listenv', 'environment' <environment: 0x556b113444c8> 
   - 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" ...
  [20:54:50.651] resolve() on list environment ...
  [20:54:50.651]  recursive: 0
  [20:54:50.659]  length: 6
  [20:54:50.660]  elements: 'a', 'b', 'c', 'd', '', ''
  [20:54:50.660] signalConditionsASAP(numeric, pos=1) ...
  [20:54:50.660] - nx: 6
  [20:54:50.661] - relay: TRUE
  [20:54:50.661] - stdout: TRUE
  [20:54:50.661] - signal: TRUE
  [20:54:50.661] - resignal: FALSE
  [20:54:50.662] - force: TRUE
  [20:54:50.662] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.662] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.662]  - until=2
  [20:54:50.663]  - relaying element #2
  [20:54:50.663] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.663] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.664] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:50.664]  length: 5 (resolved future 1)
  [20:54:50.664] Future #2
  [20:54:50.665] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:50.665] - nx: 6
  [20:54:50.665] - relay: TRUE
  [20:54:50.665] - stdout: TRUE
  [20:54:50.666] - signal: TRUE
  [20:54:50.666] - resignal: FALSE
  [20:54:50.666] - force: TRUE
  [20:54:50.666] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.667] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.667]  - until=2
  [20:54:50.667]  - relaying element #2
  [20:54:50.668] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.668] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.668] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:50.669]  length: 4 (resolved future 2)
  [20:54:50.669] Future #3
  [20:54:50.669] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:50.670] - nx: 6
  [20:54:50.670] - relay: TRUE
  [20:54:50.670] - stdout: TRUE
  [20:54:50.670] - signal: TRUE
  [20:54:50.671] - resignal: FALSE
  [20:54:50.671] - force: TRUE
  [20:54:50.671] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.671] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.672]  - until=3
  [20:54:50.672]  - relaying element #3
  [20:54:50.672] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.673] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.673] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:50.673]  length: 3 (resolved future 3)
  [20:54:50.674] Future #4
  [20:54:50.674] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:50.674] - nx: 6
  [20:54:50.674] - relay: TRUE
  [20:54:50.675] - stdout: TRUE
  [20:54:50.675] - signal: TRUE
  [20:54:50.675] - resignal: FALSE
  [20:54:50.675] - force: TRUE
  [20:54:50.676] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.676] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.676]  - until=4
  [20:54:50.676]  - relaying element #4
  [20:54:50.677] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.677] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.677] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:50.678]  length: 2 (resolved future 4)
  [20:54:50.678] signalConditionsASAP(NULL, pos=5) ...
  [20:54:50.678] - nx: 6
  [20:54:50.679] - relay: TRUE
  [20:54:50.679] - stdout: TRUE
  [20:54:50.679] - signal: TRUE
  [20:54:50.679] - resignal: FALSE
  [20:54:50.680] - force: TRUE
  [20:54:50.680] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.680] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.680]  - until=6
  [20:54:50.681]  - relaying element #6
  [20:54:50.681] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.681] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.681] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:50.682]  length: 1 (resolved future 5)
  [20:54:50.682] signalConditionsASAP(numeric, pos=6) ...
  [20:54:50.682] - nx: 6
  [20:54:50.682] - relay: TRUE
  [20:54:50.683] - stdout: TRUE
  [20:54:50.683] - signal: TRUE
  [20:54:50.683] - resignal: FALSE
  [20:54:50.683] - force: TRUE
  [20:54:50.684] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.684] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.684]  - until=6
  [20:54:50.685] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.685] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.685] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:50.685]  length: 0 (resolved future 6)
  [20:54:50.686] Relaying remaining futures
  [20:54:50.686] signalConditionsASAP(NULL, pos=0) ...
  [20:54:50.686] - nx: 6
  [20:54:50.686] - relay: TRUE
  [20:54:50.687] - stdout: TRUE
  [20:54:50.687] - signal: TRUE
  [20:54:50.687] - resignal: FALSE
  [20:54:50.687] - force: TRUE
  [20:54:50.688] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.688] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [20:54:50.688] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.688] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.689] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:50.689] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x556b11f13358> 
   - 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)
  [20:54:50.694] getGlobalsAndPackages() ...
  [20:54:50.695] Searching for globals...
  [20:54:50.695] 
  [20:54:50.696] Searching for globals ... DONE
  [20:54:50.696] - globals: [0] <none>
  [20:54:50.696] getGlobalsAndPackages() ... DONE
  [20:54:50.698] Packages needed by the future expression (n = 0): <none>
  [20:54:50.698] Packages needed by future strategies (n = 0): <none>
  [20:54:50.702] {
  [20:54:50.702]     {
  [20:54:50.702]         ...future.startTime <- base::Sys.time()
  [20:54:50.702]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.702]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.702]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.702]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.702]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.702]         {
  [20:54:50.702]             {
  [20:54:50.702]                 has_future <- base::requireNamespace("future", 
  [20:54:50.702]                   quietly = TRUE)
  [20:54:50.702]                 version <- if (has_future) 
  [20:54:50.702]                   utils::packageVersion("future")
  [20:54:50.702]                 else NULL
  [20:54:50.702]                 if (!has_future || version < "1.8.0") {
  [20:54:50.702]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.702]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.702]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.702]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.702]                       "release", "version")], collapse = " "), 
  [20:54:50.702]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.702]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.702]                     info)
  [20:54:50.702]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.702]                   if (!has_future) {
  [20:54:50.702]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.702]                       info)
  [20:54:50.702]                   }
  [20:54:50.702]                   else {
  [20:54:50.702]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.702]                       info, version)
  [20:54:50.702]                   }
  [20:54:50.702]                   base::stop(msg)
  [20:54:50.702]                 }
  [20:54:50.702]             }
  [20:54:50.702]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.702]         }
  [20:54:50.702]     }
  [20:54:50.702]     if (base::is.na(TRUE)) {
  [20:54:50.702]     }
  [20:54:50.702]     else {
  [20:54:50.702]         if (TRUE) {
  [20:54:50.702]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.702]                 open = "w")
  [20:54:50.702]         }
  [20:54:50.702]         else {
  [20:54:50.702]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.702]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.702]         }
  [20:54:50.702]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.702]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.702]             base::sink(type = "output", split = FALSE)
  [20:54:50.702]             base::close(...future.stdout)
  [20:54:50.702]         }, add = TRUE)
  [20:54:50.702]     }
  [20:54:50.702]     ...future.frame <- base::sys.nframe()
  [20:54:50.702]     ...future.conditions <- base::list()
  [20:54:50.702]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.702]     ...future.result <- base::tryCatch({
  [20:54:50.702]         base::withCallingHandlers({
  [20:54:50.702]             ...future.value <- base::withVisible(base::local(2))
  [20:54:50.702]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.702]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.702]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.702]                 version = "1.8")
  [20:54:50.702]         }, condition = base::local({
  [20:54:50.702]             c <- base::c
  [20:54:50.702]             inherits <- base::inherits
  [20:54:50.702]             invokeRestart <- base::invokeRestart
  [20:54:50.702]             length <- base::length
  [20:54:50.702]             list <- base::list
  [20:54:50.702]             seq.int <- base::seq.int
  [20:54:50.702]             signalCondition <- base::signalCondition
  [20:54:50.702]             sys.calls <- base::sys.calls
  [20:54:50.702]             Sys.time <- base::Sys.time
  [20:54:50.702]             `[[` <- base::`[[`
  [20:54:50.702]             `+` <- base::`+`
  [20:54:50.702]             `<<-` <- base::`<<-`
  [20:54:50.702]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.702]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.702]                   3L)]
  [20:54:50.702]             }
  [20:54:50.702]             function(cond) {
  [20:54:50.702]                 if (inherits(cond, "error")) {
  [20:54:50.702]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.702]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.702]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.702]                   signalCondition(cond)
  [20:54:50.702]                 }
  [20:54:50.702]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.702]                 ))) {
  [20:54:50.702]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.702]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.702]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.702]                   if (!signal) {
  [20:54:50.702]                     muffleCondition <- function (cond) 
  [20:54:50.702]                     {
  [20:54:50.702]                       inherits <- base::inherits
  [20:54:50.702]                       invokeRestart <- base::invokeRestart
  [20:54:50.702]                       muffled <- FALSE
  [20:54:50.702]                       if (inherits(cond, "message")) {
  [20:54:50.702]                         invokeRestart("muffleMessage")
  [20:54:50.702]                         muffled <- TRUE
  [20:54:50.702]                       }
  [20:54:50.702]                       else if (inherits(cond, "warning")) {
  [20:54:50.702]                         invokeRestart("muffleWarning")
  [20:54:50.702]                         muffled <- TRUE
  [20:54:50.702]                       }
  [20:54:50.702]                       else if (inherits(cond, "condition")) {
  [20:54:50.702]                         computeRestarts <- base::computeRestarts
  [20:54:50.702]                         grepl <- base::grepl
  [20:54:50.702]                         is.null <- base::is.null
  [20:54:50.702]                         restarts <- computeRestarts(cond)
  [20:54:50.702]                         for (restart in restarts) {
  [20:54:50.702]                           name <- restart$name
  [20:54:50.702]                           if (is.null(name)) 
  [20:54:50.702]                             next
  [20:54:50.702]                           if (!grepl("^muffle", name)) 
  [20:54:50.702]                             next
  [20:54:50.702]                           invokeRestart(restart)
  [20:54:50.702]                           muffled <- TRUE
  [20:54:50.702]                           break
  [20:54:50.702]                         }
  [20:54:50.702]                       }
  [20:54:50.702]                       invisible(muffled)
  [20:54:50.702]                     }
  [20:54:50.702]                     muffleCondition(cond)
  [20:54:50.702]                   }
  [20:54:50.702]                 }
  [20:54:50.702]             }
  [20:54:50.702]         }))
  [20:54:50.702]     }, error = function(ex) {
  [20:54:50.702]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.702]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.702]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.702]     }, finally = {
  [20:54:50.702]         {
  [20:54:50.702]             NULL
  [20:54:50.702]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.702]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.702]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.702]                 label = NULL, ...) 
  [20:54:50.702]             {
  [20:54:50.702]                 if (substitute) 
  [20:54:50.702]                   expr <- substitute(expr)
  [20:54:50.702]                 local <- as.logical(local)
  [20:54:50.702]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.702]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.702]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.702]                   label = label, ...)
  [20:54:50.702]                 if (!future$lazy) 
  [20:54:50.702]                   future <- run(future)
  [20:54:50.702]                 invisible(future)
  [20:54:50.702]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.702]         }
  [20:54:50.702]         base::options(...future.oldOptions)
  [20:54:50.702]     })
  [20:54:50.702]     Sys.time
  [20:54:50.702]     if (base::is.na(TRUE)) {
  [20:54:50.702]     }
  [20:54:50.702]     else {
  [20:54:50.702]         base::sink(type = "output", split = FALSE)
  [20:54:50.702]         if (TRUE) {
  [20:54:50.702]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.702]         }
  [20:54:50.702]         else {
  [20:54:50.702]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.702]         }
  [20:54:50.702]         base::close(...future.stdout)
  [20:54:50.702]         ...future.stdout <- NULL
  [20:54:50.702]     }
  [20:54:50.702]     ...future.result$conditions <- ...future.conditions
  [20:54:50.702]     ...future.result
  [20:54:50.702] }
  [20:54:50.707] plan(): Setting new future strategy stack:
  [20:54:50.707] List of future strategies:
  [20:54:50.707] 1. sequential:
  [20:54:50.707]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.707]    - tweaked: FALSE
  [20:54:50.707]    - call: NULL
  [20:54:50.713] plan(): nbrOfWorkers() = 1
  [20:54:50.714] plan(): Setting new future strategy stack:
  [20:54:50.714] List of future strategies:
  [20:54:50.714] 1. sequential:
  [20:54:50.714]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.714]    - tweaked: FALSE
  [20:54:50.714]    - call: plan(strategy)
  [20:54:50.715] plan(): nbrOfWorkers() = 1
  [20:54:50.715] SequentialFuture started (and completed)
  [20:54:50.716] getGlobalsAndPackages() ...
  [20:54:50.716] Searching for globals...
  [20:54:50.717] 
  [20:54:50.717] Searching for globals ... DONE
  [20:54:50.718] - globals: [0] <none>
  [20:54:50.718] getGlobalsAndPackages() ... DONE
  [20:54:50.720] Packages needed by the future expression (n = 0): <none>
  [20:54:50.720] Packages needed by future strategies (n = 0): <none>
  [20:54:50.724] {
  [20:54:50.724]     {
  [20:54:50.724]         ...future.startTime <- base::Sys.time()
  [20:54:50.724]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.724]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.724]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.724]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.724]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.724]         {
  [20:54:50.724]             {
  [20:54:50.724]                 has_future <- base::requireNamespace("future", 
  [20:54:50.724]                   quietly = TRUE)
  [20:54:50.724]                 version <- if (has_future) 
  [20:54:50.724]                   utils::packageVersion("future")
  [20:54:50.724]                 else NULL
  [20:54:50.724]                 if (!has_future || version < "1.8.0") {
  [20:54:50.724]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.724]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.724]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.724]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.724]                       "release", "version")], collapse = " "), 
  [20:54:50.724]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.724]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.724]                     info)
  [20:54:50.724]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.724]                   if (!has_future) {
  [20:54:50.724]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.724]                       info)
  [20:54:50.724]                   }
  [20:54:50.724]                   else {
  [20:54:50.724]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.724]                       info, version)
  [20:54:50.724]                   }
  [20:54:50.724]                   base::stop(msg)
  [20:54:50.724]                 }
  [20:54:50.724]             }
  [20:54:50.724]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.724]         }
  [20:54:50.724]     }
  [20:54:50.724]     if (base::is.na(TRUE)) {
  [20:54:50.724]     }
  [20:54:50.724]     else {
  [20:54:50.724]         if (TRUE) {
  [20:54:50.724]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.724]                 open = "w")
  [20:54:50.724]         }
  [20:54:50.724]         else {
  [20:54:50.724]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.724]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.724]         }
  [20:54:50.724]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.724]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.724]             base::sink(type = "output", split = FALSE)
  [20:54:50.724]             base::close(...future.stdout)
  [20:54:50.724]         }, add = TRUE)
  [20:54:50.724]     }
  [20:54:50.724]     ...future.frame <- base::sys.nframe()
  [20:54:50.724]     ...future.conditions <- base::list()
  [20:54:50.724]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.724]     ...future.result <- base::tryCatch({
  [20:54:50.724]         base::withCallingHandlers({
  [20:54:50.724]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:50.724]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.724]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.724]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.724]                 version = "1.8")
  [20:54:50.724]         }, condition = base::local({
  [20:54:50.724]             c <- base::c
  [20:54:50.724]             inherits <- base::inherits
  [20:54:50.724]             invokeRestart <- base::invokeRestart
  [20:54:50.724]             length <- base::length
  [20:54:50.724]             list <- base::list
  [20:54:50.724]             seq.int <- base::seq.int
  [20:54:50.724]             signalCondition <- base::signalCondition
  [20:54:50.724]             sys.calls <- base::sys.calls
  [20:54:50.724]             Sys.time <- base::Sys.time
  [20:54:50.724]             `[[` <- base::`[[`
  [20:54:50.724]             `+` <- base::`+`
  [20:54:50.724]             `<<-` <- base::`<<-`
  [20:54:50.724]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.724]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.724]                   3L)]
  [20:54:50.724]             }
  [20:54:50.724]             function(cond) {
  [20:54:50.724]                 if (inherits(cond, "error")) {
  [20:54:50.724]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.724]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.724]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.724]                   signalCondition(cond)
  [20:54:50.724]                 }
  [20:54:50.724]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.724]                 ))) {
  [20:54:50.724]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.724]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.724]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.724]                   if (!signal) {
  [20:54:50.724]                     muffleCondition <- function (cond) 
  [20:54:50.724]                     {
  [20:54:50.724]                       inherits <- base::inherits
  [20:54:50.724]                       invokeRestart <- base::invokeRestart
  [20:54:50.724]                       muffled <- FALSE
  [20:54:50.724]                       if (inherits(cond, "message")) {
  [20:54:50.724]                         invokeRestart("muffleMessage")
  [20:54:50.724]                         muffled <- TRUE
  [20:54:50.724]                       }
  [20:54:50.724]                       else if (inherits(cond, "warning")) {
  [20:54:50.724]                         invokeRestart("muffleWarning")
  [20:54:50.724]                         muffled <- TRUE
  [20:54:50.724]                       }
  [20:54:50.724]                       else if (inherits(cond, "condition")) {
  [20:54:50.724]                         computeRestarts <- base::computeRestarts
  [20:54:50.724]                         grepl <- base::grepl
  [20:54:50.724]                         is.null <- base::is.null
  [20:54:50.724]                         restarts <- computeRestarts(cond)
  [20:54:50.724]                         for (restart in restarts) {
  [20:54:50.724]                           name <- restart$name
  [20:54:50.724]                           if (is.null(name)) 
  [20:54:50.724]                             next
  [20:54:50.724]                           if (!grepl("^muffle", name)) 
  [20:54:50.724]                             next
  [20:54:50.724]                           invokeRestart(restart)
  [20:54:50.724]                           muffled <- TRUE
  [20:54:50.724]                           break
  [20:54:50.724]                         }
  [20:54:50.724]                       }
  [20:54:50.724]                       invisible(muffled)
  [20:54:50.724]                     }
  [20:54:50.724]                     muffleCondition(cond)
  [20:54:50.724]                   }
  [20:54:50.724]                 }
  [20:54:50.724]             }
  [20:54:50.724]         }))
  [20:54:50.724]     }, error = function(ex) {
  [20:54:50.724]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.724]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.724]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.724]     }, finally = {
  [20:54:50.724]         {
  [20:54:50.724]             NULL
  [20:54:50.724]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.724]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.724]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.724]                 label = NULL, ...) 
  [20:54:50.724]             {
  [20:54:50.724]                 if (substitute) 
  [20:54:50.724]                   expr <- substitute(expr)
  [20:54:50.724]                 local <- as.logical(local)
  [20:54:50.724]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.724]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.724]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.724]                   label = label, ...)
  [20:54:50.724]                 if (!future$lazy) 
  [20:54:50.724]                   future <- run(future)
  [20:54:50.724]                 invisible(future)
  [20:54:50.724]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.724]         }
  [20:54:50.724]         base::options(...future.oldOptions)
  [20:54:50.724]     })
  [20:54:50.724]     Sys.time
  [20:54:50.724]     if (base::is.na(TRUE)) {
  [20:54:50.724]     }
  [20:54:50.724]     else {
  [20:54:50.724]         base::sink(type = "output", split = FALSE)
  [20:54:50.724]         if (TRUE) {
  [20:54:50.724]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.724]         }
  [20:54:50.724]         else {
  [20:54:50.724]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.724]         }
  [20:54:50.724]         base::close(...future.stdout)
  [20:54:50.724]         ...future.stdout <- NULL
  [20:54:50.724]     }
  [20:54:50.724]     ...future.result$conditions <- ...future.conditions
  [20:54:50.724]     ...future.result
  [20:54:50.724] }
  [20:54:50.728] plan(): Setting new future strategy stack:
  [20:54:50.728] List of future strategies:
  [20:54:50.728] 1. sequential:
  [20:54:50.728]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.728]    - tweaked: FALSE
  [20:54:50.728]    - call: NULL
  [20:54:50.729] plan(): nbrOfWorkers() = 1
  [20:54:50.730] plan(): Setting new future strategy stack:
  [20:54:50.731] List of future strategies:
  [20:54:50.731] 1. sequential:
  [20:54:50.731]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.731]    - tweaked: FALSE
  [20:54:50.731]    - call: plan(strategy)
  [20:54:50.731] plan(): nbrOfWorkers() = 1
  [20:54:50.732] SequentialFuture started (and completed)
  [20:54:50.733] getGlobalsAndPackages() ...
  [20:54:50.733] Searching for globals...
  [20:54:50.734] - globals found: [1] '{'
  [20:54:50.734] Searching for globals ... DONE
  [20:54:50.735] Resolving globals: FALSE
  [20:54:50.735] 
  [20:54:50.736] 
  [20:54:50.736] getGlobalsAndPackages() ... DONE
  [20:54:50.737] Packages needed by the future expression (n = 0): <none>
  [20:54:50.738] Packages needed by future strategies (n = 0): <none>
  [20:54:50.742] {
  [20:54:50.742]     {
  [20:54:50.742]         ...future.startTime <- base::Sys.time()
  [20:54:50.742]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.742]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.742]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.742]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.742]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.742]         {
  [20:54:50.742]             {
  [20:54:50.742]                 has_future <- base::requireNamespace("future", 
  [20:54:50.742]                   quietly = TRUE)
  [20:54:50.742]                 version <- if (has_future) 
  [20:54:50.742]                   utils::packageVersion("future")
  [20:54:50.742]                 else NULL
  [20:54:50.742]                 if (!has_future || version < "1.8.0") {
  [20:54:50.742]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.742]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.742]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.742]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.742]                       "release", "version")], collapse = " "), 
  [20:54:50.742]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.742]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.742]                     info)
  [20:54:50.742]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.742]                   if (!has_future) {
  [20:54:50.742]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.742]                       info)
  [20:54:50.742]                   }
  [20:54:50.742]                   else {
  [20:54:50.742]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.742]                       info, version)
  [20:54:50.742]                   }
  [20:54:50.742]                   base::stop(msg)
  [20:54:50.742]                 }
  [20:54:50.742]             }
  [20:54:50.742]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.742]         }
  [20:54:50.742]     }
  [20:54:50.742]     if (base::is.na(TRUE)) {
  [20:54:50.742]     }
  [20:54:50.742]     else {
  [20:54:50.742]         if (TRUE) {
  [20:54:50.742]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.742]                 open = "w")
  [20:54:50.742]         }
  [20:54:50.742]         else {
  [20:54:50.742]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.742]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.742]         }
  [20:54:50.742]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.742]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.742]             base::sink(type = "output", split = FALSE)
  [20:54:50.742]             base::close(...future.stdout)
  [20:54:50.742]         }, add = TRUE)
  [20:54:50.742]     }
  [20:54:50.742]     ...future.frame <- base::sys.nframe()
  [20:54:50.742]     ...future.conditions <- base::list()
  [20:54:50.742]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.742]     ...future.result <- base::tryCatch({
  [20:54:50.742]         base::withCallingHandlers({
  [20:54:50.742]             ...future.value <- base::withVisible(base::local({
  [20:54:50.742]                 4
  [20:54:50.742]             }))
  [20:54:50.742]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.742]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.742]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.742]                 version = "1.8")
  [20:54:50.742]         }, condition = base::local({
  [20:54:50.742]             c <- base::c
  [20:54:50.742]             inherits <- base::inherits
  [20:54:50.742]             invokeRestart <- base::invokeRestart
  [20:54:50.742]             length <- base::length
  [20:54:50.742]             list <- base::list
  [20:54:50.742]             seq.int <- base::seq.int
  [20:54:50.742]             signalCondition <- base::signalCondition
  [20:54:50.742]             sys.calls <- base::sys.calls
  [20:54:50.742]             Sys.time <- base::Sys.time
  [20:54:50.742]             `[[` <- base::`[[`
  [20:54:50.742]             `+` <- base::`+`
  [20:54:50.742]             `<<-` <- base::`<<-`
  [20:54:50.742]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.742]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.742]                   3L)]
  [20:54:50.742]             }
  [20:54:50.742]             function(cond) {
  [20:54:50.742]                 if (inherits(cond, "error")) {
  [20:54:50.742]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.742]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.742]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.742]                   signalCondition(cond)
  [20:54:50.742]                 }
  [20:54:50.742]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.742]                 ))) {
  [20:54:50.742]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.742]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.742]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.742]                   if (!signal) {
  [20:54:50.742]                     muffleCondition <- function (cond) 
  [20:54:50.742]                     {
  [20:54:50.742]                       inherits <- base::inherits
  [20:54:50.742]                       invokeRestart <- base::invokeRestart
  [20:54:50.742]                       muffled <- FALSE
  [20:54:50.742]                       if (inherits(cond, "message")) {
  [20:54:50.742]                         invokeRestart("muffleMessage")
  [20:54:50.742]                         muffled <- TRUE
  [20:54:50.742]                       }
  [20:54:50.742]                       else if (inherits(cond, "warning")) {
  [20:54:50.742]                         invokeRestart("muffleWarning")
  [20:54:50.742]                         muffled <- TRUE
  [20:54:50.742]                       }
  [20:54:50.742]                       else if (inherits(cond, "condition")) {
  [20:54:50.742]                         computeRestarts <- base::computeRestarts
  [20:54:50.742]                         grepl <- base::grepl
  [20:54:50.742]                         is.null <- base::is.null
  [20:54:50.742]                         restarts <- computeRestarts(cond)
  [20:54:50.742]                         for (restart in restarts) {
  [20:54:50.742]                           name <- restart$name
  [20:54:50.742]                           if (is.null(name)) 
  [20:54:50.742]                             next
  [20:54:50.742]                           if (!grepl("^muffle", name)) 
  [20:54:50.742]                             next
  [20:54:50.742]                           invokeRestart(restart)
  [20:54:50.742]                           muffled <- TRUE
  [20:54:50.742]                           break
  [20:54:50.742]                         }
  [20:54:50.742]                       }
  [20:54:50.742]                       invisible(muffled)
  [20:54:50.742]                     }
  [20:54:50.742]                     muffleCondition(cond)
  [20:54:50.742]                   }
  [20:54:50.742]                 }
  [20:54:50.742]             }
  [20:54:50.742]         }))
  [20:54:50.742]     }, error = function(ex) {
  [20:54:50.742]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.742]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.742]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.742]     }, finally = {
  [20:54:50.742]         {
  [20:54:50.742]             NULL
  [20:54:50.742]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.742]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.742]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.742]                 label = NULL, ...) 
  [20:54:50.742]             {
  [20:54:50.742]                 if (substitute) 
  [20:54:50.742]                   expr <- substitute(expr)
  [20:54:50.742]                 local <- as.logical(local)
  [20:54:50.742]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.742]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.742]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.742]                   label = label, ...)
  [20:54:50.742]                 if (!future$lazy) 
  [20:54:50.742]                   future <- run(future)
  [20:54:50.742]                 invisible(future)
  [20:54:50.742]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.742]         }
  [20:54:50.742]         base::options(...future.oldOptions)
  [20:54:50.742]     })
  [20:54:50.742]     Sys.time
  [20:54:50.742]     if (base::is.na(TRUE)) {
  [20:54:50.742]     }
  [20:54:50.742]     else {
  [20:54:50.742]         base::sink(type = "output", split = FALSE)
  [20:54:50.742]         if (TRUE) {
  [20:54:50.742]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.742]         }
  [20:54:50.742]         else {
  [20:54:50.742]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.742]         }
  [20:54:50.742]         base::close(...future.stdout)
  [20:54:50.742]         ...future.stdout <- NULL
  [20:54:50.742]     }
  [20:54:50.742]     ...future.result$conditions <- ...future.conditions
  [20:54:50.742]     ...future.result
  [20:54:50.742] }
  [20:54:50.746] plan(): Setting new future strategy stack:
  [20:54:50.747] List of future strategies:
  [20:54:50.747] 1. sequential:
  [20:54:50.747]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.747]    - tweaked: FALSE
  [20:54:50.747]    - call: NULL
  [20:54:50.748] plan(): nbrOfWorkers() = 1
  [20:54:50.749] plan(): Setting new future strategy stack:
  [20:54:50.749] List of future strategies:
  [20:54:50.749] 1. sequential:
  [20:54:50.749]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.749]    - tweaked: FALSE
  [20:54:50.749]    - call: plan(strategy)
  [20:54:50.750] plan(): nbrOfWorkers() = 1
  [20:54:50.750] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x556b11656e80> 
  Classes 'listenv', 'environment' <environment: 0x556b119a2ce0> 
   - 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" ...
  [20:54:50.794] resolve() on list environment ...
  [20:54:50.795]  recursive: 0
  [20:54:50.797]  length: 6
  [20:54:50.797]  elements: 'a', 'b', 'c', 'd', '', ''
  [20:54:50.797] signalConditionsASAP(numeric, pos=1) ...
  [20:54:50.798] - nx: 6
  [20:54:50.798] - relay: TRUE
  [20:54:50.798] - stdout: TRUE
  [20:54:50.798] - signal: TRUE
  [20:54:50.799] - resignal: FALSE
  [20:54:50.799] - force: TRUE
  [20:54:50.799] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.799] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.800]  - until=2
  [20:54:50.800]  - relaying element #2
  [20:54:50.800] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.800] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.800] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:50.801]  length: 5 (resolved future 1)
  [20:54:50.801] Future #2
  [20:54:50.801] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:50.802] - nx: 6
  [20:54:50.802] - relay: TRUE
  [20:54:50.802] - stdout: TRUE
  [20:54:50.802] - signal: TRUE
  [20:54:50.802] - resignal: FALSE
  [20:54:50.803] - force: TRUE
  [20:54:50.803] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.803] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.803]  - until=2
  [20:54:50.804]  - relaying element #2
  [20:54:50.804] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.804] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.805] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:50.805]  length: 4 (resolved future 2)
  [20:54:50.805] Future #3
  [20:54:50.806] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:50.806] - nx: 6
  [20:54:50.806] - relay: TRUE
  [20:54:50.806] - stdout: TRUE
  [20:54:50.806] - signal: TRUE
  [20:54:50.807] - resignal: FALSE
  [20:54:50.807] - force: TRUE
  [20:54:50.807] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.807] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:50.808]  - until=3
  [20:54:50.808]  - relaying element #3
  [20:54:50.808] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.809] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.809] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:50.809]  length: 3 (resolved future 3)
  [20:54:50.809] Future #4
  [20:54:50.826] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:50.826] - nx: 6
  [20:54:50.827] - relay: TRUE
  [20:54:50.827] - stdout: TRUE
  [20:54:50.827] - signal: TRUE
  [20:54:50.827] - resignal: FALSE
  [20:54:50.827] - force: TRUE
  [20:54:50.828] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.828] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:50.828]  - until=4
  [20:54:50.828]  - relaying element #4
  [20:54:50.829] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.829] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.830] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:50.830]  length: 2 (resolved future 4)
  [20:54:50.830] signalConditionsASAP(NULL, pos=5) ...
  [20:54:50.830] - nx: 6
  [20:54:50.831] - relay: TRUE
  [20:54:50.831] - stdout: TRUE
  [20:54:50.831] - signal: TRUE
  [20:54:50.831] - resignal: FALSE
  [20:54:50.832] - force: TRUE
  [20:54:50.832] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.832] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.832]  - until=6
  [20:54:50.833]  - relaying element #6
  [20:54:50.833] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.833] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.833] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:50.834]  length: 1 (resolved future 5)
  [20:54:50.834] signalConditionsASAP(numeric, pos=6) ...
  [20:54:50.834] - nx: 6
  [20:54:50.834] - relay: TRUE
  [20:54:50.834] - stdout: TRUE
  [20:54:50.835] - signal: TRUE
  [20:54:50.835] - resignal: FALSE
  [20:54:50.835] - force: TRUE
  [20:54:50.835] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:50.836] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.836]  - until=6
  [20:54:50.836] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.836] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.837] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:50.837]  length: 0 (resolved future 6)
  [20:54:50.837] Relaying remaining futures
  [20:54:50.837] signalConditionsASAP(NULL, pos=0) ...
  [20:54:50.838] - nx: 6
  [20:54:50.838] - relay: TRUE
  [20:54:50.838] - stdout: TRUE
  [20:54:50.838] - signal: TRUE
  [20:54:50.839] - resignal: FALSE
  [20:54:50.839] - force: TRUE
  [20:54:50.839] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.839] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [20:54:50.840] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:50.840] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:50.840] signalConditionsASAP(NULL, pos=0) ... done
  [20:54:50.841] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x556b106298f0> 
   - 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)
  [20:54:50.862] getGlobalsAndPackages() ...
  [20:54:50.862] Searching for globals...
  [20:54:50.863] 
  [20:54:50.863] Searching for globals ... DONE
  [20:54:50.863] - globals: [0] <none>
  [20:54:50.864] getGlobalsAndPackages() ... DONE
  [20:54:50.869] Packages needed by the future expression (n = 0): <none>
  [20:54:50.870] Packages needed by future strategies (n = 0): <none>
  [20:54:50.890] {
  [20:54:50.890]     {
  [20:54:50.890]         ...future.startTime <- base::Sys.time()
  [20:54:50.890]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.890]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.890]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.890]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.890]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.890]         {
  [20:54:50.890]             {
  [20:54:50.890]                 has_future <- base::requireNamespace("future", 
  [20:54:50.890]                   quietly = TRUE)
  [20:54:50.890]                 version <- if (has_future) 
  [20:54:50.890]                   utils::packageVersion("future")
  [20:54:50.890]                 else NULL
  [20:54:50.890]                 if (!has_future || version < "1.8.0") {
  [20:54:50.890]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.890]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.890]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.890]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.890]                       "release", "version")], collapse = " "), 
  [20:54:50.890]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.890]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.890]                     info)
  [20:54:50.890]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.890]                   if (!has_future) {
  [20:54:50.890]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.890]                       info)
  [20:54:50.890]                   }
  [20:54:50.890]                   else {
  [20:54:50.890]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.890]                       info, version)
  [20:54:50.890]                   }
  [20:54:50.890]                   base::stop(msg)
  [20:54:50.890]                 }
  [20:54:50.890]             }
  [20:54:50.890]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.890]         }
  [20:54:50.890]     }
  [20:54:50.890]     if (base::is.na(TRUE)) {
  [20:54:50.890]     }
  [20:54:50.890]     else {
  [20:54:50.890]         if (TRUE) {
  [20:54:50.890]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.890]                 open = "w")
  [20:54:50.890]         }
  [20:54:50.890]         else {
  [20:54:50.890]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.890]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.890]         }
  [20:54:50.890]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.890]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.890]             base::sink(type = "output", split = FALSE)
  [20:54:50.890]             base::close(...future.stdout)
  [20:54:50.890]         }, add = TRUE)
  [20:54:50.890]     }
  [20:54:50.890]     ...future.frame <- base::sys.nframe()
  [20:54:50.890]     ...future.conditions <- base::list()
  [20:54:50.890]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.890]     ...future.result <- base::tryCatch({
  [20:54:50.890]         base::withCallingHandlers({
  [20:54:50.890]             ...future.value <- base::withVisible(base::local(2))
  [20:54:50.890]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.890]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.890]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.890]                 version = "1.8")
  [20:54:50.890]         }, condition = base::local({
  [20:54:50.890]             c <- base::c
  [20:54:50.890]             inherits <- base::inherits
  [20:54:50.890]             invokeRestart <- base::invokeRestart
  [20:54:50.890]             length <- base::length
  [20:54:50.890]             list <- base::list
  [20:54:50.890]             seq.int <- base::seq.int
  [20:54:50.890]             signalCondition <- base::signalCondition
  [20:54:50.890]             sys.calls <- base::sys.calls
  [20:54:50.890]             Sys.time <- base::Sys.time
  [20:54:50.890]             `[[` <- base::`[[`
  [20:54:50.890]             `+` <- base::`+`
  [20:54:50.890]             `<<-` <- base::`<<-`
  [20:54:50.890]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.890]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.890]                   3L)]
  [20:54:50.890]             }
  [20:54:50.890]             function(cond) {
  [20:54:50.890]                 if (inherits(cond, "error")) {
  [20:54:50.890]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.890]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.890]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.890]                   signalCondition(cond)
  [20:54:50.890]                 }
  [20:54:50.890]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.890]                 ))) {
  [20:54:50.890]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.890]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.890]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.890]                   if (!signal) {
  [20:54:50.890]                     muffleCondition <- function (cond) 
  [20:54:50.890]                     {
  [20:54:50.890]                       inherits <- base::inherits
  [20:54:50.890]                       invokeRestart <- base::invokeRestart
  [20:54:50.890]                       muffled <- FALSE
  [20:54:50.890]                       if (inherits(cond, "message")) {
  [20:54:50.890]                         invokeRestart("muffleMessage")
  [20:54:50.890]                         muffled <- TRUE
  [20:54:50.890]                       }
  [20:54:50.890]                       else if (inherits(cond, "warning")) {
  [20:54:50.890]                         invokeRestart("muffleWarning")
  [20:54:50.890]                         muffled <- TRUE
  [20:54:50.890]                       }
  [20:54:50.890]                       else if (inherits(cond, "condition")) {
  [20:54:50.890]                         computeRestarts <- base::computeRestarts
  [20:54:50.890]                         grepl <- base::grepl
  [20:54:50.890]                         is.null <- base::is.null
  [20:54:50.890]                         restarts <- computeRestarts(cond)
  [20:54:50.890]                         for (restart in restarts) {
  [20:54:50.890]                           name <- restart$name
  [20:54:50.890]                           if (is.null(name)) 
  [20:54:50.890]                             next
  [20:54:50.890]                           if (!grepl("^muffle", name)) 
  [20:54:50.890]                             next
  [20:54:50.890]                           invokeRestart(restart)
  [20:54:50.890]                           muffled <- TRUE
  [20:54:50.890]                           break
  [20:54:50.890]                         }
  [20:54:50.890]                       }
  [20:54:50.890]                       invisible(muffled)
  [20:54:50.890]                     }
  [20:54:50.890]                     muffleCondition(cond)
  [20:54:50.890]                   }
  [20:54:50.890]                 }
  [20:54:50.890]             }
  [20:54:50.890]         }))
  [20:54:50.890]     }, error = function(ex) {
  [20:54:50.890]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.890]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.890]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.890]     }, finally = {
  [20:54:50.890]         {
  [20:54:50.890]             NULL
  [20:54:50.890]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.890]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.890]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.890]                 label = NULL, ...) 
  [20:54:50.890]             {
  [20:54:50.890]                 if (substitute) 
  [20:54:50.890]                   expr <- substitute(expr)
  [20:54:50.890]                 local <- as.logical(local)
  [20:54:50.890]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.890]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.890]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.890]                   label = label, ...)
  [20:54:50.890]                 if (!future$lazy) 
  [20:54:50.890]                   future <- run(future)
  [20:54:50.890]                 invisible(future)
  [20:54:50.890]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.890]         }
  [20:54:50.890]         base::options(...future.oldOptions)
  [20:54:50.890]     })
  [20:54:50.890]     Sys.time
  [20:54:50.890]     if (base::is.na(TRUE)) {
  [20:54:50.890]     }
  [20:54:50.890]     else {
  [20:54:50.890]         base::sink(type = "output", split = FALSE)
  [20:54:50.890]         if (TRUE) {
  [20:54:50.890]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.890]         }
  [20:54:50.890]         else {
  [20:54:50.890]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.890]         }
  [20:54:50.890]         base::close(...future.stdout)
  [20:54:50.890]         ...future.stdout <- NULL
  [20:54:50.890]     }
  [20:54:50.890]     ...future.result$conditions <- ...future.conditions
  [20:54:50.890]     ...future.result
  [20:54:50.890] }
  [20:54:50.895] plan(): Setting new future strategy stack:
  [20:54:50.895] List of future strategies:
  [20:54:50.895] 1. sequential:
  [20:54:50.895]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.895]    - tweaked: FALSE
  [20:54:50.895]    - call: NULL
  [20:54:50.896] plan(): nbrOfWorkers() = 1
  [20:54:50.897] plan(): Setting new future strategy stack:
  [20:54:50.897] List of future strategies:
  [20:54:50.897] 1. sequential:
  [20:54:50.897]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.897]    - tweaked: FALSE
  [20:54:50.897]    - call: plan(strategy)
  [20:54:50.898] plan(): nbrOfWorkers() = 1
  [20:54:50.898] SequentialFuture started (and completed)
  [20:54:50.899] getGlobalsAndPackages() ...
  [20:54:50.899] Searching for globals...
  [20:54:50.900] 
  [20:54:50.900] Searching for globals ... DONE
  [20:54:50.900] - globals: [0] <none>
  [20:54:50.901] getGlobalsAndPackages() ... DONE
  [20:54:50.902] Packages needed by the future expression (n = 0): <none>
  [20:54:50.902] Packages needed by future strategies (n = 0): <none>
  [20:54:50.922] {
  [20:54:50.922]     {
  [20:54:50.922]         ...future.startTime <- base::Sys.time()
  [20:54:50.922]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.922]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.922]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.922]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.922]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.922]         {
  [20:54:50.922]             {
  [20:54:50.922]                 has_future <- base::requireNamespace("future", 
  [20:54:50.922]                   quietly = TRUE)
  [20:54:50.922]                 version <- if (has_future) 
  [20:54:50.922]                   utils::packageVersion("future")
  [20:54:50.922]                 else NULL
  [20:54:50.922]                 if (!has_future || version < "1.8.0") {
  [20:54:50.922]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.922]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.922]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.922]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.922]                       "release", "version")], collapse = " "), 
  [20:54:50.922]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.922]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.922]                     info)
  [20:54:50.922]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.922]                   if (!has_future) {
  [20:54:50.922]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.922]                       info)
  [20:54:50.922]                   }
  [20:54:50.922]                   else {
  [20:54:50.922]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.922]                       info, version)
  [20:54:50.922]                   }
  [20:54:50.922]                   base::stop(msg)
  [20:54:50.922]                 }
  [20:54:50.922]             }
  [20:54:50.922]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.922]         }
  [20:54:50.922]     }
  [20:54:50.922]     if (base::is.na(TRUE)) {
  [20:54:50.922]     }
  [20:54:50.922]     else {
  [20:54:50.922]         if (TRUE) {
  [20:54:50.922]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.922]                 open = "w")
  [20:54:50.922]         }
  [20:54:50.922]         else {
  [20:54:50.922]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.922]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.922]         }
  [20:54:50.922]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.922]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.922]             base::sink(type = "output", split = FALSE)
  [20:54:50.922]             base::close(...future.stdout)
  [20:54:50.922]         }, add = TRUE)
  [20:54:50.922]     }
  [20:54:50.922]     ...future.frame <- base::sys.nframe()
  [20:54:50.922]     ...future.conditions <- base::list()
  [20:54:50.922]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.922]     ...future.result <- base::tryCatch({
  [20:54:50.922]         base::withCallingHandlers({
  [20:54:50.922]             ...future.value <- base::withVisible(base::local(NULL))
  [20:54:50.922]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.922]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.922]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.922]                 version = "1.8")
  [20:54:50.922]         }, condition = base::local({
  [20:54:50.922]             c <- base::c
  [20:54:50.922]             inherits <- base::inherits
  [20:54:50.922]             invokeRestart <- base::invokeRestart
  [20:54:50.922]             length <- base::length
  [20:54:50.922]             list <- base::list
  [20:54:50.922]             seq.int <- base::seq.int
  [20:54:50.922]             signalCondition <- base::signalCondition
  [20:54:50.922]             sys.calls <- base::sys.calls
  [20:54:50.922]             Sys.time <- base::Sys.time
  [20:54:50.922]             `[[` <- base::`[[`
  [20:54:50.922]             `+` <- base::`+`
  [20:54:50.922]             `<<-` <- base::`<<-`
  [20:54:50.922]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.922]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.922]                   3L)]
  [20:54:50.922]             }
  [20:54:50.922]             function(cond) {
  [20:54:50.922]                 if (inherits(cond, "error")) {
  [20:54:50.922]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.922]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.922]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.922]                   signalCondition(cond)
  [20:54:50.922]                 }
  [20:54:50.922]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.922]                 ))) {
  [20:54:50.922]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.922]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.922]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.922]                   if (!signal) {
  [20:54:50.922]                     muffleCondition <- function (cond) 
  [20:54:50.922]                     {
  [20:54:50.922]                       inherits <- base::inherits
  [20:54:50.922]                       invokeRestart <- base::invokeRestart
  [20:54:50.922]                       muffled <- FALSE
  [20:54:50.922]                       if (inherits(cond, "message")) {
  [20:54:50.922]                         invokeRestart("muffleMessage")
  [20:54:50.922]                         muffled <- TRUE
  [20:54:50.922]                       }
  [20:54:50.922]                       else if (inherits(cond, "warning")) {
  [20:54:50.922]                         invokeRestart("muffleWarning")
  [20:54:50.922]                         muffled <- TRUE
  [20:54:50.922]                       }
  [20:54:50.922]                       else if (inherits(cond, "condition")) {
  [20:54:50.922]                         computeRestarts <- base::computeRestarts
  [20:54:50.922]                         grepl <- base::grepl
  [20:54:50.922]                         is.null <- base::is.null
  [20:54:50.922]                         restarts <- computeRestarts(cond)
  [20:54:50.922]                         for (restart in restarts) {
  [20:54:50.922]                           name <- restart$name
  [20:54:50.922]                           if (is.null(name)) 
  [20:54:50.922]                             next
  [20:54:50.922]                           if (!grepl("^muffle", name)) 
  [20:54:50.922]                             next
  [20:54:50.922]                           invokeRestart(restart)
  [20:54:50.922]                           muffled <- TRUE
  [20:54:50.922]                           break
  [20:54:50.922]                         }
  [20:54:50.922]                       }
  [20:54:50.922]                       invisible(muffled)
  [20:54:50.922]                     }
  [20:54:50.922]                     muffleCondition(cond)
  [20:54:50.922]                   }
  [20:54:50.922]                 }
  [20:54:50.922]             }
  [20:54:50.922]         }))
  [20:54:50.922]     }, error = function(ex) {
  [20:54:50.922]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.922]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.922]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.922]     }, finally = {
  [20:54:50.922]         {
  [20:54:50.922]             NULL
  [20:54:50.922]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.922]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.922]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.922]                 label = NULL, ...) 
  [20:54:50.922]             {
  [20:54:50.922]                 if (substitute) 
  [20:54:50.922]                   expr <- substitute(expr)
  [20:54:50.922]                 local <- as.logical(local)
  [20:54:50.922]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.922]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.922]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.922]                   label = label, ...)
  [20:54:50.922]                 if (!future$lazy) 
  [20:54:50.922]                   future <- run(future)
  [20:54:50.922]                 invisible(future)
  [20:54:50.922]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.922]         }
  [20:54:50.922]         base::options(...future.oldOptions)
  [20:54:50.922]     })
  [20:54:50.922]     Sys.time
  [20:54:50.922]     if (base::is.na(TRUE)) {
  [20:54:50.922]     }
  [20:54:50.922]     else {
  [20:54:50.922]         base::sink(type = "output", split = FALSE)
  [20:54:50.922]         if (TRUE) {
  [20:54:50.922]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.922]         }
  [20:54:50.922]         else {
  [20:54:50.922]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.922]         }
  [20:54:50.922]         base::close(...future.stdout)
  [20:54:50.922]         ...future.stdout <- NULL
  [20:54:50.922]     }
  [20:54:50.922]     ...future.result$conditions <- ...future.conditions
  [20:54:50.922]     ...future.result
  [20:54:50.922] }
  [20:54:50.927] plan(): Setting new future strategy stack:
  [20:54:50.927] List of future strategies:
  [20:54:50.927] 1. sequential:
  [20:54:50.927]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.927]    - tweaked: FALSE
  [20:54:50.927]    - call: NULL
  [20:54:50.928] plan(): nbrOfWorkers() = 1
  [20:54:50.929] plan(): Setting new future strategy stack:
  [20:54:50.929] List of future strategies:
  [20:54:50.929] 1. sequential:
  [20:54:50.929]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.929]    - tweaked: FALSE
  [20:54:50.929]    - call: plan(strategy)
  [20:54:50.930] plan(): nbrOfWorkers() = 1
  [20:54:50.931] SequentialFuture started (and completed)
  [20:54:50.931] getGlobalsAndPackages() ...
  [20:54:50.932] Searching for globals...
  [20:54:50.933] - globals found: [1] '{'
  [20:54:50.933] Searching for globals ... DONE
  [20:54:50.934] Resolving globals: FALSE
  [20:54:50.934] 
  [20:54:50.935] 
  [20:54:50.935] getGlobalsAndPackages() ... DONE
  [20:54:50.936] Packages needed by the future expression (n = 0): <none>
  [20:54:50.937] Packages needed by future strategies (n = 0): <none>
  [20:54:50.957] {
  [20:54:50.957]     {
  [20:54:50.957]         ...future.startTime <- base::Sys.time()
  [20:54:50.957]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:54:50.957]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:54:50.957]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:54:50.957]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:54:50.957]             future.resolve.recursive = NULL, width = 80L)
  [20:54:50.957]         {
  [20:54:50.957]             {
  [20:54:50.957]                 has_future <- base::requireNamespace("future", 
  [20:54:50.957]                   quietly = TRUE)
  [20:54:50.957]                 version <- if (has_future) 
  [20:54:50.957]                   utils::packageVersion("future")
  [20:54:50.957]                 else NULL
  [20:54:50.957]                 if (!has_future || version < "1.8.0") {
  [20:54:50.957]                   info <- base::c(r_version = base::gsub("R version ", 
  [20:54:50.957]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:54:50.957]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:54:50.957]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:54:50.957]                       "release", "version")], collapse = " "), 
  [20:54:50.957]                     hostname = base::Sys.info()[["nodename"]])
  [20:54:50.957]                   info <- base::sprintf("%s: %s", base::names(info), 
  [20:54:50.957]                     info)
  [20:54:50.957]                   info <- base::paste(info, collapse = "; ")
  [20:54:50.957]                   if (!has_future) {
  [20:54:50.957]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:54:50.957]                       info)
  [20:54:50.957]                   }
  [20:54:50.957]                   else {
  [20:54:50.957]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:54:50.957]                       info, version)
  [20:54:50.957]                   }
  [20:54:50.957]                   base::stop(msg)
  [20:54:50.957]                 }
  [20:54:50.957]             }
  [20:54:50.957]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:54:50.957]         }
  [20:54:50.957]     }
  [20:54:50.957]     if (base::is.na(TRUE)) {
  [20:54:50.957]     }
  [20:54:50.957]     else {
  [20:54:50.957]         if (TRUE) {
  [20:54:50.957]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:54:50.957]                 open = "w")
  [20:54:50.957]         }
  [20:54:50.957]         else {
  [20:54:50.957]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:54:50.957]                 windows = "NUL", "/dev/null"), open = "w")
  [20:54:50.957]         }
  [20:54:50.957]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:54:50.957]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:54:50.957]             base::sink(type = "output", split = FALSE)
  [20:54:50.957]             base::close(...future.stdout)
  [20:54:50.957]         }, add = TRUE)
  [20:54:50.957]     }
  [20:54:50.957]     ...future.frame <- base::sys.nframe()
  [20:54:50.957]     ...future.conditions <- base::list()
  [20:54:50.957]     ...future.rng <- base::globalenv()$.Random.seed
  [20:54:50.957]     ...future.result <- base::tryCatch({
  [20:54:50.957]         base::withCallingHandlers({
  [20:54:50.957]             ...future.value <- base::withVisible(base::local({
  [20:54:50.957]                 4
  [20:54:50.957]             }))
  [20:54:50.957]             future::FutureResult(value = ...future.value$value, 
  [20:54:50.957]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.957]                   ...future.rng), started = ...future.startTime, 
  [20:54:50.957]                 version = "1.8")
  [20:54:50.957]         }, condition = base::local({
  [20:54:50.957]             c <- base::c
  [20:54:50.957]             inherits <- base::inherits
  [20:54:50.957]             invokeRestart <- base::invokeRestart
  [20:54:50.957]             length <- base::length
  [20:54:50.957]             list <- base::list
  [20:54:50.957]             seq.int <- base::seq.int
  [20:54:50.957]             signalCondition <- base::signalCondition
  [20:54:50.957]             sys.calls <- base::sys.calls
  [20:54:50.957]             Sys.time <- base::Sys.time
  [20:54:50.957]             `[[` <- base::`[[`
  [20:54:50.957]             `+` <- base::`+`
  [20:54:50.957]             `<<-` <- base::`<<-`
  [20:54:50.957]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:54:50.957]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:54:50.957]                   3L)]
  [20:54:50.957]             }
  [20:54:50.957]             function(cond) {
  [20:54:50.957]                 if (inherits(cond, "error")) {
  [20:54:50.957]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.957]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:54:50.957]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:54:50.957]                   signalCondition(cond)
  [20:54:50.957]                 }
  [20:54:50.957]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:54:50.957]                 ))) {
  [20:54:50.957]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:54:50.957]                   ...future.conditions[[length(...future.conditions) + 
  [20:54:50.957]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:54:50.957]                   if (!signal) {
  [20:54:50.957]                     muffleCondition <- function (cond) 
  [20:54:50.957]                     {
  [20:54:50.957]                       inherits <- base::inherits
  [20:54:50.957]                       invokeRestart <- base::invokeRestart
  [20:54:50.957]                       muffled <- FALSE
  [20:54:50.957]                       if (inherits(cond, "message")) {
  [20:54:50.957]                         invokeRestart("muffleMessage")
  [20:54:50.957]                         muffled <- TRUE
  [20:54:50.957]                       }
  [20:54:50.957]                       else if (inherits(cond, "warning")) {
  [20:54:50.957]                         invokeRestart("muffleWarning")
  [20:54:50.957]                         muffled <- TRUE
  [20:54:50.957]                       }
  [20:54:50.957]                       else if (inherits(cond, "condition")) {
  [20:54:50.957]                         computeRestarts <- base::computeRestarts
  [20:54:50.957]                         grepl <- base::grepl
  [20:54:50.957]                         is.null <- base::is.null
  [20:54:50.957]                         restarts <- computeRestarts(cond)
  [20:54:50.957]                         for (restart in restarts) {
  [20:54:50.957]                           name <- restart$name
  [20:54:50.957]                           if (is.null(name)) 
  [20:54:50.957]                             next
  [20:54:50.957]                           if (!grepl("^muffle", name)) 
  [20:54:50.957]                             next
  [20:54:50.957]                           invokeRestart(restart)
  [20:54:50.957]                           muffled <- TRUE
  [20:54:50.957]                           break
  [20:54:50.957]                         }
  [20:54:50.957]                       }
  [20:54:50.957]                       invisible(muffled)
  [20:54:50.957]                     }
  [20:54:50.957]                     muffleCondition(cond)
  [20:54:50.957]                   }
  [20:54:50.957]                 }
  [20:54:50.957]             }
  [20:54:50.957]         }))
  [20:54:50.957]     }, error = function(ex) {
  [20:54:50.957]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:54:50.957]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:54:50.957]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:54:50.957]     }, finally = {
  [20:54:50.957]         {
  [20:54:50.957]             NULL
  [20:54:50.957]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:54:50.957]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:54:50.957]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:54:50.957]                 label = NULL, ...) 
  [20:54:50.957]             {
  [20:54:50.957]                 if (substitute) 
  [20:54:50.957]                   expr <- substitute(expr)
  [20:54:50.957]                 local <- as.logical(local)
  [20:54:50.957]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:54:50.957]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:54:50.957]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:54:50.957]                   label = label, ...)
  [20:54:50.957]                 if (!future$lazy) 
  [20:54:50.957]                   future <- run(future)
  [20:54:50.957]                 invisible(future)
  [20:54:50.957]             }), .cleanup = FALSE, .init = FALSE)
  [20:54:50.957]         }
  [20:54:50.957]         base::options(...future.oldOptions)
  [20:54:50.957]     })
  [20:54:50.957]     Sys.time
  [20:54:50.957]     if (base::is.na(TRUE)) {
  [20:54:50.957]     }
  [20:54:50.957]     else {
  [20:54:50.957]         base::sink(type = "output", split = FALSE)
  [20:54:50.957]         if (TRUE) {
  [20:54:50.957]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:54:50.957]         }
  [20:54:50.957]         else {
  [20:54:50.957]             ...future.result["stdout"] <- base::list(NULL)
  [20:54:50.957]         }
  [20:54:50.957]         base::close(...future.stdout)
  [20:54:50.957]         ...future.stdout <- NULL
  [20:54:50.957]     }
  [20:54:50.957]     ...future.result$conditions <- ...future.conditions
  [20:54:50.957]     ...future.result
  [20:54:50.957] }
  [20:54:50.961] plan(): Setting new future strategy stack:
  [20:54:50.962] List of future strategies:
  [20:54:50.962] 1. sequential:
  [20:54:50.962]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.962]    - tweaked: FALSE
  [20:54:50.962]    - call: NULL
  [20:54:50.962] plan(): nbrOfWorkers() = 1
  [20:54:50.963] plan(): Setting new future strategy stack:
  [20:54:50.969] List of future strategies:
  [20:54:50.969] 1. sequential:
  [20:54:50.969]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:54:50.969]    - tweaked: FALSE
  [20:54:50.969]    - call: plan(strategy)
  [20:54:50.986] plan(): nbrOfWorkers() = 1
  [20:54:50.987] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x556b11ec00b0> 
  Classes 'listenv', 'environment' <environment: 0x556b117bda08> 
   - 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" "d" ...
  [20:54:51.020] resolve() on list environment ...
  [20:54:51.020]  recursive: 0
  [20:54:51.022]  length: 6
  [20:54:51.022]  elements: 'a', 'b', 'c', 'd', '', ''
  [20:54:51.023] signalConditionsASAP(numeric, pos=1) ...
  [20:54:51.023] - nx: 6
  [20:54:51.023] - relay: TRUE
  [20:54:51.023] - stdout: TRUE
  [20:54:51.024] - signal: TRUE
  [20:54:51.024] - resignal: FALSE
  [20:54:51.024] - force: TRUE
  [20:54:51.024] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.024] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.025]  - until=2
  [20:54:51.025]  - relaying element #2
  [20:54:51.025] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.025] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.026] signalConditionsASAP(NULL, pos=1) ... done
  [20:54:51.026]  length: 5 (resolved future 1)
  [20:54:51.026] Future #2
  [20:54:51.027] signalConditionsASAP(SequentialFuture, pos=2) ...
  [20:54:51.027] - nx: 6
  [20:54:51.027] - relay: TRUE
  [20:54:51.027] - stdout: TRUE
  [20:54:51.028] - signal: TRUE
  [20:54:51.028] - resignal: FALSE
  [20:54:51.028] - force: TRUE
  [20:54:51.028] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.028] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.029]  - until=2
  [20:54:51.029]  - relaying element #2
  [20:54:51.029] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.030] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.030] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [20:54:51.030]  length: 4 (resolved future 2)
  [20:54:51.031] Future #3
  [20:54:51.031] signalConditionsASAP(SequentialFuture, pos=3) ...
  [20:54:51.031] - nx: 6
  [20:54:51.031] - relay: TRUE
  [20:54:51.032] - stdout: TRUE
  [20:54:51.032] - signal: TRUE
  [20:54:51.032] - resignal: FALSE
  [20:54:51.032] - force: TRUE
  [20:54:51.032] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.033] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [20:54:51.033]  - until=3
  [20:54:51.033]  - relaying element #3
  [20:54:51.050] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:51.050] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:51.050] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [20:54:51.051]  length: 3 (resolved future 3)
  [20:54:51.051] Future #4
  [20:54:51.051] signalConditionsASAP(SequentialFuture, pos=4) ...
  [20:54:51.052] - nx: 6
  [20:54:51.052] - relay: TRUE
  [20:54:51.052] - stdout: TRUE
  [20:54:51.052] - signal: TRUE
  [20:54:51.053] - resignal: FALSE
  [20:54:51.053] - force: TRUE
  [20:54:51.053] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:51.053] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [20:54:51.054]  - until=4
  [20:54:51.054]  - relaying element #4
  [20:54:51.054] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.055] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.055] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [20:54:51.055]  length: 2 (resolved future 4)
  [20:54:51.055] signalConditionsASAP(NULL, pos=5) ...
  [20:54:51.056] - nx: 6
  [20:54:51.056] - relay: TRUE
  [20:54:51.056] - stdout: TRUE
  [20:54:51.056] - signal: TRUE
  [20:54:51.057] - resignal: FALSE
  [20:54:51.057] - force: TRUE
  [20:54:51.057] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.057] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.058]  - until=6
  [20:54:51.058]  - relaying element #6
  [20:54:51.058] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:51.058] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.058] signalConditionsASAP(NULL, pos=5) ... done
  [20:54:51.059]  length: 1 (resolved future 5)
  [20:54:51.059] signalConditionsASAP(numeric, pos=6) ...
  [20:54:51.059] - nx: 6
  [20:54:51.059] - relay: TRUE
  [20:54:51.060] - stdout: TRUE
  [20:54:51.060] - signal: TRUE
  [20:54:51.060] - resignal: FALSE
  [20:54:51.060] - force: TRUE
  [20:54:51.061] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [20:54:51.082] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.082]  - until=6
  [20:54:51.082] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [20:54:51.083] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [20:54:51.083] signalConditionsASAP(numeric, pos=6) ... done
  [20:54:51.083]  length: 0 (resolved future 6)
  [20:54:51.084] Relaying remaining futures
  [20:54:51.084] signalConditionsASAP(NULL, pos=0) ...
  [20:54:51.084] - nx: 6
  [20:54:51.084] - relay: TRUE
  [20:54:51.085] - stdout: TRUE
  [20:54:51.085] - signal: TRUE
  [20:54:51.085] - resignal: FALSE