Running ‘000.sessionDetails.R’ [7s/8s]
  Running ‘ClusterRegistry.R’ [3s/50s]
  Running ‘Future-class.R’ [2s/16s]
  Running ‘FutureError.R’ [1s/1s]
  Running ‘FutureGlobals.R’ [1s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/17s]
  Running ‘availableCores.R’ [1s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/1s]
  Running ‘cluster-missing-future-pkg.R’ [1s/2s]
  Running ‘cluster.R’ [7s/112s]
  Running ‘constant.R’ [1s/1s]
  Running ‘demo.R’ [10s/26s]
  Running ‘dotdotdot.R’ [2s/18s]
  Running ‘early-signaling.R’ [2s/36s]
  Running ‘future,labels.R’ [1s/1s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/18s]
  Running ‘futureAssign_OP.R’ [3s/20s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [4s/29s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [13s/88s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [4s/20s]
  Running ‘globals,manual.R’ [2s/2s]
  Running ‘globals,resolve.R’ [1s/17s]
  Running ‘globals,subassignment.R’ [3s/20s]
  Running ‘globals,toolarge.R’ [1s/17s]
  Running ‘globals,tricky.R’ [7s/28s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [2s/18s]
  Running ‘makeClusterPSOCK.R’ [1s/8s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [1s/1s]
  Running ‘multicore,multithreading.R’ [1s/1s]
  Running ‘multicore.R’ [1s/1s]
  Running ‘multiprocess.R’ [2s/2s]
  Running ‘multisession.R’ [4s/52s]
  Running ‘nbrOfWorkers.R’ [5s/67s]
  Running ‘nested_futures,mc.cores.R’ [5s/112s]
  Running ‘nested_futures.R’ [1s/1s]
  Running ‘non-exportable,connections.R’ [1s/17s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [7s/17s]
  Running ‘relaying.R’ [1s/2s]
  Running ‘remote.R’ [1s/18s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [2s/30s]
  Running ‘reserved-keyword-functions.R’ [1s/1s]
  Running ‘resolve.R’ [2s/4s]
  Running ‘resolved-non-blocking-test.R’ [3s/67s]
  Running ‘rng.R’ [11s/32s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/35s]
  Running ‘stdout.R’ [2s/19s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [7s/8s]
  Running ‘uuid.R’ [1s/1s]
  Running ‘whichIndex.R’ [1s/1s]
Running the tests in ‘tests/futures.R’ failed.
Complete output:
  > source("incl/start.R")
  [14:20:46.712] plan(): Setting new future strategy stack:
  [14:20:46.713] List of future strategies:
  [14:20:46.713] 1. sequential:
  [14:20:46.713]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:46.713]    - tweaked: FALSE
  [14:20:46.713]    - call: future::plan("sequential")
  [14:20:46.716] 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
  [14:20:47.056] plan(): Setting new future strategy stack:
  [14:20:47.057] List of future strategies:
  [14:20:47.057] 1. sequential:
  [14:20:47.057]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.057]    - tweaked: FALSE
  [14:20:47.057]    - call: plan(strategy)
  [14:20:47.091] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [14:20:47.093] getGlobalsAndPackages() ...
  [14:20:47.094] Searching for globals...
  [14:20:47.099] 
  [14:20:47.100] Searching for globals ... DONE
  [14:20:47.100] - globals: [0] <none>
  [14:20:47.100] getGlobalsAndPackages() ... DONE
  [14:20:47.104] Packages needed by the future expression (n = 0): <none>
  [14:20:47.105] Packages needed by future strategies (n = 0): <none>
  [14:20:47.111] {
  [14:20:47.111]     {
  [14:20:47.111]         ...future.startTime <- base::Sys.time()
  [14:20:47.111]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.111]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.111]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [14:20:47.111]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.111]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.111]         {
  [14:20:47.111]             {
  [14:20:47.111]                 has_future <- base::requireNamespace("future", 
  [14:20:47.111]                   quietly = TRUE)
  [14:20:47.111]                 version <- if (has_future) 
  [14:20:47.111]                   utils::packageVersion("future")
  [14:20:47.111]                 else NULL
  [14:20:47.111]                 if (!has_future || version < "1.8.0") {
  [14:20:47.111]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.111]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.111]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.111]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.111]                       "release", "version")], collapse = " "), 
  [14:20:47.111]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.111]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.111]                     info)
  [14:20:47.111]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.111]                   if (!has_future) {
  [14:20:47.111]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.111]                       info)
  [14:20:47.111]                   }
  [14:20:47.111]                   else {
  [14:20:47.111]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.111]                       info, version)
  [14:20:47.111]                   }
  [14:20:47.111]                   base::stop(msg)
  [14:20:47.111]                 }
  [14:20:47.111]             }
  [14:20:47.111]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.111]         }
  [14:20:47.111]     }
  [14:20:47.111]     if (base::is.na(TRUE)) {
  [14:20:47.111]     }
  [14:20:47.111]     else {
  [14:20:47.111]         if (TRUE) {
  [14:20:47.111]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.111]                 open = "w")
  [14:20:47.111]         }
  [14:20:47.111]         else {
  [14:20:47.111]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.111]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.111]         }
  [14:20:47.111]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.111]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.111]             base::sink(type = "output", split = FALSE)
  [14:20:47.111]             base::close(...future.stdout)
  [14:20:47.111]         }, add = TRUE)
  [14:20:47.111]     }
  [14:20:47.111]     ...future.frame <- base::sys.nframe()
  [14:20:47.111]     ...future.conditions <- base::list()
  [14:20:47.111]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.111]     ...future.result <- base::tryCatch({
  [14:20:47.111]         base::withCallingHandlers({
  [14:20:47.111]             ...future.value <- base::withVisible(base::local(2))
  [14:20:47.111]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.111]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.111]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.111]                 version = "1.8")
  [14:20:47.111]         }, condition = base::local({
  [14:20:47.111]             c <- base::c
  [14:20:47.111]             inherits <- base::inherits
  [14:20:47.111]             invokeRestart <- base::invokeRestart
  [14:20:47.111]             length <- base::length
  [14:20:47.111]             list <- base::list
  [14:20:47.111]             seq.int <- base::seq.int
  [14:20:47.111]             signalCondition <- base::signalCondition
  [14:20:47.111]             sys.calls <- base::sys.calls
  [14:20:47.111]             Sys.time <- base::Sys.time
  [14:20:47.111]             `[[` <- base::`[[`
  [14:20:47.111]             `+` <- base::`+`
  [14:20:47.111]             `<<-` <- base::`<<-`
  [14:20:47.111]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.111]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.111]                   3L)]
  [14:20:47.111]             }
  [14:20:47.111]             function(cond) {
  [14:20:47.111]                 if (inherits(cond, "error")) {
  [14:20:47.111]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.111]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.111]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.111]                   signalCondition(cond)
  [14:20:47.111]                 }
  [14:20:47.111]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.111]                 ))) {
  [14:20:47.111]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.111]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.111]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.111]                   if (!signal) {
  [14:20:47.111]                     muffleCondition <- function (cond) 
  [14:20:47.111]                     {
  [14:20:47.111]                       inherits <- base::inherits
  [14:20:47.111]                       invokeRestart <- base::invokeRestart
  [14:20:47.111]                       muffled <- FALSE
  [14:20:47.111]                       if (inherits(cond, "message")) {
  [14:20:47.111]                         invokeRestart("muffleMessage")
  [14:20:47.111]                         muffled <- TRUE
  [14:20:47.111]                       }
  [14:20:47.111]                       else if (inherits(cond, "warning")) {
  [14:20:47.111]                         invokeRestart("muffleWarning")
  [14:20:47.111]                         muffled <- TRUE
  [14:20:47.111]                       }
  [14:20:47.111]                       else if (inherits(cond, "condition")) {
  [14:20:47.111]                         computeRestarts <- base::computeRestarts
  [14:20:47.111]                         grepl <- base::grepl
  [14:20:47.111]                         is.null <- base::is.null
  [14:20:47.111]                         restarts <- computeRestarts(cond)
  [14:20:47.111]                         for (restart in restarts) {
  [14:20:47.111]                           name <- restart$name
  [14:20:47.111]                           if (is.null(name)) 
  [14:20:47.111]                             next
  [14:20:47.111]                           if (!grepl("^muffle", name)) 
  [14:20:47.111]                             next
  [14:20:47.111]                           invokeRestart(restart)
  [14:20:47.111]                           muffled <- TRUE
  [14:20:47.111]                           break
  [14:20:47.111]                         }
  [14:20:47.111]                       }
  [14:20:47.111]                       invisible(muffled)
  [14:20:47.111]                     }
  [14:20:47.111]                     muffleCondition(cond)
  [14:20:47.111]                   }
  [14:20:47.111]                 }
  [14:20:47.111]             }
  [14:20:47.111]         }))
  [14:20:47.111]     }, error = function(ex) {
  [14:20:47.111]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.111]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.111]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.111]     }, finally = {
  [14:20:47.111]         {
  [14:20:47.111]             NULL
  [14:20:47.111]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.111]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.111]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.111]                 label = NULL, ...) 
  [14:20:47.111]             {
  [14:20:47.111]                 if (substitute) 
  [14:20:47.111]                   expr <- substitute(expr)
  [14:20:47.111]                 local <- as.logical(local)
  [14:20:47.111]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.111]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.111]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.111]                   label = label, ...)
  [14:20:47.111]                 if (!future$lazy) 
  [14:20:47.111]                   future <- run(future)
  [14:20:47.111]                 invisible(future)
  [14:20:47.111]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.111]         }
  [14:20:47.111]         base::options(...future.oldOptions)
  [14:20:47.111]     })
  [14:20:47.111]     Sys.time
  [14:20:47.111]     if (base::is.na(TRUE)) {
  [14:20:47.111]     }
  [14:20:47.111]     else {
  [14:20:47.111]         base::sink(type = "output", split = FALSE)
  [14:20:47.111]         if (TRUE) {
  [14:20:47.111]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.111]         }
  [14:20:47.111]         else {
  [14:20:47.111]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.111]         }
  [14:20:47.111]         base::close(...future.stdout)
  [14:20:47.111]         ...future.stdout <- NULL
  [14:20:47.111]     }
  [14:20:47.111]     ...future.result$conditions <- ...future.conditions
  [14:20:47.111]     ...future.result
  [14:20:47.111] }
  [14:20:47.117] plan(): Setting new future strategy stack:
  [14:20:47.118] List of future strategies:
  [14:20:47.118] 1. sequential:
  [14:20:47.118]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.118]    - tweaked: FALSE
  [14:20:47.118]    - call: NULL
  [14:20:47.119] plan(): nbrOfWorkers() = 1
  [14:20:47.120] plan(): Setting new future strategy stack:
  [14:20:47.121] List of future strategies:
  [14:20:47.121] 1. sequential:
  [14:20:47.121]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.121]    - tweaked: FALSE
  [14:20:47.121]    - call: plan(strategy)
  [14:20:47.122] plan(): nbrOfWorkers() = 1
  [14:20:47.122] SequentialFuture started (and completed)
  [14:20:47.124] getGlobalsAndPackages() ...
  [14:20:47.124] Searching for globals...
  [14:20:47.125] 
  [14:20:47.125] Searching for globals ... DONE
  [14:20:47.126] - globals: [0] <none>
  [14:20:47.126] getGlobalsAndPackages() ... DONE
  [14:20:47.128] Packages needed by the future expression (n = 0): <none>
  [14:20:47.128] Packages needed by future strategies (n = 0): <none>
  [14:20:47.134] {
  [14:20:47.134]     {
  [14:20:47.134]         ...future.startTime <- base::Sys.time()
  [14:20:47.134]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.134]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.134]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.134]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.134]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.134]         {
  [14:20:47.134]             {
  [14:20:47.134]                 has_future <- base::requireNamespace("future", 
  [14:20:47.134]                   quietly = TRUE)
  [14:20:47.134]                 version <- if (has_future) 
  [14:20:47.134]                   utils::packageVersion("future")
  [14:20:47.134]                 else NULL
  [14:20:47.134]                 if (!has_future || version < "1.8.0") {
  [14:20:47.134]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.134]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.134]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.134]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.134]                       "release", "version")], collapse = " "), 
  [14:20:47.134]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.134]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.134]                     info)
  [14:20:47.134]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.134]                   if (!has_future) {
  [14:20:47.134]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.134]                       info)
  [14:20:47.134]                   }
  [14:20:47.134]                   else {
  [14:20:47.134]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.134]                       info, version)
  [14:20:47.134]                   }
  [14:20:47.134]                   base::stop(msg)
  [14:20:47.134]                 }
  [14:20:47.134]             }
  [14:20:47.134]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.134]         }
  [14:20:47.134]     }
  [14:20:47.134]     if (base::is.na(TRUE)) {
  [14:20:47.134]     }
  [14:20:47.134]     else {
  [14:20:47.134]         if (TRUE) {
  [14:20:47.134]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.134]                 open = "w")
  [14:20:47.134]         }
  [14:20:47.134]         else {
  [14:20:47.134]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.134]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.134]         }
  [14:20:47.134]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.134]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.134]             base::sink(type = "output", split = FALSE)
  [14:20:47.134]             base::close(...future.stdout)
  [14:20:47.134]         }, add = TRUE)
  [14:20:47.134]     }
  [14:20:47.134]     ...future.frame <- base::sys.nframe()
  [14:20:47.134]     ...future.conditions <- base::list()
  [14:20:47.134]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.134]     ...future.result <- base::tryCatch({
  [14:20:47.134]         base::withCallingHandlers({
  [14:20:47.134]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:47.134]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.134]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.134]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.134]                 version = "1.8")
  [14:20:47.134]         }, condition = base::local({
  [14:20:47.134]             c <- base::c
  [14:20:47.134]             inherits <- base::inherits
  [14:20:47.134]             invokeRestart <- base::invokeRestart
  [14:20:47.134]             length <- base::length
  [14:20:47.134]             list <- base::list
  [14:20:47.134]             seq.int <- base::seq.int
  [14:20:47.134]             signalCondition <- base::signalCondition
  [14:20:47.134]             sys.calls <- base::sys.calls
  [14:20:47.134]             Sys.time <- base::Sys.time
  [14:20:47.134]             `[[` <- base::`[[`
  [14:20:47.134]             `+` <- base::`+`
  [14:20:47.134]             `<<-` <- base::`<<-`
  [14:20:47.134]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.134]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.134]                   3L)]
  [14:20:47.134]             }
  [14:20:47.134]             function(cond) {
  [14:20:47.134]                 if (inherits(cond, "error")) {
  [14:20:47.134]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.134]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.134]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.134]                   signalCondition(cond)
  [14:20:47.134]                 }
  [14:20:47.134]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.134]                 ))) {
  [14:20:47.134]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.134]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.134]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.134]                   if (!signal) {
  [14:20:47.134]                     muffleCondition <- function (cond) 
  [14:20:47.134]                     {
  [14:20:47.134]                       inherits <- base::inherits
  [14:20:47.134]                       invokeRestart <- base::invokeRestart
  [14:20:47.134]                       muffled <- FALSE
  [14:20:47.134]                       if (inherits(cond, "message")) {
  [14:20:47.134]                         invokeRestart("muffleMessage")
  [14:20:47.134]                         muffled <- TRUE
  [14:20:47.134]                       }
  [14:20:47.134]                       else if (inherits(cond, "warning")) {
  [14:20:47.134]                         invokeRestart("muffleWarning")
  [14:20:47.134]                         muffled <- TRUE
  [14:20:47.134]                       }
  [14:20:47.134]                       else if (inherits(cond, "condition")) {
  [14:20:47.134]                         computeRestarts <- base::computeRestarts
  [14:20:47.134]                         grepl <- base::grepl
  [14:20:47.134]                         is.null <- base::is.null
  [14:20:47.134]                         restarts <- computeRestarts(cond)
  [14:20:47.134]                         for (restart in restarts) {
  [14:20:47.134]                           name <- restart$name
  [14:20:47.134]                           if (is.null(name)) 
  [14:20:47.134]                             next
  [14:20:47.134]                           if (!grepl("^muffle", name)) 
  [14:20:47.134]                             next
  [14:20:47.134]                           invokeRestart(restart)
  [14:20:47.134]                           muffled <- TRUE
  [14:20:47.134]                           break
  [14:20:47.134]                         }
  [14:20:47.134]                       }
  [14:20:47.134]                       invisible(muffled)
  [14:20:47.134]                     }
  [14:20:47.134]                     muffleCondition(cond)
  [14:20:47.134]                   }
  [14:20:47.134]                 }
  [14:20:47.134]             }
  [14:20:47.134]         }))
  [14:20:47.134]     }, error = function(ex) {
  [14:20:47.134]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.134]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.134]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.134]     }, finally = {
  [14:20:47.134]         {
  [14:20:47.134]             NULL
  [14:20:47.134]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.134]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.134]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.134]                 label = NULL, ...) 
  [14:20:47.134]             {
  [14:20:47.134]                 if (substitute) 
  [14:20:47.134]                   expr <- substitute(expr)
  [14:20:47.134]                 local <- as.logical(local)
  [14:20:47.134]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.134]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.134]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.134]                   label = label, ...)
  [14:20:47.134]                 if (!future$lazy) 
  [14:20:47.134]                   future <- run(future)
  [14:20:47.134]                 invisible(future)
  [14:20:47.134]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.134]         }
  [14:20:47.134]         base::options(...future.oldOptions)
  [14:20:47.134]     })
  [14:20:47.134]     Sys.time
  [14:20:47.134]     if (base::is.na(TRUE)) {
  [14:20:47.134]     }
  [14:20:47.134]     else {
  [14:20:47.134]         base::sink(type = "output", split = FALSE)
  [14:20:47.134]         if (TRUE) {
  [14:20:47.134]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.134]         }
  [14:20:47.134]         else {
  [14:20:47.134]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.134]         }
  [14:20:47.134]         base::close(...future.stdout)
  [14:20:47.134]         ...future.stdout <- NULL
  [14:20:47.134]     }
  [14:20:47.134]     ...future.result$conditions <- ...future.conditions
  [14:20:47.134]     ...future.result
  [14:20:47.134] }
  [14:20:47.144] plan(): Setting new future strategy stack:
  [14:20:47.144] List of future strategies:
  [14:20:47.144] 1. sequential:
  [14:20:47.144]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.144]    - tweaked: FALSE
  [14:20:47.144]    - call: NULL
  [14:20:47.145] plan(): nbrOfWorkers() = 1
  [14:20:47.147] plan(): Setting new future strategy stack:
  [14:20:47.147] List of future strategies:
  [14:20:47.147] 1. sequential:
  [14:20:47.147]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.147]    - tweaked: FALSE
  [14:20:47.147]    - call: plan(strategy)
  [14:20:47.148] plan(): nbrOfWorkers() = 1
  [14:20:47.149] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa12a378> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa4e6af8> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa12a378> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa4e6af8> 
   $  : NULL
   $  : NULL
   $  : num 6
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [14:20:47.172] resolve() on list ...
  [14:20:47.173]  recursive: 0
  [14:20:47.174]  length: 6
  [14:20:47.174]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:47.174] signalConditionsASAP(numeric, pos=1) ...
  [14:20:47.175] - nx: 6
  [14:20:47.175] - relay: TRUE
  [14:20:47.175] - stdout: TRUE
  [14:20:47.176] - signal: TRUE
  [14:20:47.176] - resignal: FALSE
  [14:20:47.176] - force: TRUE
  [14:20:47.176] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.177] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.177]  - until=2
  [14:20:47.177]  - relaying element #2
  [14:20:47.178] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.178] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.178] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:47.179]  length: 5 (resolved future 1)
  [14:20:47.179] Future #2
  [14:20:47.180] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:47.180] - nx: 6
  [14:20:47.181] - relay: TRUE
  [14:20:47.181] - stdout: TRUE
  [14:20:47.181] - signal: TRUE
  [14:20:47.182] - resignal: FALSE
  [14:20:47.182] - force: TRUE
  [14:20:47.182] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.182] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.183]  - until=2
  [14:20:47.183]  - relaying element #2
  [14:20:47.184] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.184] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.184] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:47.185]  length: 4 (resolved future 2)
  [14:20:47.185] Future #3
  [14:20:47.186] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:47.186] - nx: 6
  [14:20:47.187] - relay: TRUE
  [14:20:47.187] - stdout: TRUE
  [14:20:47.187] - signal: TRUE
  [14:20:47.187] - resignal: FALSE
  [14:20:47.188] - force: TRUE
  [14:20:47.188] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.188] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.189]  - until=3
  [14:20:47.189]  - relaying element #3
  [14:20:47.190] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.190] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.190] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:47.191]  length: 3 (resolved future 3)
  [14:20:47.191] signalConditionsASAP(NULL, pos=4) ...
  [14:20:47.191] - nx: 6
  [14:20:47.191] - relay: TRUE
  [14:20:47.192] - stdout: TRUE
  [14:20:47.192] - signal: TRUE
  [14:20:47.192] - resignal: FALSE
  [14:20:47.193] - force: TRUE
  [14:20:47.193] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.193] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.194]  - until=5
  [14:20:47.194]  - relaying element #5
  [14:20:47.194] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.195] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.195] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:47.195]  length: 2 (resolved future 4)
  [14:20:47.196] signalConditionsASAP(NULL, pos=5) ...
  [14:20:47.196] - nx: 6
  [14:20:47.196] - relay: TRUE
  [14:20:47.196] - stdout: TRUE
  [14:20:47.197] - signal: TRUE
  [14:20:47.197] - resignal: FALSE
  [14:20:47.197] - force: TRUE
  [14:20:47.198] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.198] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.198]  - until=6
  [14:20:47.199]  - relaying element #6
  [14:20:47.199] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.199] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.200] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:47.200]  length: 1 (resolved future 5)
  [14:20:47.200] signalConditionsASAP(numeric, pos=6) ...
  [14:20:47.200] - nx: 6
  [14:20:47.201] - relay: TRUE
  [14:20:47.201] - stdout: TRUE
  [14:20:47.201] - signal: TRUE
  [14:20:47.202] - resignal: FALSE
  [14:20:47.202] - force: TRUE
  [14:20:47.202] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.203] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.203]  - until=6
  [14:20:47.203] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.204] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.204] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:47.204]  length: 0 (resolved future 6)
  [14:20:47.205] Relaying remaining futures
  [14:20:47.205] signalConditionsASAP(NULL, pos=0) ...
  [14:20:47.205] - nx: 6
  [14:20:47.205] - relay: TRUE
  [14:20:47.206] - stdout: TRUE
  [14:20:47.206] - signal: TRUE
  [14:20:47.206] - resignal: FALSE
  [14:20:47.207] - force: TRUE
  [14:20:47.207] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.207] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:47.208] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.208] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.208] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:47.209] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [14:20:47.215] getGlobalsAndPackages() ...
  [14:20:47.215] Searching for globals...
  [14:20:47.216] 
  [14:20:47.216] Searching for globals ... DONE
  [14:20:47.217] - globals: [0] <none>
  [14:20:47.217] getGlobalsAndPackages() ... DONE
  [14:20:47.219] Packages needed by the future expression (n = 0): <none>
  [14:20:47.220] Packages needed by future strategies (n = 0): <none>
  [14:20:47.225] {
  [14:20:47.225]     {
  [14:20:47.225]         ...future.startTime <- base::Sys.time()
  [14:20:47.225]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.225]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.225]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.225]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.225]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.225]         {
  [14:20:47.225]             {
  [14:20:47.225]                 has_future <- base::requireNamespace("future", 
  [14:20:47.225]                   quietly = TRUE)
  [14:20:47.225]                 version <- if (has_future) 
  [14:20:47.225]                   utils::packageVersion("future")
  [14:20:47.225]                 else NULL
  [14:20:47.225]                 if (!has_future || version < "1.8.0") {
  [14:20:47.225]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.225]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.225]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.225]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.225]                       "release", "version")], collapse = " "), 
  [14:20:47.225]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.225]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.225]                     info)
  [14:20:47.225]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.225]                   if (!has_future) {
  [14:20:47.225]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.225]                       info)
  [14:20:47.225]                   }
  [14:20:47.225]                   else {
  [14:20:47.225]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.225]                       info, version)
  [14:20:47.225]                   }
  [14:20:47.225]                   base::stop(msg)
  [14:20:47.225]                 }
  [14:20:47.225]             }
  [14:20:47.225]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.225]         }
  [14:20:47.225]     }
  [14:20:47.225]     if (base::is.na(TRUE)) {
  [14:20:47.225]     }
  [14:20:47.225]     else {
  [14:20:47.225]         if (TRUE) {
  [14:20:47.225]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.225]                 open = "w")
  [14:20:47.225]         }
  [14:20:47.225]         else {
  [14:20:47.225]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.225]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.225]         }
  [14:20:47.225]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.225]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.225]             base::sink(type = "output", split = FALSE)
  [14:20:47.225]             base::close(...future.stdout)
  [14:20:47.225]         }, add = TRUE)
  [14:20:47.225]     }
  [14:20:47.225]     ...future.frame <- base::sys.nframe()
  [14:20:47.225]     ...future.conditions <- base::list()
  [14:20:47.225]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.225]     ...future.result <- base::tryCatch({
  [14:20:47.225]         base::withCallingHandlers({
  [14:20:47.225]             ...future.value <- base::withVisible(base::local(2))
  [14:20:47.225]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.225]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.225]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.225]                 version = "1.8")
  [14:20:47.225]         }, condition = base::local({
  [14:20:47.225]             c <- base::c
  [14:20:47.225]             inherits <- base::inherits
  [14:20:47.225]             invokeRestart <- base::invokeRestart
  [14:20:47.225]             length <- base::length
  [14:20:47.225]             list <- base::list
  [14:20:47.225]             seq.int <- base::seq.int
  [14:20:47.225]             signalCondition <- base::signalCondition
  [14:20:47.225]             sys.calls <- base::sys.calls
  [14:20:47.225]             Sys.time <- base::Sys.time
  [14:20:47.225]             `[[` <- base::`[[`
  [14:20:47.225]             `+` <- base::`+`
  [14:20:47.225]             `<<-` <- base::`<<-`
  [14:20:47.225]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.225]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.225]                   3L)]
  [14:20:47.225]             }
  [14:20:47.225]             function(cond) {
  [14:20:47.225]                 if (inherits(cond, "error")) {
  [14:20:47.225]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.225]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.225]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.225]                   signalCondition(cond)
  [14:20:47.225]                 }
  [14:20:47.225]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.225]                 ))) {
  [14:20:47.225]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.225]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.225]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.225]                   if (!signal) {
  [14:20:47.225]                     muffleCondition <- function (cond) 
  [14:20:47.225]                     {
  [14:20:47.225]                       inherits <- base::inherits
  [14:20:47.225]                       invokeRestart <- base::invokeRestart
  [14:20:47.225]                       muffled <- FALSE
  [14:20:47.225]                       if (inherits(cond, "message")) {
  [14:20:47.225]                         invokeRestart("muffleMessage")
  [14:20:47.225]                         muffled <- TRUE
  [14:20:47.225]                       }
  [14:20:47.225]                       else if (inherits(cond, "warning")) {
  [14:20:47.225]                         invokeRestart("muffleWarning")
  [14:20:47.225]                         muffled <- TRUE
  [14:20:47.225]                       }
  [14:20:47.225]                       else if (inherits(cond, "condition")) {
  [14:20:47.225]                         computeRestarts <- base::computeRestarts
  [14:20:47.225]                         grepl <- base::grepl
  [14:20:47.225]                         is.null <- base::is.null
  [14:20:47.225]                         restarts <- computeRestarts(cond)
  [14:20:47.225]                         for (restart in restarts) {
  [14:20:47.225]                           name <- restart$name
  [14:20:47.225]                           if (is.null(name)) 
  [14:20:47.225]                             next
  [14:20:47.225]                           if (!grepl("^muffle", name)) 
  [14:20:47.225]                             next
  [14:20:47.225]                           invokeRestart(restart)
  [14:20:47.225]                           muffled <- TRUE
  [14:20:47.225]                           break
  [14:20:47.225]                         }
  [14:20:47.225]                       }
  [14:20:47.225]                       invisible(muffled)
  [14:20:47.225]                     }
  [14:20:47.225]                     muffleCondition(cond)
  [14:20:47.225]                   }
  [14:20:47.225]                 }
  [14:20:47.225]             }
  [14:20:47.225]         }))
  [14:20:47.225]     }, error = function(ex) {
  [14:20:47.225]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.225]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.225]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.225]     }, finally = {
  [14:20:47.225]         {
  [14:20:47.225]             NULL
  [14:20:47.225]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.225]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.225]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.225]                 label = NULL, ...) 
  [14:20:47.225]             {
  [14:20:47.225]                 if (substitute) 
  [14:20:47.225]                   expr <- substitute(expr)
  [14:20:47.225]                 local <- as.logical(local)
  [14:20:47.225]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.225]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.225]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.225]                   label = label, ...)
  [14:20:47.225]                 if (!future$lazy) 
  [14:20:47.225]                   future <- run(future)
  [14:20:47.225]                 invisible(future)
  [14:20:47.225]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.225]         }
  [14:20:47.225]         base::options(...future.oldOptions)
  [14:20:47.225]     })
  [14:20:47.225]     Sys.time
  [14:20:47.225]     if (base::is.na(TRUE)) {
  [14:20:47.225]     }
  [14:20:47.225]     else {
  [14:20:47.225]         base::sink(type = "output", split = FALSE)
  [14:20:47.225]         if (TRUE) {
  [14:20:47.225]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.225]         }
  [14:20:47.225]         else {
  [14:20:47.225]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.225]         }
  [14:20:47.225]         base::close(...future.stdout)
  [14:20:47.225]         ...future.stdout <- NULL
  [14:20:47.225]     }
  [14:20:47.225]     ...future.result$conditions <- ...future.conditions
  [14:20:47.225]     ...future.result
  [14:20:47.225] }
  [14:20:47.231] plan(): Setting new future strategy stack:
  [14:20:47.232] List of future strategies:
  [14:20:47.232] 1. sequential:
  [14:20:47.232]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.232]    - tweaked: FALSE
  [14:20:47.232]    - call: NULL
  [14:20:47.233] plan(): nbrOfWorkers() = 1
  [14:20:47.234] plan(): Setting new future strategy stack:
  [14:20:47.234] List of future strategies:
  [14:20:47.234] 1. sequential:
  [14:20:47.234]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.234]    - tweaked: FALSE
  [14:20:47.234]    - call: plan(strategy)
  [14:20:47.235] plan(): nbrOfWorkers() = 1
  [14:20:47.236] SequentialFuture started (and completed)
  [14:20:47.237] getGlobalsAndPackages() ...
  [14:20:47.237] Searching for globals...
  [14:20:47.238] 
  [14:20:47.238] Searching for globals ... DONE
  [14:20:47.238] - globals: [0] <none>
  [14:20:47.239] getGlobalsAndPackages() ... DONE
  [14:20:47.241] Packages needed by the future expression (n = 0): <none>
  [14:20:47.241] Packages needed by future strategies (n = 0): <none>
  [14:20:47.247] {
  [14:20:47.247]     {
  [14:20:47.247]         ...future.startTime <- base::Sys.time()
  [14:20:47.247]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.247]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.247]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.247]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.247]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.247]         {
  [14:20:47.247]             {
  [14:20:47.247]                 has_future <- base::requireNamespace("future", 
  [14:20:47.247]                   quietly = TRUE)
  [14:20:47.247]                 version <- if (has_future) 
  [14:20:47.247]                   utils::packageVersion("future")
  [14:20:47.247]                 else NULL
  [14:20:47.247]                 if (!has_future || version < "1.8.0") {
  [14:20:47.247]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.247]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.247]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.247]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.247]                       "release", "version")], collapse = " "), 
  [14:20:47.247]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.247]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.247]                     info)
  [14:20:47.247]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.247]                   if (!has_future) {
  [14:20:47.247]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.247]                       info)
  [14:20:47.247]                   }
  [14:20:47.247]                   else {
  [14:20:47.247]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.247]                       info, version)
  [14:20:47.247]                   }
  [14:20:47.247]                   base::stop(msg)
  [14:20:47.247]                 }
  [14:20:47.247]             }
  [14:20:47.247]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.247]         }
  [14:20:47.247]     }
  [14:20:47.247]     if (base::is.na(TRUE)) {
  [14:20:47.247]     }
  [14:20:47.247]     else {
  [14:20:47.247]         if (TRUE) {
  [14:20:47.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.247]                 open = "w")
  [14:20:47.247]         }
  [14:20:47.247]         else {
  [14:20:47.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.247]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.247]         }
  [14:20:47.247]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.247]             base::sink(type = "output", split = FALSE)
  [14:20:47.247]             base::close(...future.stdout)
  [14:20:47.247]         }, add = TRUE)
  [14:20:47.247]     }
  [14:20:47.247]     ...future.frame <- base::sys.nframe()
  [14:20:47.247]     ...future.conditions <- base::list()
  [14:20:47.247]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.247]     ...future.result <- base::tryCatch({
  [14:20:47.247]         base::withCallingHandlers({
  [14:20:47.247]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:47.247]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.247]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.247]                 version = "1.8")
  [14:20:47.247]         }, condition = base::local({
  [14:20:47.247]             c <- base::c
  [14:20:47.247]             inherits <- base::inherits
  [14:20:47.247]             invokeRestart <- base::invokeRestart
  [14:20:47.247]             length <- base::length
  [14:20:47.247]             list <- base::list
  [14:20:47.247]             seq.int <- base::seq.int
  [14:20:47.247]             signalCondition <- base::signalCondition
  [14:20:47.247]             sys.calls <- base::sys.calls
  [14:20:47.247]             Sys.time <- base::Sys.time
  [14:20:47.247]             `[[` <- base::`[[`
  [14:20:47.247]             `+` <- base::`+`
  [14:20:47.247]             `<<-` <- base::`<<-`
  [14:20:47.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.247]                   3L)]
  [14:20:47.247]             }
  [14:20:47.247]             function(cond) {
  [14:20:47.247]                 if (inherits(cond, "error")) {
  [14:20:47.247]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.247]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.247]                   signalCondition(cond)
  [14:20:47.247]                 }
  [14:20:47.247]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.247]                 ))) {
  [14:20:47.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.247]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.247]                   if (!signal) {
  [14:20:47.247]                     muffleCondition <- function (cond) 
  [14:20:47.247]                     {
  [14:20:47.247]                       inherits <- base::inherits
  [14:20:47.247]                       invokeRestart <- base::invokeRestart
  [14:20:47.247]                       muffled <- FALSE
  [14:20:47.247]                       if (inherits(cond, "message")) {
  [14:20:47.247]                         invokeRestart("muffleMessage")
  [14:20:47.247]                         muffled <- TRUE
  [14:20:47.247]                       }
  [14:20:47.247]                       else if (inherits(cond, "warning")) {
  [14:20:47.247]                         invokeRestart("muffleWarning")
  [14:20:47.247]                         muffled <- TRUE
  [14:20:47.247]                       }
  [14:20:47.247]                       else if (inherits(cond, "condition")) {
  [14:20:47.247]                         computeRestarts <- base::computeRestarts
  [14:20:47.247]                         grepl <- base::grepl
  [14:20:47.247]                         is.null <- base::is.null
  [14:20:47.247]                         restarts <- computeRestarts(cond)
  [14:20:47.247]                         for (restart in restarts) {
  [14:20:47.247]                           name <- restart$name
  [14:20:47.247]                           if (is.null(name)) 
  [14:20:47.247]                             next
  [14:20:47.247]                           if (!grepl("^muffle", name)) 
  [14:20:47.247]                             next
  [14:20:47.247]                           invokeRestart(restart)
  [14:20:47.247]                           muffled <- TRUE
  [14:20:47.247]                           break
  [14:20:47.247]                         }
  [14:20:47.247]                       }
  [14:20:47.247]                       invisible(muffled)
  [14:20:47.247]                     }
  [14:20:47.247]                     muffleCondition(cond)
  [14:20:47.247]                   }
  [14:20:47.247]                 }
  [14:20:47.247]             }
  [14:20:47.247]         }))
  [14:20:47.247]     }, error = function(ex) {
  [14:20:47.247]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.247]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.247]     }, finally = {
  [14:20:47.247]         {
  [14:20:47.247]             NULL
  [14:20:47.247]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.247]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.247]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.247]                 label = NULL, ...) 
  [14:20:47.247]             {
  [14:20:47.247]                 if (substitute) 
  [14:20:47.247]                   expr <- substitute(expr)
  [14:20:47.247]                 local <- as.logical(local)
  [14:20:47.247]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.247]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.247]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.247]                   label = label, ...)
  [14:20:47.247]                 if (!future$lazy) 
  [14:20:47.247]                   future <- run(future)
  [14:20:47.247]                 invisible(future)
  [14:20:47.247]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.247]         }
  [14:20:47.247]         base::options(...future.oldOptions)
  [14:20:47.247]     })
  [14:20:47.247]     Sys.time
  [14:20:47.247]     if (base::is.na(TRUE)) {
  [14:20:47.247]     }
  [14:20:47.247]     else {
  [14:20:47.247]         base::sink(type = "output", split = FALSE)
  [14:20:47.247]         if (TRUE) {
  [14:20:47.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.247]         }
  [14:20:47.247]         else {
  [14:20:47.247]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.247]         }
  [14:20:47.247]         base::close(...future.stdout)
  [14:20:47.247]         ...future.stdout <- NULL
  [14:20:47.247]     }
  [14:20:47.247]     ...future.result$conditions <- ...future.conditions
  [14:20:47.247]     ...future.result
  [14:20:47.247] }
  [14:20:47.253] plan(): Setting new future strategy stack:
  [14:20:47.253] List of future strategies:
  [14:20:47.253] 1. sequential:
  [14:20:47.253]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.253]    - tweaked: FALSE
  [14:20:47.253]    - call: NULL
  [14:20:47.254] plan(): nbrOfWorkers() = 1
  [14:20:47.260] plan(): Setting new future strategy stack:
  [14:20:47.260] List of future strategies:
  [14:20:47.260] 1. sequential:
  [14:20:47.260]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.260]    - tweaked: FALSE
  [14:20:47.260]    - call: plan(strategy)
  [14:20:47.261] plan(): nbrOfWorkers() = 1
  [14:20:47.262] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa391f10> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa69a650> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa391f10> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa69a650> 
   $  : 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" "" ...
  [14:20:47.282] resolve() on list ...
  [14:20:47.283]  recursive: 0
  [14:20:47.283]  length: 6
  [14:20:47.283]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:47.284] signalConditionsASAP(numeric, pos=1) ...
  [14:20:47.284] - nx: 6
  [14:20:47.284] - relay: TRUE
  [14:20:47.285] - stdout: TRUE
  [14:20:47.285] - signal: TRUE
  [14:20:47.285] - resignal: FALSE
  [14:20:47.285] - force: TRUE
  [14:20:47.286] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.286] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.286]  - until=2
  [14:20:47.287]  - relaying element #2
  [14:20:47.287] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.287] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.288] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:47.288]  length: 5 (resolved future 1)
  [14:20:47.288] Future #2
  [14:20:47.289] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:47.289] - nx: 6
  [14:20:47.289] - relay: TRUE
  [14:20:47.289] - stdout: TRUE
  [14:20:47.290] - signal: TRUE
  [14:20:47.290] - resignal: FALSE
  [14:20:47.290] - force: TRUE
  [14:20:47.290] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.291] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.291]  - until=2
  [14:20:47.291]  - relaying element #2
  [14:20:47.292] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.292] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.292] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:47.293]  length: 4 (resolved future 2)
  [14:20:47.293] Future #3
  [14:20:47.293] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:47.294] - nx: 6
  [14:20:47.294] - relay: TRUE
  [14:20:47.294] - stdout: TRUE
  [14:20:47.295] - signal: TRUE
  [14:20:47.295] - resignal: FALSE
  [14:20:47.295] - force: TRUE
  [14:20:47.295] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.296] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.296]  - until=3
  [14:20:47.296]  - relaying element #3
  [14:20:47.297] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.297] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.298] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:47.298]  length: 3 (resolved future 3)
  [14:20:47.298] signalConditionsASAP(NULL, pos=4) ...
  [14:20:47.299] - nx: 6
  [14:20:47.299] - relay: TRUE
  [14:20:47.299] - stdout: TRUE
  [14:20:47.299] - signal: TRUE
  [14:20:47.300] - resignal: FALSE
  [14:20:47.300] - force: TRUE
  [14:20:47.300] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.301] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.301]  - until=5
  [14:20:47.301]  - relaying element #5
  [14:20:47.302] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.302] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.302] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:47.302]  length: 2 (resolved future 4)
  [14:20:47.303] signalConditionsASAP(NULL, pos=5) ...
  [14:20:47.303] - nx: 6
  [14:20:47.303] - relay: TRUE
  [14:20:47.304] - stdout: TRUE
  [14:20:47.304] - signal: TRUE
  [14:20:47.304] - resignal: FALSE
  [14:20:47.305] - force: TRUE
  [14:20:47.305] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.305] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.305]  - until=6
  [14:20:47.306]  - relaying element #6
  [14:20:47.306] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.306] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.307] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:47.307]  length: 1 (resolved future 5)
  [14:20:47.307] signalConditionsASAP(numeric, pos=6) ...
  [14:20:47.308] - nx: 6
  [14:20:47.308] - relay: TRUE
  [14:20:47.308] - stdout: TRUE
  [14:20:47.309] - signal: TRUE
  [14:20:47.309] - resignal: FALSE
  [14:20:47.309] - force: TRUE
  [14:20:47.309] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.310] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.310]  - until=6
  [14:20:47.310] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.311] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.311] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:47.311]  length: 0 (resolved future 6)
  [14:20:47.312] Relaying remaining futures
  [14:20:47.312] signalConditionsASAP(NULL, pos=0) ...
  [14:20:47.312] - nx: 6
  [14:20:47.312] - relay: TRUE
  [14:20:47.313] - stdout: TRUE
  [14:20:47.313] - signal: TRUE
  [14:20:47.313] - resignal: FALSE
  [14:20:47.314] - force: TRUE
  [14:20:47.314] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.314] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:47.315] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.315] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.315] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:47.316] 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)
  [14:20:47.325] getGlobalsAndPackages() ...
  [14:20:47.326] Searching for globals...
  [14:20:47.327] 
  [14:20:47.327] Searching for globals ... DONE
  [14:20:47.327] - globals: [0] <none>
  [14:20:47.328] getGlobalsAndPackages() ... DONE
  [14:20:47.330] Packages needed by the future expression (n = 0): <none>
  [14:20:47.330] Packages needed by future strategies (n = 0): <none>
  [14:20:47.340] {
  [14:20:47.340]     {
  [14:20:47.340]         ...future.startTime <- base::Sys.time()
  [14:20:47.340]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.340]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.340]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.340]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.340]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.340]         {
  [14:20:47.340]             {
  [14:20:47.340]                 has_future <- base::requireNamespace("future", 
  [14:20:47.340]                   quietly = TRUE)
  [14:20:47.340]                 version <- if (has_future) 
  [14:20:47.340]                   utils::packageVersion("future")
  [14:20:47.340]                 else NULL
  [14:20:47.340]                 if (!has_future || version < "1.8.0") {
  [14:20:47.340]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.340]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.340]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.340]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.340]                       "release", "version")], collapse = " "), 
  [14:20:47.340]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.340]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.340]                     info)
  [14:20:47.340]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.340]                   if (!has_future) {
  [14:20:47.340]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.340]                       info)
  [14:20:47.340]                   }
  [14:20:47.340]                   else {
  [14:20:47.340]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.340]                       info, version)
  [14:20:47.340]                   }
  [14:20:47.340]                   base::stop(msg)
  [14:20:47.340]                 }
  [14:20:47.340]             }
  [14:20:47.340]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.340]         }
  [14:20:47.340]     }
  [14:20:47.340]     if (base::is.na(TRUE)) {
  [14:20:47.340]     }
  [14:20:47.340]     else {
  [14:20:47.340]         if (TRUE) {
  [14:20:47.340]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.340]                 open = "w")
  [14:20:47.340]         }
  [14:20:47.340]         else {
  [14:20:47.340]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.340]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.340]         }
  [14:20:47.340]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.340]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.340]             base::sink(type = "output", split = FALSE)
  [14:20:47.340]             base::close(...future.stdout)
  [14:20:47.340]         }, add = TRUE)
  [14:20:47.340]     }
  [14:20:47.340]     ...future.frame <- base::sys.nframe()
  [14:20:47.340]     ...future.conditions <- base::list()
  [14:20:47.340]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.340]     ...future.result <- base::tryCatch({
  [14:20:47.340]         base::withCallingHandlers({
  [14:20:47.340]             ...future.value <- base::withVisible(base::local(2))
  [14:20:47.340]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.340]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.340]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.340]                 version = "1.8")
  [14:20:47.340]         }, condition = base::local({
  [14:20:47.340]             c <- base::c
  [14:20:47.340]             inherits <- base::inherits
  [14:20:47.340]             invokeRestart <- base::invokeRestart
  [14:20:47.340]             length <- base::length
  [14:20:47.340]             list <- base::list
  [14:20:47.340]             seq.int <- base::seq.int
  [14:20:47.340]             signalCondition <- base::signalCondition
  [14:20:47.340]             sys.calls <- base::sys.calls
  [14:20:47.340]             Sys.time <- base::Sys.time
  [14:20:47.340]             `[[` <- base::`[[`
  [14:20:47.340]             `+` <- base::`+`
  [14:20:47.340]             `<<-` <- base::`<<-`
  [14:20:47.340]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.340]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.340]                   3L)]
  [14:20:47.340]             }
  [14:20:47.340]             function(cond) {
  [14:20:47.340]                 if (inherits(cond, "error")) {
  [14:20:47.340]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.340]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.340]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.340]                   signalCondition(cond)
  [14:20:47.340]                 }
  [14:20:47.340]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.340]                 ))) {
  [14:20:47.340]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.340]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.340]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.340]                   if (!signal) {
  [14:20:47.340]                     muffleCondition <- function (cond) 
  [14:20:47.340]                     {
  [14:20:47.340]                       inherits <- base::inherits
  [14:20:47.340]                       invokeRestart <- base::invokeRestart
  [14:20:47.340]                       muffled <- FALSE
  [14:20:47.340]                       if (inherits(cond, "message")) {
  [14:20:47.340]                         invokeRestart("muffleMessage")
  [14:20:47.340]                         muffled <- TRUE
  [14:20:47.340]                       }
  [14:20:47.340]                       else if (inherits(cond, "warning")) {
  [14:20:47.340]                         invokeRestart("muffleWarning")
  [14:20:47.340]                         muffled <- TRUE
  [14:20:47.340]                       }
  [14:20:47.340]                       else if (inherits(cond, "condition")) {
  [14:20:47.340]                         computeRestarts <- base::computeRestarts
  [14:20:47.340]                         grepl <- base::grepl
  [14:20:47.340]                         is.null <- base::is.null
  [14:20:47.340]                         restarts <- computeRestarts(cond)
  [14:20:47.340]                         for (restart in restarts) {
  [14:20:47.340]                           name <- restart$name
  [14:20:47.340]                           if (is.null(name)) 
  [14:20:47.340]                             next
  [14:20:47.340]                           if (!grepl("^muffle", name)) 
  [14:20:47.340]                             next
  [14:20:47.340]                           invokeRestart(restart)
  [14:20:47.340]                           muffled <- TRUE
  [14:20:47.340]                           break
  [14:20:47.340]                         }
  [14:20:47.340]                       }
  [14:20:47.340]                       invisible(muffled)
  [14:20:47.340]                     }
  [14:20:47.340]                     muffleCondition(cond)
  [14:20:47.340]                   }
  [14:20:47.340]                 }
  [14:20:47.340]             }
  [14:20:47.340]         }))
  [14:20:47.340]     }, error = function(ex) {
  [14:20:47.340]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.340]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.340]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.340]     }, finally = {
  [14:20:47.340]         {
  [14:20:47.340]             NULL
  [14:20:47.340]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.340]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.340]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.340]                 label = NULL, ...) 
  [14:20:47.340]             {
  [14:20:47.340]                 if (substitute) 
  [14:20:47.340]                   expr <- substitute(expr)
  [14:20:47.340]                 local <- as.logical(local)
  [14:20:47.340]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.340]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.340]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.340]                   label = label, ...)
  [14:20:47.340]                 if (!future$lazy) 
  [14:20:47.340]                   future <- run(future)
  [14:20:47.340]                 invisible(future)
  [14:20:47.340]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.340]         }
  [14:20:47.340]         base::options(...future.oldOptions)
  [14:20:47.340]     })
  [14:20:47.340]     Sys.time
  [14:20:47.340]     if (base::is.na(TRUE)) {
  [14:20:47.340]     }
  [14:20:47.340]     else {
  [14:20:47.340]         base::sink(type = "output", split = FALSE)
  [14:20:47.340]         if (TRUE) {
  [14:20:47.340]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.340]         }
  [14:20:47.340]         else {
  [14:20:47.340]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.340]         }
  [14:20:47.340]         base::close(...future.stdout)
  [14:20:47.340]         ...future.stdout <- NULL
  [14:20:47.340]     }
  [14:20:47.340]     ...future.result$conditions <- ...future.conditions
  [14:20:47.340]     ...future.result
  [14:20:47.340] }
  [14:20:47.346] plan(): Setting new future strategy stack:
  [14:20:47.346] List of future strategies:
  [14:20:47.346] 1. sequential:
  [14:20:47.346]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.346]    - tweaked: FALSE
  [14:20:47.346]    - call: NULL
  [14:20:47.347] plan(): nbrOfWorkers() = 1
  [14:20:47.348] plan(): Setting new future strategy stack:
  [14:20:47.349] List of future strategies:
  [14:20:47.349] 1. sequential:
  [14:20:47.349]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.349]    - tweaked: FALSE
  [14:20:47.349]    - call: plan(strategy)
  [14:20:47.350] plan(): nbrOfWorkers() = 1
  [14:20:47.350] SequentialFuture started (and completed)
  [14:20:47.351] getGlobalsAndPackages() ...
  [14:20:47.351] Searching for globals...
  [14:20:47.352] 
  [14:20:47.353] Searching for globals ... DONE
  [14:20:47.353] - globals: [0] <none>
  [14:20:47.353] getGlobalsAndPackages() ... DONE
  [14:20:47.355] Packages needed by the future expression (n = 0): <none>
  [14:20:47.356] Packages needed by future strategies (n = 0): <none>
  [14:20:47.362] {
  [14:20:47.362]     {
  [14:20:47.362]         ...future.startTime <- base::Sys.time()
  [14:20:47.362]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.362]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.362]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.362]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.362]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.362]         {
  [14:20:47.362]             {
  [14:20:47.362]                 has_future <- base::requireNamespace("future", 
  [14:20:47.362]                   quietly = TRUE)
  [14:20:47.362]                 version <- if (has_future) 
  [14:20:47.362]                   utils::packageVersion("future")
  [14:20:47.362]                 else NULL
  [14:20:47.362]                 if (!has_future || version < "1.8.0") {
  [14:20:47.362]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.362]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.362]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.362]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.362]                       "release", "version")], collapse = " "), 
  [14:20:47.362]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.362]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.362]                     info)
  [14:20:47.362]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.362]                   if (!has_future) {
  [14:20:47.362]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.362]                       info)
  [14:20:47.362]                   }
  [14:20:47.362]                   else {
  [14:20:47.362]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.362]                       info, version)
  [14:20:47.362]                   }
  [14:20:47.362]                   base::stop(msg)
  [14:20:47.362]                 }
  [14:20:47.362]             }
  [14:20:47.362]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.362]         }
  [14:20:47.362]     }
  [14:20:47.362]     if (base::is.na(TRUE)) {
  [14:20:47.362]     }
  [14:20:47.362]     else {
  [14:20:47.362]         if (TRUE) {
  [14:20:47.362]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.362]                 open = "w")
  [14:20:47.362]         }
  [14:20:47.362]         else {
  [14:20:47.362]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.362]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.362]         }
  [14:20:47.362]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.362]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.362]             base::sink(type = "output", split = FALSE)
  [14:20:47.362]             base::close(...future.stdout)
  [14:20:47.362]         }, add = TRUE)
  [14:20:47.362]     }
  [14:20:47.362]     ...future.frame <- base::sys.nframe()
  [14:20:47.362]     ...future.conditions <- base::list()
  [14:20:47.362]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.362]     ...future.result <- base::tryCatch({
  [14:20:47.362]         base::withCallingHandlers({
  [14:20:47.362]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:47.362]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.362]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.362]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.362]                 version = "1.8")
  [14:20:47.362]         }, condition = base::local({
  [14:20:47.362]             c <- base::c
  [14:20:47.362]             inherits <- base::inherits
  [14:20:47.362]             invokeRestart <- base::invokeRestart
  [14:20:47.362]             length <- base::length
  [14:20:47.362]             list <- base::list
  [14:20:47.362]             seq.int <- base::seq.int
  [14:20:47.362]             signalCondition <- base::signalCondition
  [14:20:47.362]             sys.calls <- base::sys.calls
  [14:20:47.362]             Sys.time <- base::Sys.time
  [14:20:47.362]             `[[` <- base::`[[`
  [14:20:47.362]             `+` <- base::`+`
  [14:20:47.362]             `<<-` <- base::`<<-`
  [14:20:47.362]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.362]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.362]                   3L)]
  [14:20:47.362]             }
  [14:20:47.362]             function(cond) {
  [14:20:47.362]                 if (inherits(cond, "error")) {
  [14:20:47.362]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.362]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.362]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.362]                   signalCondition(cond)
  [14:20:47.362]                 }
  [14:20:47.362]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.362]                 ))) {
  [14:20:47.362]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.362]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.362]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.362]                   if (!signal) {
  [14:20:47.362]                     muffleCondition <- function (cond) 
  [14:20:47.362]                     {
  [14:20:47.362]                       inherits <- base::inherits
  [14:20:47.362]                       invokeRestart <- base::invokeRestart
  [14:20:47.362]                       muffled <- FALSE
  [14:20:47.362]                       if (inherits(cond, "message")) {
  [14:20:47.362]                         invokeRestart("muffleMessage")
  [14:20:47.362]                         muffled <- TRUE
  [14:20:47.362]                       }
  [14:20:47.362]                       else if (inherits(cond, "warning")) {
  [14:20:47.362]                         invokeRestart("muffleWarning")
  [14:20:47.362]                         muffled <- TRUE
  [14:20:47.362]                       }
  [14:20:47.362]                       else if (inherits(cond, "condition")) {
  [14:20:47.362]                         computeRestarts <- base::computeRestarts
  [14:20:47.362]                         grepl <- base::grepl
  [14:20:47.362]                         is.null <- base::is.null
  [14:20:47.362]                         restarts <- computeRestarts(cond)
  [14:20:47.362]                         for (restart in restarts) {
  [14:20:47.362]                           name <- restart$name
  [14:20:47.362]                           if (is.null(name)) 
  [14:20:47.362]                             next
  [14:20:47.362]                           if (!grepl("^muffle", name)) 
  [14:20:47.362]                             next
  [14:20:47.362]                           invokeRestart(restart)
  [14:20:47.362]                           muffled <- TRUE
  [14:20:47.362]                           break
  [14:20:47.362]                         }
  [14:20:47.362]                       }
  [14:20:47.362]                       invisible(muffled)
  [14:20:47.362]                     }
  [14:20:47.362]                     muffleCondition(cond)
  [14:20:47.362]                   }
  [14:20:47.362]                 }
  [14:20:47.362]             }
  [14:20:47.362]         }))
  [14:20:47.362]     }, error = function(ex) {
  [14:20:47.362]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.362]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.362]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.362]     }, finally = {
  [14:20:47.362]         {
  [14:20:47.362]             NULL
  [14:20:47.362]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.362]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.362]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.362]                 label = NULL, ...) 
  [14:20:47.362]             {
  [14:20:47.362]                 if (substitute) 
  [14:20:47.362]                   expr <- substitute(expr)
  [14:20:47.362]                 local <- as.logical(local)
  [14:20:47.362]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.362]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.362]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.362]                   label = label, ...)
  [14:20:47.362]                 if (!future$lazy) 
  [14:20:47.362]                   future <- run(future)
  [14:20:47.362]                 invisible(future)
  [14:20:47.362]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.362]         }
  [14:20:47.362]         base::options(...future.oldOptions)
  [14:20:47.362]     })
  [14:20:47.362]     Sys.time
  [14:20:47.362]     if (base::is.na(TRUE)) {
  [14:20:47.362]     }
  [14:20:47.362]     else {
  [14:20:47.362]         base::sink(type = "output", split = FALSE)
  [14:20:47.362]         if (TRUE) {
  [14:20:47.362]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.362]         }
  [14:20:47.362]         else {
  [14:20:47.362]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.362]         }
  [14:20:47.362]         base::close(...future.stdout)
  [14:20:47.362]         ...future.stdout <- NULL
  [14:20:47.362]     }
  [14:20:47.362]     ...future.result$conditions <- ...future.conditions
  [14:20:47.362]     ...future.result
  [14:20:47.362] }
  [14:20:47.368] plan(): Setting new future strategy stack:
  [14:20:47.368] List of future strategies:
  [14:20:47.368] 1. sequential:
  [14:20:47.368]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.368]    - tweaked: FALSE
  [14:20:47.368]    - call: NULL
  [14:20:47.369] plan(): nbrOfWorkers() = 1
  [14:20:47.370] plan(): Setting new future strategy stack:
  [14:20:47.371] List of future strategies:
  [14:20:47.371] 1. sequential:
  [14:20:47.371]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.371]    - tweaked: FALSE
  [14:20:47.371]    - call: plan(strategy)
  [14:20:47.372] plan(): nbrOfWorkers() = 1
  [14:20:47.373] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa864b40> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574f8afd608> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa864b40> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574f8afd608> 
   $  : 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" "" ...
  [14:20:47.392] resolve() on list ...
  [14:20:47.393]  recursive: 0
  [14:20:47.393]  length: 6
  [14:20:47.393]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:47.394] signalConditionsASAP(numeric, pos=1) ...
  [14:20:47.394] - nx: 6
  [14:20:47.394] - relay: TRUE
  [14:20:47.395] - stdout: TRUE
  [14:20:47.395] - signal: TRUE
  [14:20:47.395] - resignal: FALSE
  [14:20:47.395] - force: TRUE
  [14:20:47.396] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.396] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.396]  - until=2
  [14:20:47.397]  - relaying element #2
  [14:20:47.397] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.397] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.398] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:47.398]  length: 5 (resolved future 1)
  [14:20:47.398] Future #2
  [14:20:47.399] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:47.399] - nx: 6
  [14:20:47.399] - relay: TRUE
  [14:20:47.400] - stdout: TRUE
  [14:20:47.400] - signal: TRUE
  [14:20:47.400] - resignal: FALSE
  [14:20:47.401] - force: TRUE
  [14:20:47.401] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.401] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.402]  - until=2
  [14:20:47.402]  - relaying element #2
  [14:20:47.402] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.403] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.403] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:47.404]  length: 4 (resolved future 2)
  [14:20:47.404] Future #3
  [14:20:47.404] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:47.405] - nx: 6
  [14:20:47.405] - relay: TRUE
  [14:20:47.405] - stdout: TRUE
  [14:20:47.406] - signal: TRUE
  [14:20:47.406] - resignal: FALSE
  [14:20:47.406] - force: TRUE
  [14:20:47.406] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.407] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.407]  - until=3
  [14:20:47.407]  - relaying element #3
  [14:20:47.408] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.408] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.409] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:47.409]  length: 3 (resolved future 3)
  [14:20:47.409] signalConditionsASAP(NULL, pos=4) ...
  [14:20:47.410] - nx: 6
  [14:20:47.410] - relay: TRUE
  [14:20:47.410] - stdout: TRUE
  [14:20:47.411] - signal: TRUE
  [14:20:47.411] - resignal: FALSE
  [14:20:47.411] - force: TRUE
  [14:20:47.411] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.412] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.412]  - until=5
  [14:20:47.412]  - relaying element #5
  [14:20:47.413] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.413] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.413] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:47.414]  length: 2 (resolved future 4)
  [14:20:47.414] signalConditionsASAP(NULL, pos=5) ...
  [14:20:47.414] - nx: 6
  [14:20:47.414] - relay: TRUE
  [14:20:47.415] - stdout: TRUE
  [14:20:47.415] - signal: TRUE
  [14:20:47.415] - resignal: FALSE
  [14:20:47.416] - force: TRUE
  [14:20:47.416] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.416] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.417]  - until=6
  [14:20:47.417]  - relaying element #6
  [14:20:47.417] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.417] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.418] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:47.418]  length: 1 (resolved future 5)
  [14:20:47.418] signalConditionsASAP(numeric, pos=6) ...
  [14:20:47.419] - nx: 6
  [14:20:47.419] - relay: TRUE
  [14:20:47.419] - stdout: TRUE
  [14:20:47.420] - signal: TRUE
  [14:20:47.420] - resignal: FALSE
  [14:20:47.420] - force: TRUE
  [14:20:47.420] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.421] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.421]  - until=6
  [14:20:47.421] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.422] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.422] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:47.422]  length: 0 (resolved future 6)
  [14:20:47.423] Relaying remaining futures
  [14:20:47.423] signalConditionsASAP(NULL, pos=0) ...
  [14:20:47.423] - nx: 6
  [14:20:47.424] - relay: TRUE
  [14:20:47.428] - stdout: TRUE
  [14:20:47.428] - signal: TRUE
  [14:20:47.429] - resignal: FALSE
  [14:20:47.429] - force: TRUE
  [14:20:47.429] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.429] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:47.430] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.430] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.431] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:47.431] 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)
  [14:20:47.441] getGlobalsAndPackages() ...
  [14:20:47.441] Searching for globals...
  [14:20:47.442] 
  [14:20:47.443] Searching for globals ... DONE
  [14:20:47.443] - globals: [0] <none>
  [14:20:47.443] getGlobalsAndPackages() ... DONE
  [14:20:47.445] Packages needed by the future expression (n = 0): <none>
  [14:20:47.446] Packages needed by future strategies (n = 0): <none>
  [14:20:47.451] {
  [14:20:47.451]     {
  [14:20:47.451]         ...future.startTime <- base::Sys.time()
  [14:20:47.451]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.451]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.451]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.451]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.451]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.451]         {
  [14:20:47.451]             {
  [14:20:47.451]                 has_future <- base::requireNamespace("future", 
  [14:20:47.451]                   quietly = TRUE)
  [14:20:47.451]                 version <- if (has_future) 
  [14:20:47.451]                   utils::packageVersion("future")
  [14:20:47.451]                 else NULL
  [14:20:47.451]                 if (!has_future || version < "1.8.0") {
  [14:20:47.451]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.451]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.451]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.451]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.451]                       "release", "version")], collapse = " "), 
  [14:20:47.451]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.451]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.451]                     info)
  [14:20:47.451]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.451]                   if (!has_future) {
  [14:20:47.451]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.451]                       info)
  [14:20:47.451]                   }
  [14:20:47.451]                   else {
  [14:20:47.451]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.451]                       info, version)
  [14:20:47.451]                   }
  [14:20:47.451]                   base::stop(msg)
  [14:20:47.451]                 }
  [14:20:47.451]             }
  [14:20:47.451]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.451]         }
  [14:20:47.451]     }
  [14:20:47.451]     if (base::is.na(TRUE)) {
  [14:20:47.451]     }
  [14:20:47.451]     else {
  [14:20:47.451]         if (TRUE) {
  [14:20:47.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.451]                 open = "w")
  [14:20:47.451]         }
  [14:20:47.451]         else {
  [14:20:47.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.451]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.451]         }
  [14:20:47.451]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.451]             base::sink(type = "output", split = FALSE)
  [14:20:47.451]             base::close(...future.stdout)
  [14:20:47.451]         }, add = TRUE)
  [14:20:47.451]     }
  [14:20:47.451]     ...future.frame <- base::sys.nframe()
  [14:20:47.451]     ...future.conditions <- base::list()
  [14:20:47.451]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.451]     ...future.result <- base::tryCatch({
  [14:20:47.451]         base::withCallingHandlers({
  [14:20:47.451]             ...future.value <- base::withVisible(base::local(2))
  [14:20:47.451]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.451]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.451]                 version = "1.8")
  [14:20:47.451]         }, condition = base::local({
  [14:20:47.451]             c <- base::c
  [14:20:47.451]             inherits <- base::inherits
  [14:20:47.451]             invokeRestart <- base::invokeRestart
  [14:20:47.451]             length <- base::length
  [14:20:47.451]             list <- base::list
  [14:20:47.451]             seq.int <- base::seq.int
  [14:20:47.451]             signalCondition <- base::signalCondition
  [14:20:47.451]             sys.calls <- base::sys.calls
  [14:20:47.451]             Sys.time <- base::Sys.time
  [14:20:47.451]             `[[` <- base::`[[`
  [14:20:47.451]             `+` <- base::`+`
  [14:20:47.451]             `<<-` <- base::`<<-`
  [14:20:47.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.451]                   3L)]
  [14:20:47.451]             }
  [14:20:47.451]             function(cond) {
  [14:20:47.451]                 if (inherits(cond, "error")) {
  [14:20:47.451]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.451]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.451]                   signalCondition(cond)
  [14:20:47.451]                 }
  [14:20:47.451]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.451]                 ))) {
  [14:20:47.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.451]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.451]                   if (!signal) {
  [14:20:47.451]                     muffleCondition <- function (cond) 
  [14:20:47.451]                     {
  [14:20:47.451]                       inherits <- base::inherits
  [14:20:47.451]                       invokeRestart <- base::invokeRestart
  [14:20:47.451]                       muffled <- FALSE
  [14:20:47.451]                       if (inherits(cond, "message")) {
  [14:20:47.451]                         invokeRestart("muffleMessage")
  [14:20:47.451]                         muffled <- TRUE
  [14:20:47.451]                       }
  [14:20:47.451]                       else if (inherits(cond, "warning")) {
  [14:20:47.451]                         invokeRestart("muffleWarning")
  [14:20:47.451]                         muffled <- TRUE
  [14:20:47.451]                       }
  [14:20:47.451]                       else if (inherits(cond, "condition")) {
  [14:20:47.451]                         computeRestarts <- base::computeRestarts
  [14:20:47.451]                         grepl <- base::grepl
  [14:20:47.451]                         is.null <- base::is.null
  [14:20:47.451]                         restarts <- computeRestarts(cond)
  [14:20:47.451]                         for (restart in restarts) {
  [14:20:47.451]                           name <- restart$name
  [14:20:47.451]                           if (is.null(name)) 
  [14:20:47.451]                             next
  [14:20:47.451]                           if (!grepl("^muffle", name)) 
  [14:20:47.451]                             next
  [14:20:47.451]                           invokeRestart(restart)
  [14:20:47.451]                           muffled <- TRUE
  [14:20:47.451]                           break
  [14:20:47.451]                         }
  [14:20:47.451]                       }
  [14:20:47.451]                       invisible(muffled)
  [14:20:47.451]                     }
  [14:20:47.451]                     muffleCondition(cond)
  [14:20:47.451]                   }
  [14:20:47.451]                 }
  [14:20:47.451]             }
  [14:20:47.451]         }))
  [14:20:47.451]     }, error = function(ex) {
  [14:20:47.451]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.451]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.451]     }, finally = {
  [14:20:47.451]         {
  [14:20:47.451]             NULL
  [14:20:47.451]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.451]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.451]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.451]                 label = NULL, ...) 
  [14:20:47.451]             {
  [14:20:47.451]                 if (substitute) 
  [14:20:47.451]                   expr <- substitute(expr)
  [14:20:47.451]                 local <- as.logical(local)
  [14:20:47.451]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.451]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.451]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.451]                   label = label, ...)
  [14:20:47.451]                 if (!future$lazy) 
  [14:20:47.451]                   future <- run(future)
  [14:20:47.451]                 invisible(future)
  [14:20:47.451]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.451]         }
  [14:20:47.451]         base::options(...future.oldOptions)
  [14:20:47.451]     })
  [14:20:47.451]     Sys.time
  [14:20:47.451]     if (base::is.na(TRUE)) {
  [14:20:47.451]     }
  [14:20:47.451]     else {
  [14:20:47.451]         base::sink(type = "output", split = FALSE)
  [14:20:47.451]         if (TRUE) {
  [14:20:47.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.451]         }
  [14:20:47.451]         else {
  [14:20:47.451]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.451]         }
  [14:20:47.451]         base::close(...future.stdout)
  [14:20:47.451]         ...future.stdout <- NULL
  [14:20:47.451]     }
  [14:20:47.451]     ...future.result$conditions <- ...future.conditions
  [14:20:47.451]     ...future.result
  [14:20:47.451] }
  [14:20:47.458] plan(): Setting new future strategy stack:
  [14:20:47.458] List of future strategies:
  [14:20:47.458] 1. sequential:
  [14:20:47.458]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.458]    - tweaked: FALSE
  [14:20:47.458]    - call: NULL
  [14:20:47.459] plan(): nbrOfWorkers() = 1
  [14:20:47.461] plan(): Setting new future strategy stack:
  [14:20:47.461] List of future strategies:
  [14:20:47.461] 1. sequential:
  [14:20:47.461]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.461]    - tweaked: FALSE
  [14:20:47.461]    - call: plan(strategy)
  [14:20:47.462] plan(): nbrOfWorkers() = 1
  [14:20:47.463] SequentialFuture started (and completed)
  [14:20:47.463] getGlobalsAndPackages() ...
  [14:20:47.463] Searching for globals...
  [14:20:47.464] 
  [14:20:47.465] Searching for globals ... DONE
  [14:20:47.465] - globals: [0] <none>
  [14:20:47.465] getGlobalsAndPackages() ... DONE
  [14:20:47.467] Packages needed by the future expression (n = 0): <none>
  [14:20:47.468] Packages needed by future strategies (n = 0): <none>
  [14:20:47.473] {
  [14:20:47.473]     {
  [14:20:47.473]         ...future.startTime <- base::Sys.time()
  [14:20:47.473]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.473]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.473]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.473]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.473]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.473]         {
  [14:20:47.473]             {
  [14:20:47.473]                 has_future <- base::requireNamespace("future", 
  [14:20:47.473]                   quietly = TRUE)
  [14:20:47.473]                 version <- if (has_future) 
  [14:20:47.473]                   utils::packageVersion("future")
  [14:20:47.473]                 else NULL
  [14:20:47.473]                 if (!has_future || version < "1.8.0") {
  [14:20:47.473]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.473]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.473]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.473]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.473]                       "release", "version")], collapse = " "), 
  [14:20:47.473]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.473]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.473]                     info)
  [14:20:47.473]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.473]                   if (!has_future) {
  [14:20:47.473]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.473]                       info)
  [14:20:47.473]                   }
  [14:20:47.473]                   else {
  [14:20:47.473]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.473]                       info, version)
  [14:20:47.473]                   }
  [14:20:47.473]                   base::stop(msg)
  [14:20:47.473]                 }
  [14:20:47.473]             }
  [14:20:47.473]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.473]         }
  [14:20:47.473]     }
  [14:20:47.473]     if (base::is.na(TRUE)) {
  [14:20:47.473]     }
  [14:20:47.473]     else {
  [14:20:47.473]         if (TRUE) {
  [14:20:47.473]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.473]                 open = "w")
  [14:20:47.473]         }
  [14:20:47.473]         else {
  [14:20:47.473]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.473]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.473]         }
  [14:20:47.473]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.473]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.473]             base::sink(type = "output", split = FALSE)
  [14:20:47.473]             base::close(...future.stdout)
  [14:20:47.473]         }, add = TRUE)
  [14:20:47.473]     }
  [14:20:47.473]     ...future.frame <- base::sys.nframe()
  [14:20:47.473]     ...future.conditions <- base::list()
  [14:20:47.473]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.473]     ...future.result <- base::tryCatch({
  [14:20:47.473]         base::withCallingHandlers({
  [14:20:47.473]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:47.473]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.473]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.473]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.473]                 version = "1.8")
  [14:20:47.473]         }, condition = base::local({
  [14:20:47.473]             c <- base::c
  [14:20:47.473]             inherits <- base::inherits
  [14:20:47.473]             invokeRestart <- base::invokeRestart
  [14:20:47.473]             length <- base::length
  [14:20:47.473]             list <- base::list
  [14:20:47.473]             seq.int <- base::seq.int
  [14:20:47.473]             signalCondition <- base::signalCondition
  [14:20:47.473]             sys.calls <- base::sys.calls
  [14:20:47.473]             Sys.time <- base::Sys.time
  [14:20:47.473]             `[[` <- base::`[[`
  [14:20:47.473]             `+` <- base::`+`
  [14:20:47.473]             `<<-` <- base::`<<-`
  [14:20:47.473]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.473]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.473]                   3L)]
  [14:20:47.473]             }
  [14:20:47.473]             function(cond) {
  [14:20:47.473]                 if (inherits(cond, "error")) {
  [14:20:47.473]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.473]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.473]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.473]                   signalCondition(cond)
  [14:20:47.473]                 }
  [14:20:47.473]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.473]                 ))) {
  [14:20:47.473]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.473]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.473]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.473]                   if (!signal) {
  [14:20:47.473]                     muffleCondition <- function (cond) 
  [14:20:47.473]                     {
  [14:20:47.473]                       inherits <- base::inherits
  [14:20:47.473]                       invokeRestart <- base::invokeRestart
  [14:20:47.473]                       muffled <- FALSE
  [14:20:47.473]                       if (inherits(cond, "message")) {
  [14:20:47.473]                         invokeRestart("muffleMessage")
  [14:20:47.473]                         muffled <- TRUE
  [14:20:47.473]                       }
  [14:20:47.473]                       else if (inherits(cond, "warning")) {
  [14:20:47.473]                         invokeRestart("muffleWarning")
  [14:20:47.473]                         muffled <- TRUE
  [14:20:47.473]                       }
  [14:20:47.473]                       else if (inherits(cond, "condition")) {
  [14:20:47.473]                         computeRestarts <- base::computeRestarts
  [14:20:47.473]                         grepl <- base::grepl
  [14:20:47.473]                         is.null <- base::is.null
  [14:20:47.473]                         restarts <- computeRestarts(cond)
  [14:20:47.473]                         for (restart in restarts) {
  [14:20:47.473]                           name <- restart$name
  [14:20:47.473]                           if (is.null(name)) 
  [14:20:47.473]                             next
  [14:20:47.473]                           if (!grepl("^muffle", name)) 
  [14:20:47.473]                             next
  [14:20:47.473]                           invokeRestart(restart)
  [14:20:47.473]                           muffled <- TRUE
  [14:20:47.473]                           break
  [14:20:47.473]                         }
  [14:20:47.473]                       }
  [14:20:47.473]                       invisible(muffled)
  [14:20:47.473]                     }
  [14:20:47.473]                     muffleCondition(cond)
  [14:20:47.473]                   }
  [14:20:47.473]                 }
  [14:20:47.473]             }
  [14:20:47.473]         }))
  [14:20:47.473]     }, error = function(ex) {
  [14:20:47.473]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.473]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.473]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.473]     }, finally = {
  [14:20:47.473]         {
  [14:20:47.473]             NULL
  [14:20:47.473]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.473]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.473]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.473]                 label = NULL, ...) 
  [14:20:47.473]             {
  [14:20:47.473]                 if (substitute) 
  [14:20:47.473]                   expr <- substitute(expr)
  [14:20:47.473]                 local <- as.logical(local)
  [14:20:47.473]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.473]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.473]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.473]                   label = label, ...)
  [14:20:47.473]                 if (!future$lazy) 
  [14:20:47.473]                   future <- run(future)
  [14:20:47.473]                 invisible(future)
  [14:20:47.473]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.473]         }
  [14:20:47.473]         base::options(...future.oldOptions)
  [14:20:47.473]     })
  [14:20:47.473]     Sys.time
  [14:20:47.473]     if (base::is.na(TRUE)) {
  [14:20:47.473]     }
  [14:20:47.473]     else {
  [14:20:47.473]         base::sink(type = "output", split = FALSE)
  [14:20:47.473]         if (TRUE) {
  [14:20:47.473]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.473]         }
  [14:20:47.473]         else {
  [14:20:47.473]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.473]         }
  [14:20:47.473]         base::close(...future.stdout)
  [14:20:47.473]         ...future.stdout <- NULL
  [14:20:47.473]     }
  [14:20:47.473]     ...future.result$conditions <- ...future.conditions
  [14:20:47.473]     ...future.result
  [14:20:47.473] }
  [14:20:47.479] plan(): Setting new future strategy stack:
  [14:20:47.480] List of future strategies:
  [14:20:47.480] 1. sequential:
  [14:20:47.480]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.480]    - tweaked: FALSE
  [14:20:47.480]    - call: NULL
  [14:20:47.481] plan(): nbrOfWorkers() = 1
  [14:20:47.482] plan(): Setting new future strategy stack:
  [14:20:47.482] List of future strategies:
  [14:20:47.482] 1. sequential:
  [14:20:47.482]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.482]    - tweaked: FALSE
  [14:20:47.482]    - call: plan(strategy)
  [14:20:47.483] plan(): nbrOfWorkers() = 1
  [14:20:47.484] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574f8e691d0> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa057378> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574f8e691d0> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa057378> 
   $  : 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" "" ...
  [14:20:47.505] resolve() on list ...
  [14:20:47.505]  recursive: 0
  [14:20:47.505]  length: 6
  [14:20:47.506]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:47.506] signalConditionsASAP(numeric, pos=1) ...
  [14:20:47.506] - nx: 6
  [14:20:47.506] - relay: TRUE
  [14:20:47.507] - stdout: TRUE
  [14:20:47.507] - signal: TRUE
  [14:20:47.507] - resignal: FALSE
  [14:20:47.512] - force: TRUE
  [14:20:47.512] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.513] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.513]  - until=2
  [14:20:47.513]  - relaying element #2
  [14:20:47.514] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.514] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.514] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:47.515]  length: 5 (resolved future 1)
  [14:20:47.515] Future #2
  [14:20:47.515] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:47.516] - nx: 6
  [14:20:47.516] - relay: TRUE
  [14:20:47.516] - stdout: TRUE
  [14:20:47.517] - signal: TRUE
  [14:20:47.517] - resignal: FALSE
  [14:20:47.517] - force: TRUE
  [14:20:47.518] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.518] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.518]  - until=2
  [14:20:47.519]  - relaying element #2
  [14:20:47.519] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.520] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.520] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:47.520]  length: 4 (resolved future 2)
  [14:20:47.521] Future #3
  [14:20:47.521] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:47.522] - nx: 6
  [14:20:47.522] - relay: TRUE
  [14:20:47.522] - stdout: TRUE
  [14:20:47.522] - signal: TRUE
  [14:20:47.523] - resignal: FALSE
  [14:20:47.523] - force: TRUE
  [14:20:47.523] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.524] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.524]  - until=3
  [14:20:47.524]  - relaying element #3
  [14:20:47.525] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.525] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.526] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:47.526]  length: 3 (resolved future 3)
  [14:20:47.526] signalConditionsASAP(NULL, pos=4) ...
  [14:20:47.527] - nx: 6
  [14:20:47.527] - relay: TRUE
  [14:20:47.527] - stdout: TRUE
  [14:20:47.527] - signal: TRUE
  [14:20:47.528] - resignal: FALSE
  [14:20:47.528] - force: TRUE
  [14:20:47.528] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.529] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.529]  - until=5
  [14:20:47.529]  - relaying element #5
  [14:20:47.530] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.530] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.530] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:47.531]  length: 2 (resolved future 4)
  [14:20:47.531] signalConditionsASAP(NULL, pos=5) ...
  [14:20:47.531] - nx: 6
  [14:20:47.532] - relay: TRUE
  [14:20:47.532] - stdout: TRUE
  [14:20:47.532] - signal: TRUE
  [14:20:47.532] - resignal: FALSE
  [14:20:47.533] - force: TRUE
  [14:20:47.533] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.533] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.534]  - until=6
  [14:20:47.534]  - relaying element #6
  [14:20:47.534] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.535] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.535] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:47.535]  length: 1 (resolved future 5)
  [14:20:47.536] signalConditionsASAP(numeric, pos=6) ...
  [14:20:47.536] - nx: 6
  [14:20:47.536] - relay: TRUE
  [14:20:47.537] - stdout: TRUE
  [14:20:47.537] - signal: TRUE
  [14:20:47.537] - resignal: FALSE
  [14:20:47.537] - force: TRUE
  [14:20:47.538] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.538] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.538]  - until=6
  [14:20:47.539] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.539] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.539] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:47.540]  length: 0 (resolved future 6)
  [14:20:47.540] Relaying remaining futures
  [14:20:47.540] signalConditionsASAP(NULL, pos=0) ...
  [14:20:47.541] - nx: 6
  [14:20:47.541] - relay: TRUE
  [14:20:47.541] - stdout: TRUE
  [14:20:47.542] - signal: TRUE
  [14:20:47.542] - resignal: FALSE
  [14:20:47.542] - force: TRUE
  [14:20:47.542] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.543] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:47.543] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.544] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.544] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:47.544] 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)
  [14:20:47.555] getGlobalsAndPackages() ...
  [14:20:47.555] Searching for globals...
  [14:20:47.556] 
  [14:20:47.557] Searching for globals ... DONE
  [14:20:47.557] - globals: [0] <none>
  [14:20:47.557] getGlobalsAndPackages() ... DONE
  [14:20:47.559] Packages needed by the future expression (n = 0): <none>
  [14:20:47.560] Packages needed by future strategies (n = 0): <none>
  [14:20:47.565] {
  [14:20:47.565]     {
  [14:20:47.565]         ...future.startTime <- base::Sys.time()
  [14:20:47.565]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.565]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.565]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.565]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.565]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.565]         {
  [14:20:47.565]             {
  [14:20:47.565]                 has_future <- base::requireNamespace("future", 
  [14:20:47.565]                   quietly = TRUE)
  [14:20:47.565]                 version <- if (has_future) 
  [14:20:47.565]                   utils::packageVersion("future")
  [14:20:47.565]                 else NULL
  [14:20:47.565]                 if (!has_future || version < "1.8.0") {
  [14:20:47.565]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.565]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.565]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.565]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.565]                       "release", "version")], collapse = " "), 
  [14:20:47.565]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.565]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.565]                     info)
  [14:20:47.565]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.565]                   if (!has_future) {
  [14:20:47.565]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.565]                       info)
  [14:20:47.565]                   }
  [14:20:47.565]                   else {
  [14:20:47.565]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.565]                       info, version)
  [14:20:47.565]                   }
  [14:20:47.565]                   base::stop(msg)
  [14:20:47.565]                 }
  [14:20:47.565]             }
  [14:20:47.565]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.565]         }
  [14:20:47.565]     }
  [14:20:47.565]     if (base::is.na(TRUE)) {
  [14:20:47.565]     }
  [14:20:47.565]     else {
  [14:20:47.565]         if (TRUE) {
  [14:20:47.565]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.565]                 open = "w")
  [14:20:47.565]         }
  [14:20:47.565]         else {
  [14:20:47.565]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.565]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.565]         }
  [14:20:47.565]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.565]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.565]             base::sink(type = "output", split = FALSE)
  [14:20:47.565]             base::close(...future.stdout)
  [14:20:47.565]         }, add = TRUE)
  [14:20:47.565]     }
  [14:20:47.565]     ...future.frame <- base::sys.nframe()
  [14:20:47.565]     ...future.conditions <- base::list()
  [14:20:47.565]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.565]     ...future.result <- base::tryCatch({
  [14:20:47.565]         base::withCallingHandlers({
  [14:20:47.565]             ...future.value <- base::withVisible(base::local(2))
  [14:20:47.565]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.565]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.565]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.565]                 version = "1.8")
  [14:20:47.565]         }, condition = base::local({
  [14:20:47.565]             c <- base::c
  [14:20:47.565]             inherits <- base::inherits
  [14:20:47.565]             invokeRestart <- base::invokeRestart
  [14:20:47.565]             length <- base::length
  [14:20:47.565]             list <- base::list
  [14:20:47.565]             seq.int <- base::seq.int
  [14:20:47.565]             signalCondition <- base::signalCondition
  [14:20:47.565]             sys.calls <- base::sys.calls
  [14:20:47.565]             Sys.time <- base::Sys.time
  [14:20:47.565]             `[[` <- base::`[[`
  [14:20:47.565]             `+` <- base::`+`
  [14:20:47.565]             `<<-` <- base::`<<-`
  [14:20:47.565]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.565]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.565]                   3L)]
  [14:20:47.565]             }
  [14:20:47.565]             function(cond) {
  [14:20:47.565]                 if (inherits(cond, "error")) {
  [14:20:47.565]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.565]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.565]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.565]                   signalCondition(cond)
  [14:20:47.565]                 }
  [14:20:47.565]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.565]                 ))) {
  [14:20:47.565]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.565]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.565]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.565]                   if (!signal) {
  [14:20:47.565]                     muffleCondition <- function (cond) 
  [14:20:47.565]                     {
  [14:20:47.565]                       inherits <- base::inherits
  [14:20:47.565]                       invokeRestart <- base::invokeRestart
  [14:20:47.565]                       muffled <- FALSE
  [14:20:47.565]                       if (inherits(cond, "message")) {
  [14:20:47.565]                         invokeRestart("muffleMessage")
  [14:20:47.565]                         muffled <- TRUE
  [14:20:47.565]                       }
  [14:20:47.565]                       else if (inherits(cond, "warning")) {
  [14:20:47.565]                         invokeRestart("muffleWarning")
  [14:20:47.565]                         muffled <- TRUE
  [14:20:47.565]                       }
  [14:20:47.565]                       else if (inherits(cond, "condition")) {
  [14:20:47.565]                         computeRestarts <- base::computeRestarts
  [14:20:47.565]                         grepl <- base::grepl
  [14:20:47.565]                         is.null <- base::is.null
  [14:20:47.565]                         restarts <- computeRestarts(cond)
  [14:20:47.565]                         for (restart in restarts) {
  [14:20:47.565]                           name <- restart$name
  [14:20:47.565]                           if (is.null(name)) 
  [14:20:47.565]                             next
  [14:20:47.565]                           if (!grepl("^muffle", name)) 
  [14:20:47.565]                             next
  [14:20:47.565]                           invokeRestart(restart)
  [14:20:47.565]                           muffled <- TRUE
  [14:20:47.565]                           break
  [14:20:47.565]                         }
  [14:20:47.565]                       }
  [14:20:47.565]                       invisible(muffled)
  [14:20:47.565]                     }
  [14:20:47.565]                     muffleCondition(cond)
  [14:20:47.565]                   }
  [14:20:47.565]                 }
  [14:20:47.565]             }
  [14:20:47.565]         }))
  [14:20:47.565]     }, error = function(ex) {
  [14:20:47.565]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.565]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.565]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.565]     }, finally = {
  [14:20:47.565]         {
  [14:20:47.565]             NULL
  [14:20:47.565]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.565]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.565]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.565]                 label = NULL, ...) 
  [14:20:47.565]             {
  [14:20:47.565]                 if (substitute) 
  [14:20:47.565]                   expr <- substitute(expr)
  [14:20:47.565]                 local <- as.logical(local)
  [14:20:47.565]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.565]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.565]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.565]                   label = label, ...)
  [14:20:47.565]                 if (!future$lazy) 
  [14:20:47.565]                   future <- run(future)
  [14:20:47.565]                 invisible(future)
  [14:20:47.565]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.565]         }
  [14:20:47.565]         base::options(...future.oldOptions)
  [14:20:47.565]     })
  [14:20:47.565]     Sys.time
  [14:20:47.565]     if (base::is.na(TRUE)) {
  [14:20:47.565]     }
  [14:20:47.565]     else {
  [14:20:47.565]         base::sink(type = "output", split = FALSE)
  [14:20:47.565]         if (TRUE) {
  [14:20:47.565]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.565]         }
  [14:20:47.565]         else {
  [14:20:47.565]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.565]         }
  [14:20:47.565]         base::close(...future.stdout)
  [14:20:47.565]         ...future.stdout <- NULL
  [14:20:47.565]     }
  [14:20:47.565]     ...future.result$conditions <- ...future.conditions
  [14:20:47.565]     ...future.result
  [14:20:47.565] }
  [14:20:47.571] plan(): Setting new future strategy stack:
  [14:20:47.572] List of future strategies:
  [14:20:47.572] 1. sequential:
  [14:20:47.572]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.572]    - tweaked: FALSE
  [14:20:47.572]    - call: NULL
  [14:20:47.573] plan(): nbrOfWorkers() = 1
  [14:20:47.574] plan(): Setting new future strategy stack:
  [14:20:47.575] List of future strategies:
  [14:20:47.575] 1. sequential:
  [14:20:47.575]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.575]    - tweaked: FALSE
  [14:20:47.575]    - call: plan(strategy)
  [14:20:47.576] plan(): nbrOfWorkers() = 1
  [14:20:47.577] SequentialFuture started (and completed)
  [14:20:47.577] getGlobalsAndPackages() ...
  [14:20:47.577] Searching for globals...
  [14:20:47.578] 
  [14:20:47.579] Searching for globals ... DONE
  [14:20:47.579] - globals: [0] <none>
  [14:20:47.580] getGlobalsAndPackages() ... DONE
  [14:20:47.582] Packages needed by the future expression (n = 0): <none>
  [14:20:47.582] Packages needed by future strategies (n = 0): <none>
  [14:20:47.588] {
  [14:20:47.588]     {
  [14:20:47.588]         ...future.startTime <- base::Sys.time()
  [14:20:47.588]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:47.588]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:47.588]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:47.588]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:47.588]             future.resolve.recursive = NULL, width = 80L)
  [14:20:47.588]         {
  [14:20:47.588]             {
  [14:20:47.588]                 has_future <- base::requireNamespace("future", 
  [14:20:47.588]                   quietly = TRUE)
  [14:20:47.588]                 version <- if (has_future) 
  [14:20:47.588]                   utils::packageVersion("future")
  [14:20:47.588]                 else NULL
  [14:20:47.588]                 if (!has_future || version < "1.8.0") {
  [14:20:47.588]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:47.588]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:47.588]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:47.588]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:47.588]                       "release", "version")], collapse = " "), 
  [14:20:47.588]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:47.588]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:47.588]                     info)
  [14:20:47.588]                   info <- base::paste(info, collapse = "; ")
  [14:20:47.588]                   if (!has_future) {
  [14:20:47.588]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:47.588]                       info)
  [14:20:47.588]                   }
  [14:20:47.588]                   else {
  [14:20:47.588]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:47.588]                       info, version)
  [14:20:47.588]                   }
  [14:20:47.588]                   base::stop(msg)
  [14:20:47.588]                 }
  [14:20:47.588]             }
  [14:20:47.588]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:47.588]         }
  [14:20:47.588]     }
  [14:20:47.588]     if (base::is.na(TRUE)) {
  [14:20:47.588]     }
  [14:20:47.588]     else {
  [14:20:47.588]         if (TRUE) {
  [14:20:47.588]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:47.588]                 open = "w")
  [14:20:47.588]         }
  [14:20:47.588]         else {
  [14:20:47.588]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:47.588]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:47.588]         }
  [14:20:47.588]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:47.588]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:47.588]             base::sink(type = "output", split = FALSE)
  [14:20:47.588]             base::close(...future.stdout)
  [14:20:47.588]         }, add = TRUE)
  [14:20:47.588]     }
  [14:20:47.588]     ...future.frame <- base::sys.nframe()
  [14:20:47.588]     ...future.conditions <- base::list()
  [14:20:47.588]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:47.588]     ...future.result <- base::tryCatch({
  [14:20:47.588]         base::withCallingHandlers({
  [14:20:47.588]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:47.588]             future::FutureResult(value = ...future.value$value, 
  [14:20:47.588]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.588]                   ...future.rng), started = ...future.startTime, 
  [14:20:47.588]                 version = "1.8")
  [14:20:47.588]         }, condition = base::local({
  [14:20:47.588]             c <- base::c
  [14:20:47.588]             inherits <- base::inherits
  [14:20:47.588]             invokeRestart <- base::invokeRestart
  [14:20:47.588]             length <- base::length
  [14:20:47.588]             list <- base::list
  [14:20:47.588]             seq.int <- base::seq.int
  [14:20:47.588]             signalCondition <- base::signalCondition
  [14:20:47.588]             sys.calls <- base::sys.calls
  [14:20:47.588]             Sys.time <- base::Sys.time
  [14:20:47.588]             `[[` <- base::`[[`
  [14:20:47.588]             `+` <- base::`+`
  [14:20:47.588]             `<<-` <- base::`<<-`
  [14:20:47.588]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:47.588]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:47.588]                   3L)]
  [14:20:47.588]             }
  [14:20:47.588]             function(cond) {
  [14:20:47.588]                 if (inherits(cond, "error")) {
  [14:20:47.588]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.588]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:47.588]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:47.588]                   signalCondition(cond)
  [14:20:47.588]                 }
  [14:20:47.588]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:47.588]                 ))) {
  [14:20:47.588]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:47.588]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:47.588]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:47.588]                   if (!signal) {
  [14:20:47.588]                     muffleCondition <- function (cond) 
  [14:20:47.588]                     {
  [14:20:47.588]                       inherits <- base::inherits
  [14:20:47.588]                       invokeRestart <- base::invokeRestart
  [14:20:47.588]                       muffled <- FALSE
  [14:20:47.588]                       if (inherits(cond, "message")) {
  [14:20:47.588]                         invokeRestart("muffleMessage")
  [14:20:47.588]                         muffled <- TRUE
  [14:20:47.588]                       }
  [14:20:47.588]                       else if (inherits(cond, "warning")) {
  [14:20:47.588]                         invokeRestart("muffleWarning")
  [14:20:47.588]                         muffled <- TRUE
  [14:20:47.588]                       }
  [14:20:47.588]                       else if (inherits(cond, "condition")) {
  [14:20:47.588]                         computeRestarts <- base::computeRestarts
  [14:20:47.588]                         grepl <- base::grepl
  [14:20:47.588]                         is.null <- base::is.null
  [14:20:47.588]                         restarts <- computeRestarts(cond)
  [14:20:47.588]                         for (restart in restarts) {
  [14:20:47.588]                           name <- restart$name
  [14:20:47.588]                           if (is.null(name)) 
  [14:20:47.588]                             next
  [14:20:47.588]                           if (!grepl("^muffle", name)) 
  [14:20:47.588]                             next
  [14:20:47.588]                           invokeRestart(restart)
  [14:20:47.588]                           muffled <- TRUE
  [14:20:47.588]                           break
  [14:20:47.588]                         }
  [14:20:47.588]                       }
  [14:20:47.588]                       invisible(muffled)
  [14:20:47.588]                     }
  [14:20:47.588]                     muffleCondition(cond)
  [14:20:47.588]                   }
  [14:20:47.588]                 }
  [14:20:47.588]             }
  [14:20:47.588]         }))
  [14:20:47.588]     }, error = function(ex) {
  [14:20:47.588]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:47.588]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:47.588]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:47.588]     }, finally = {
  [14:20:47.588]         {
  [14:20:47.588]             NULL
  [14:20:47.588]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:47.588]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:47.588]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:47.588]                 label = NULL, ...) 
  [14:20:47.588]             {
  [14:20:47.588]                 if (substitute) 
  [14:20:47.588]                   expr <- substitute(expr)
  [14:20:47.588]                 local <- as.logical(local)
  [14:20:47.588]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:47.588]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:47.588]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:47.588]                   label = label, ...)
  [14:20:47.588]                 if (!future$lazy) 
  [14:20:47.588]                   future <- run(future)
  [14:20:47.588]                 invisible(future)
  [14:20:47.588]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:47.588]         }
  [14:20:47.588]         base::options(...future.oldOptions)
  [14:20:47.588]     })
  [14:20:47.588]     Sys.time
  [14:20:47.588]     if (base::is.na(TRUE)) {
  [14:20:47.588]     }
  [14:20:47.588]     else {
  [14:20:47.588]         base::sink(type = "output", split = FALSE)
  [14:20:47.588]         if (TRUE) {
  [14:20:47.588]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:47.588]         }
  [14:20:47.588]         else {
  [14:20:47.588]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:47.588]         }
  [14:20:47.588]         base::close(...future.stdout)
  [14:20:47.588]         ...future.stdout <- NULL
  [14:20:47.588]     }
  [14:20:47.588]     ...future.result$conditions <- ...future.conditions
  [14:20:47.588]     ...future.result
  [14:20:47.588] }
  [14:20:47.594] plan(): Setting new future strategy stack:
  [14:20:47.596] List of future strategies:
  [14:20:47.596] 1. sequential:
  [14:20:47.596]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.596]    - tweaked: FALSE
  [14:20:47.596]    - call: NULL
  [14:20:47.597] plan(): nbrOfWorkers() = 1
  [14:20:47.598] plan(): Setting new future strategy stack:
  [14:20:47.598] List of future strategies:
  [14:20:47.598] 1. sequential:
  [14:20:47.598]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:47.598]    - tweaked: FALSE
  [14:20:47.598]    - call: plan(strategy)
  [14:20:47.604] plan(): nbrOfWorkers() = 1
  [14:20:47.604] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa316808> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa634240> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa316808> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x5574fa634240> 
   $  : 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" "" ...
  [14:20:47.627] resolve() on list ...
  [14:20:47.627]  recursive: 0
  [14:20:47.627]  length: 6
  [14:20:47.628]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:47.628] signalConditionsASAP(numeric, pos=1) ...
  [14:20:47.628] - nx: 6
  [14:20:47.629] - relay: TRUE
  [14:20:47.629] - stdout: TRUE
  [14:20:47.629] - signal: TRUE
  [14:20:47.630] - resignal: FALSE
  [14:20:47.630] - force: TRUE
  [14:20:47.630] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.630] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.631]  - until=2
  [14:20:47.631]  - relaying element #2
  [14:20:47.631] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.632] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.632] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:47.632]  length: 5 (resolved future 1)
  [14:20:47.633] Future #2
  [14:20:47.633] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:47.634] - nx: 6
  [14:20:47.634] - relay: TRUE
  [14:20:47.634] - stdout: TRUE
  [14:20:47.634] - signal: TRUE
  [14:20:47.635] - resignal: FALSE
  [14:20:47.635] - force: TRUE
  [14:20:47.635] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.636] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.636]  - until=2
  [14:20:47.636]  - relaying element #2
  [14:20:47.637] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.637] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.638] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:47.638]  length: 4 (resolved future 2)
  [14:20:47.638] Future #3
  [14:20:47.639] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:47.639] - nx: 6
  [14:20:47.639] - relay: TRUE
  [14:20:47.640] - stdout: TRUE
  [14:20:47.640] - signal: TRUE
  [14:20:47.640] - resignal: FALSE
  [14:20:47.641] - force: TRUE
  [14:20:47.641] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.641] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:47.642]  - until=3
  [14:20:47.642]  - relaying element #3
  [14:20:47.643] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.643] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.643] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:47.644]  length: 3 (resolved future 3)
  [14:20:47.644] signalConditionsASAP(NULL, pos=4) ...
  [14:20:47.644] - nx: 6
  [14:20:47.644] - relay: TRUE
  [14:20:47.645] - stdout: TRUE
  [14:20:47.645] - signal: TRUE
  [14:20:47.645] - resignal: FALSE
  [14:20:47.646] - force: TRUE
  [14:20:47.646] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.646] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.647]  - until=5
  [14:20:47.647]  - relaying element #5
  [14:20:47.647] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.648] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.648] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:47.648]  length: 2 (resolved future 4)
  [14:20:47.649] signalConditionsASAP(NULL, pos=5) ...
  [14:20:47.649] - nx: 6
  [14:20:47.649] - relay: TRUE
  [14:20:47.649] - stdout: TRUE
  [14:20:47.650] - signal: TRUE
  [14:20:47.650] - resignal: FALSE
  [14:20:47.650] - force: TRUE
  [14:20:47.651] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:47.651] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.651]  - until=6
  [14:20:47.652]  - relaying element #6
  [14:20:47.652] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.652] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.653] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:47.653]  length: 1 (resolved future 5)
  [14:20:47.653] signalConditionsASAP(numeric, pos=6) ...
  [14:20:47.654] - nx: 6
  [14:20:47.654] - relay: TRUE
  [14:20:47.654] - stdout: TRUE
  [14:20:47.654] - signal: TRUE
  [14:20:47.655] - resignal: FALSE
  [14:20:47.655] - force: TRUE
  [14:20:47.655] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:47.656] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.656]  - until=6
  [14:20:47.656] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.657] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.657] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:47.657]  length: 0 (resolved future 6)
  [14:20:47.658] Relaying remaining futures
  [14:20:47.658] signalConditionsASAP(NULL, pos=0) ...
  [14:20:47.658] - nx: 6
  [14:20:47.658] - relay: TRUE
  [14:20:47.659] - stdout: TRUE
  [14:20:47.659] - signal: TRUE
  [14:20:47.659] - resignal: FALSE
  [14:20:47.660] - force: TRUE
  [14:20:47.660] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.660] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:47.661] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:47.661] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:47.661] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:47.662] 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
  [14:20:47.673] plan(): Setting new future strategy stack:
  [14:20:47.673] List of future strategies:
  [14:20:47.673] 1. cluster:
  [14:20:47.673]    - 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, ...)
  [14:20:47.673]    - tweaked: FALSE
  [14:20:47.673]    - call: plan(strategy)
  [14:20:47.674] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [14:20:47.675] cluster:
  [14:20:47.675] - 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, ...)
  [14:20:47.675] - tweaked: FALSE
  [14:20:47.675] - call: plan(strategy)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 35445
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpjYgzDn/future.parent=29608.73a85e0d8fc1.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpjYgzDn/future.parent=29608.73a85e0d8fc1.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futures.R:gimli:hornik:29608' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpjYgzDn/future.parent=29608.73a85e0d8fc1.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35445 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
  [14:20:55.518] getGlobalsAndPackages() ...
  [14:20:55.518] Not searching for globals
  [14:20:55.519] - globals: [0] <none>
  [14:20:55.519] getGlobalsAndPackages() ... DONE
  [14:20:55.524] Packages needed by the future expression (n = 0): <none>
  [14:20:55.525] Packages needed by future strategies (n = 0): <none>
  [14:20:55.547] {
  [14:20:55.547]     {
  [14:20:55.547]         ...future.startTime <- base::Sys.time()
  [14:20:55.547]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:55.547]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:55.547]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:55.547]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:55.547]             future.resolve.recursive = NULL, width = 80L)
  [14:20:55.547]         {
  [14:20:55.547]             {
  [14:20:55.547]                 has_future <- base::requireNamespace("future", 
  [14:20:55.547]                   quietly = TRUE)
  [14:20:55.547]                 version <- if (has_future) 
  [14:20:55.547]                   utils::packageVersion("future")
  [14:20:55.547]                 else NULL
  [14:20:55.547]                 if (!has_future || version < "1.8.0") {
  [14:20:55.547]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:55.547]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:55.547]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:55.547]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:55.547]                       "release", "version")], collapse = " "), 
  [14:20:55.547]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:55.547]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:55.547]                     info)
  [14:20:55.547]                   info <- base::paste(info, collapse = "; ")
  [14:20:55.547]                   if (!has_future) {
  [14:20:55.547]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:55.547]                       info)
  [14:20:55.547]                   }
  [14:20:55.547]                   else {
  [14:20:55.547]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:55.547]                       info, version)
  [14:20:55.547]                   }
  [14:20:55.547]                   base::stop(msg)
  [14:20:55.547]                 }
  [14:20:55.547]             }
  [14:20:55.547]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:55.547]         }
  [14:20:55.547]     }
  [14:20:55.547]     if (base::is.na(TRUE)) {
  [14:20:55.547]     }
  [14:20:55.547]     else {
  [14:20:55.547]         if (TRUE) {
  [14:20:55.547]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:55.547]                 open = "w")
  [14:20:55.547]         }
  [14:20:55.547]         else {
  [14:20:55.547]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:55.547]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:55.547]         }
  [14:20:55.547]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:55.547]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:55.547]             base::sink(type = "output", split = FALSE)
  [14:20:55.547]             base::close(...future.stdout)
  [14:20:55.547]         }, add = TRUE)
  [14:20:55.547]     }
  [14:20:55.547]     ...future.frame <- base::sys.nframe()
  [14:20:55.547]     ...future.conditions <- base::list()
  [14:20:55.547]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:55.547]     ...future.result <- base::tryCatch({
  [14:20:55.547]         base::withCallingHandlers({
  [14:20:55.547]             ...future.value <- base::withVisible(base::local({
  [14:20:55.547]                 ...future.sendCondition <- local({
  [14:20:55.547]                   sendCondition <- NULL
  [14:20:55.547]                   function(frame = 1L) {
  [14:20:55.547]                     if (is.function(sendCondition)) 
  [14:20:55.547]                       return(sendCondition)
  [14:20:55.547]                     ns <- getNamespace("parallel")
  [14:20:55.547]                     if (exists("sendData", mode = "function", 
  [14:20:55.547]                       envir = ns)) {
  [14:20:55.547]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:55.547]                         envir = ns)
  [14:20:55.547]                       envir <- sys.frame(frame)
  [14:20:55.547]                       master <- NULL
  [14:20:55.547]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:55.547]                         !identical(envir, emptyenv())) {
  [14:20:55.547]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:55.547]                           inherits = FALSE)) {
  [14:20:55.547]                           master <- get("master", mode = "list", 
  [14:20:55.547]                             envir = envir, inherits = FALSE)
  [14:20:55.547]                           if (inherits(master, "SOCKnode")) {
  [14:20:55.547]                             sendCondition <<- function(cond) {
  [14:20:55.547]                               data <- list(type = "VALUE", value = cond, 
  [14:20:55.547]                                 success = TRUE)
  [14:20:55.547]                               parallel_sendData(master, data)
  [14:20:55.547]                             }
  [14:20:55.547]                             return(sendCondition)
  [14:20:55.547]                           }
  [14:20:55.547]                         }
  [14:20:55.547]                         frame <- frame + 1L
  [14:20:55.547]                         envir <- sys.frame(frame)
  [14:20:55.547]                       }
  [14:20:55.547]                     }
  [14:20:55.547]                     sendCondition <<- function(cond) NULL
  [14:20:55.547]                   }
  [14:20:55.547]                 })
  [14:20:55.547]                 withCallingHandlers({
  [14:20:55.547]                   NA
  [14:20:55.547]                 }, immediateCondition = function(cond) {
  [14:20:55.547]                   sendCondition <- ...future.sendCondition()
  [14:20:55.547]                   sendCondition(cond)
  [14:20:55.547]                   muffleCondition <- function (cond) 
  [14:20:55.547]                   {
  [14:20:55.547]                     inherits <- base::inherits
  [14:20:55.547]                     invokeRestart <- base::invokeRestart
  [14:20:55.547]                     muffled <- FALSE
  [14:20:55.547]                     if (inherits(cond, "message")) {
  [14:20:55.547]                       invokeRestart("muffleMessage")
  [14:20:55.547]                       muffled <- TRUE
  [14:20:55.547]                     }
  [14:20:55.547]                     else if (inherits(cond, "warning")) {
  [14:20:55.547]                       invokeRestart("muffleWarning")
  [14:20:55.547]                       muffled <- TRUE
  [14:20:55.547]                     }
  [14:20:55.547]                     else if (inherits(cond, "condition")) {
  [14:20:55.547]                       computeRestarts <- base::computeRestarts
  [14:20:55.547]                       grepl <- base::grepl
  [14:20:55.547]                       is.null <- base::is.null
  [14:20:55.547]                       restarts <- computeRestarts(cond)
  [14:20:55.547]                       for (restart in restarts) {
  [14:20:55.547]                         name <- restart$name
  [14:20:55.547]                         if (is.null(name)) 
  [14:20:55.547]                           next
  [14:20:55.547]                         if (!grepl("^muffle", name)) 
  [14:20:55.547]                           next
  [14:20:55.547]                         invokeRestart(restart)
  [14:20:55.547]                         muffled <- TRUE
  [14:20:55.547]                         break
  [14:20:55.547]                       }
  [14:20:55.547]                     }
  [14:20:55.547]                     invisible(muffled)
  [14:20:55.547]                   }
  [14:20:55.547]                   muffleCondition(cond)
  [14:20:55.547]                 })
  [14:20:55.547]             }))
  [14:20:55.547]             future::FutureResult(value = ...future.value$value, 
  [14:20:55.547]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.547]                   ...future.rng), started = ...future.startTime, 
  [14:20:55.547]                 version = "1.8")
  [14:20:55.547]         }, condition = base::local({
  [14:20:55.547]             c <- base::c
  [14:20:55.547]             inherits <- base::inherits
  [14:20:55.547]             invokeRestart <- base::invokeRestart
  [14:20:55.547]             length <- base::length
  [14:20:55.547]             list <- base::list
  [14:20:55.547]             seq.int <- base::seq.int
  [14:20:55.547]             signalCondition <- base::signalCondition
  [14:20:55.547]             sys.calls <- base::sys.calls
  [14:20:55.547]             Sys.time <- base::Sys.time
  [14:20:55.547]             `[[` <- base::`[[`
  [14:20:55.547]             `+` <- base::`+`
  [14:20:55.547]             `<<-` <- base::`<<-`
  [14:20:55.547]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:55.547]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:55.547]                   3L)]
  [14:20:55.547]             }
  [14:20:55.547]             function(cond) {
  [14:20:55.547]                 if (inherits(cond, "error")) {
  [14:20:55.547]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.547]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:55.547]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:55.547]                   signalCondition(cond)
  [14:20:55.547]                 }
  [14:20:55.547]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:55.547]                 ))) {
  [14:20:55.547]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:55.547]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.547]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:55.547]                   if (!signal) {
  [14:20:55.547]                     muffleCondition <- function (cond) 
  [14:20:55.547]                     {
  [14:20:55.547]                       inherits <- base::inherits
  [14:20:55.547]                       invokeRestart <- base::invokeRestart
  [14:20:55.547]                       muffled <- FALSE
  [14:20:55.547]                       if (inherits(cond, "message")) {
  [14:20:55.547]                         invokeRestart("muffleMessage")
  [14:20:55.547]                         muffled <- TRUE
  [14:20:55.547]                       }
  [14:20:55.547]                       else if (inherits(cond, "warning")) {
  [14:20:55.547]                         invokeRestart("muffleWarning")
  [14:20:55.547]                         muffled <- TRUE
  [14:20:55.547]                       }
  [14:20:55.547]                       else if (inherits(cond, "condition")) {
  [14:20:55.547]                         computeRestarts <- base::computeRestarts
  [14:20:55.547]                         grepl <- base::grepl
  [14:20:55.547]                         is.null <- base::is.null
  [14:20:55.547]                         restarts <- computeRestarts(cond)
  [14:20:55.547]                         for (restart in restarts) {
  [14:20:55.547]                           name <- restart$name
  [14:20:55.547]                           if (is.null(name)) 
  [14:20:55.547]                             next
  [14:20:55.547]                           if (!grepl("^muffle", name)) 
  [14:20:55.547]                             next
  [14:20:55.547]                           invokeRestart(restart)
  [14:20:55.547]                           muffled <- TRUE
  [14:20:55.547]                           break
  [14:20:55.547]                         }
  [14:20:55.547]                       }
  [14:20:55.547]                       invisible(muffled)
  [14:20:55.547]                     }
  [14:20:55.547]                     muffleCondition(cond)
  [14:20:55.547]                   }
  [14:20:55.547]                 }
  [14:20:55.547]             }
  [14:20:55.547]         }))
  [14:20:55.547]     }, error = function(ex) {
  [14:20:55.547]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:55.547]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.547]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:55.547]     }, finally = {
  [14:20:55.547]         {
  [14:20:55.547]             NULL
  [14:20:55.547]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:55.547]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:55.547]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:55.547]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:55.547]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:55.547]                 ...) 
  [14:20:55.547]             {
  [14:20:55.547]                 if (substitute) 
  [14:20:55.547]                   expr <- substitute(expr)
  [14:20:55.547]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:55.547]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:55.547]                   globals = globals, persistent = persistent, 
  [14:20:55.547]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:55.547]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:55.547]                   label = label, ...)
  [14:20:55.547]                 if (!future$lazy) 
  [14:20:55.547]                   future <- run(future)
  [14:20:55.547]                 invisible(future)
  [14:20:55.547]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:55.547]         }
  [14:20:55.547]         base::options(...future.oldOptions)
  [14:20:55.547]     })
  [14:20:55.547]     Sys.time
  [14:20:55.547]     if (base::is.na(TRUE)) {
  [14:20:55.547]     }
  [14:20:55.547]     else {
  [14:20:55.547]         base::sink(type = "output", split = FALSE)
  [14:20:55.547]         if (TRUE) {
  [14:20:55.547]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:55.547]         }
  [14:20:55.547]         else {
  [14:20:55.547]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:55.547]         }
  [14:20:55.547]         base::close(...future.stdout)
  [14:20:55.547]         ...future.stdout <- NULL
  [14:20:55.547]     }
  [14:20:55.547]     ...future.result$conditions <- ...future.conditions
  [14:20:55.547]     ...future.result
  [14:20:55.547] }
  [14:20:55.556] ClusterFuture started
  [14:20:55.556] result() for ClusterFuture ...
  [14:20:55.558] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:55.558] - Validating connection of ClusterFuture
  [14:20:55.781] - received message: FutureResult
  [14:20:55.781] - Received FutureResult
  [14:20:55.788] - Erased future from FutureRegistry
  [14:20:55.789] result() for ClusterFuture ...
  [14:20:55.789] - result already collected: FutureResult
  [14:20:55.790] result() for ClusterFuture ... done
  [14:20:55.790] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:55.791] result() for ClusterFuture ... done
  [14:20:55.791] result() for ClusterFuture ...
  [14:20:55.791] - result already collected: FutureResult
  [14:20:55.792] result() for ClusterFuture ... done
  [14:20:55.792] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [14:20:55.794] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [14:20:55.817] getGlobalsAndPackages() ...
  [14:20:55.817] Searching for globals...
  [14:20:55.818] 
  [14:20:55.818] Searching for globals ... DONE
  [14:20:55.819] - globals: [0] <none>
  [14:20:55.819] getGlobalsAndPackages() ... DONE
  [14:20:55.823] Packages needed by the future expression (n = 0): <none>
  [14:20:55.824] Packages needed by future strategies (n = 0): <none>
  [14:20:55.846] {
  [14:20:55.846]     {
  [14:20:55.846]         ...future.startTime <- base::Sys.time()
  [14:20:55.846]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:55.846]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:55.846]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:55.846]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:55.846]             future.resolve.recursive = NULL, width = 80L)
  [14:20:55.846]         {
  [14:20:55.846]             {
  [14:20:55.846]                 has_future <- base::requireNamespace("future", 
  [14:20:55.846]                   quietly = TRUE)
  [14:20:55.846]                 version <- if (has_future) 
  [14:20:55.846]                   utils::packageVersion("future")
  [14:20:55.846]                 else NULL
  [14:20:55.846]                 if (!has_future || version < "1.8.0") {
  [14:20:55.846]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:55.846]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:55.846]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:55.846]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:55.846]                       "release", "version")], collapse = " "), 
  [14:20:55.846]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:55.846]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:55.846]                     info)
  [14:20:55.846]                   info <- base::paste(info, collapse = "; ")
  [14:20:55.846]                   if (!has_future) {
  [14:20:55.846]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:55.846]                       info)
  [14:20:55.846]                   }
  [14:20:55.846]                   else {
  [14:20:55.846]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:55.846]                       info, version)
  [14:20:55.846]                   }
  [14:20:55.846]                   base::stop(msg)
  [14:20:55.846]                 }
  [14:20:55.846]             }
  [14:20:55.846]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:55.846]         }
  [14:20:55.846]     }
  [14:20:55.846]     if (base::is.na(TRUE)) {
  [14:20:55.846]     }
  [14:20:55.846]     else {
  [14:20:55.846]         if (TRUE) {
  [14:20:55.846]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:55.846]                 open = "w")
  [14:20:55.846]         }
  [14:20:55.846]         else {
  [14:20:55.846]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:55.846]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:55.846]         }
  [14:20:55.846]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:55.846]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:55.846]             base::sink(type = "output", split = FALSE)
  [14:20:55.846]             base::close(...future.stdout)
  [14:20:55.846]         }, add = TRUE)
  [14:20:55.846]     }
  [14:20:55.846]     ...future.frame <- base::sys.nframe()
  [14:20:55.846]     ...future.conditions <- base::list()
  [14:20:55.846]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:55.846]     ...future.result <- base::tryCatch({
  [14:20:55.846]         base::withCallingHandlers({
  [14:20:55.846]             ...future.value <- base::withVisible(base::local({
  [14:20:55.846]                 ...future.sendCondition <- local({
  [14:20:55.846]                   sendCondition <- NULL
  [14:20:55.846]                   function(frame = 1L) {
  [14:20:55.846]                     if (is.function(sendCondition)) 
  [14:20:55.846]                       return(sendCondition)
  [14:20:55.846]                     ns <- getNamespace("parallel")
  [14:20:55.846]                     if (exists("sendData", mode = "function", 
  [14:20:55.846]                       envir = ns)) {
  [14:20:55.846]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:55.846]                         envir = ns)
  [14:20:55.846]                       envir <- sys.frame(frame)
  [14:20:55.846]                       master <- NULL
  [14:20:55.846]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:55.846]                         !identical(envir, emptyenv())) {
  [14:20:55.846]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:55.846]                           inherits = FALSE)) {
  [14:20:55.846]                           master <- get("master", mode = "list", 
  [14:20:55.846]                             envir = envir, inherits = FALSE)
  [14:20:55.846]                           if (inherits(master, "SOCKnode")) {
  [14:20:55.846]                             sendCondition <<- function(cond) {
  [14:20:55.846]                               data <- list(type = "VALUE", value = cond, 
  [14:20:55.846]                                 success = TRUE)
  [14:20:55.846]                               parallel_sendData(master, data)
  [14:20:55.846]                             }
  [14:20:55.846]                             return(sendCondition)
  [14:20:55.846]                           }
  [14:20:55.846]                         }
  [14:20:55.846]                         frame <- frame + 1L
  [14:20:55.846]                         envir <- sys.frame(frame)
  [14:20:55.846]                       }
  [14:20:55.846]                     }
  [14:20:55.846]                     sendCondition <<- function(cond) NULL
  [14:20:55.846]                   }
  [14:20:55.846]                 })
  [14:20:55.846]                 withCallingHandlers({
  [14:20:55.846]                   2
  [14:20:55.846]                 }, immediateCondition = function(cond) {
  [14:20:55.846]                   sendCondition <- ...future.sendCondition()
  [14:20:55.846]                   sendCondition(cond)
  [14:20:55.846]                   muffleCondition <- function (cond) 
  [14:20:55.846]                   {
  [14:20:55.846]                     inherits <- base::inherits
  [14:20:55.846]                     invokeRestart <- base::invokeRestart
  [14:20:55.846]                     muffled <- FALSE
  [14:20:55.846]                     if (inherits(cond, "message")) {
  [14:20:55.846]                       invokeRestart("muffleMessage")
  [14:20:55.846]                       muffled <- TRUE
  [14:20:55.846]                     }
  [14:20:55.846]                     else if (inherits(cond, "warning")) {
  [14:20:55.846]                       invokeRestart("muffleWarning")
  [14:20:55.846]                       muffled <- TRUE
  [14:20:55.846]                     }
  [14:20:55.846]                     else if (inherits(cond, "condition")) {
  [14:20:55.846]                       computeRestarts <- base::computeRestarts
  [14:20:55.846]                       grepl <- base::grepl
  [14:20:55.846]                       is.null <- base::is.null
  [14:20:55.846]                       restarts <- computeRestarts(cond)
  [14:20:55.846]                       for (restart in restarts) {
  [14:20:55.846]                         name <- restart$name
  [14:20:55.846]                         if (is.null(name)) 
  [14:20:55.846]                           next
  [14:20:55.846]                         if (!grepl("^muffle", name)) 
  [14:20:55.846]                           next
  [14:20:55.846]                         invokeRestart(restart)
  [14:20:55.846]                         muffled <- TRUE
  [14:20:55.846]                         break
  [14:20:55.846]                       }
  [14:20:55.846]                     }
  [14:20:55.846]                     invisible(muffled)
  [14:20:55.846]                   }
  [14:20:55.846]                   muffleCondition(cond)
  [14:20:55.846]                 })
  [14:20:55.846]             }))
  [14:20:55.846]             future::FutureResult(value = ...future.value$value, 
  [14:20:55.846]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.846]                   ...future.rng), started = ...future.startTime, 
  [14:20:55.846]                 version = "1.8")
  [14:20:55.846]         }, condition = base::local({
  [14:20:55.846]             c <- base::c
  [14:20:55.846]             inherits <- base::inherits
  [14:20:55.846]             invokeRestart <- base::invokeRestart
  [14:20:55.846]             length <- base::length
  [14:20:55.846]             list <- base::list
  [14:20:55.846]             seq.int <- base::seq.int
  [14:20:55.846]             signalCondition <- base::signalCondition
  [14:20:55.846]             sys.calls <- base::sys.calls
  [14:20:55.846]             Sys.time <- base::Sys.time
  [14:20:55.846]             `[[` <- base::`[[`
  [14:20:55.846]             `+` <- base::`+`
  [14:20:55.846]             `<<-` <- base::`<<-`
  [14:20:55.846]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:55.846]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:55.846]                   3L)]
  [14:20:55.846]             }
  [14:20:55.846]             function(cond) {
  [14:20:55.846]                 if (inherits(cond, "error")) {
  [14:20:55.846]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.846]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:55.846]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:55.846]                   signalCondition(cond)
  [14:20:55.846]                 }
  [14:20:55.846]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:55.846]                 ))) {
  [14:20:55.846]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:55.846]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.846]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:55.846]                   if (!signal) {
  [14:20:55.846]                     muffleCondition <- function (cond) 
  [14:20:55.846]                     {
  [14:20:55.846]                       inherits <- base::inherits
  [14:20:55.846]                       invokeRestart <- base::invokeRestart
  [14:20:55.846]                       muffled <- FALSE
  [14:20:55.846]                       if (inherits(cond, "message")) {
  [14:20:55.846]                         invokeRestart("muffleMessage")
  [14:20:55.846]                         muffled <- TRUE
  [14:20:55.846]                       }
  [14:20:55.846]                       else if (inherits(cond, "warning")) {
  [14:20:55.846]                         invokeRestart("muffleWarning")
  [14:20:55.846]                         muffled <- TRUE
  [14:20:55.846]                       }
  [14:20:55.846]                       else if (inherits(cond, "condition")) {
  [14:20:55.846]                         computeRestarts <- base::computeRestarts
  [14:20:55.846]                         grepl <- base::grepl
  [14:20:55.846]                         is.null <- base::is.null
  [14:20:55.846]                         restarts <- computeRestarts(cond)
  [14:20:55.846]                         for (restart in restarts) {
  [14:20:55.846]                           name <- restart$name
  [14:20:55.846]                           if (is.null(name)) 
  [14:20:55.846]                             next
  [14:20:55.846]                           if (!grepl("^muffle", name)) 
  [14:20:55.846]                             next
  [14:20:55.846]                           invokeRestart(restart)
  [14:20:55.846]                           muffled <- TRUE
  [14:20:55.846]                           break
  [14:20:55.846]                         }
  [14:20:55.846]                       }
  [14:20:55.846]                       invisible(muffled)
  [14:20:55.846]                     }
  [14:20:55.846]                     muffleCondition(cond)
  [14:20:55.846]                   }
  [14:20:55.846]                 }
  [14:20:55.846]             }
  [14:20:55.846]         }))
  [14:20:55.846]     }, error = function(ex) {
  [14:20:55.846]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:55.846]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.846]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:55.846]     }, finally = {
  [14:20:55.846]         {
  [14:20:55.846]             NULL
  [14:20:55.846]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:55.846]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:55.846]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:55.846]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:55.846]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:55.846]                 ...) 
  [14:20:55.846]             {
  [14:20:55.846]                 if (substitute) 
  [14:20:55.846]                   expr <- substitute(expr)
  [14:20:55.846]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:55.846]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:55.846]                   globals = globals, persistent = persistent, 
  [14:20:55.846]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:55.846]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:55.846]                   label = label, ...)
  [14:20:55.846]                 if (!future$lazy) 
  [14:20:55.846]                   future <- run(future)
  [14:20:55.846]                 invisible(future)
  [14:20:55.846]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:55.846]         }
  [14:20:55.846]         base::options(...future.oldOptions)
  [14:20:55.846]     })
  [14:20:55.846]     Sys.time
  [14:20:55.846]     if (base::is.na(TRUE)) {
  [14:20:55.846]     }
  [14:20:55.846]     else {
  [14:20:55.846]         base::sink(type = "output", split = FALSE)
  [14:20:55.846]         if (TRUE) {
  [14:20:55.846]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:55.846]         }
  [14:20:55.846]         else {
  [14:20:55.846]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:55.846]         }
  [14:20:55.846]         base::close(...future.stdout)
  [14:20:55.846]         ...future.stdout <- NULL
  [14:20:55.846]     }
  [14:20:55.846]     ...future.result$conditions <- ...future.conditions
  [14:20:55.846]     ...future.result
  [14:20:55.846] }
  [14:20:55.855] ClusterFuture started
  [14:20:55.875] getGlobalsAndPackages() ...
  [14:20:55.875] Searching for globals...
  [14:20:55.876] 
  [14:20:55.877] Searching for globals ... DONE
  [14:20:55.877] - globals: [0] <none>
  [14:20:55.877] getGlobalsAndPackages() ... DONE
  [14:20:55.882] Packages needed by the future expression (n = 0): <none>
  [14:20:55.882] Packages needed by future strategies (n = 0): <none>
  [14:20:55.921] {
  [14:20:55.921]     {
  [14:20:55.921]         ...future.startTime <- base::Sys.time()
  [14:20:55.921]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:55.921]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:55.921]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:55.921]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:55.921]             future.resolve.recursive = NULL, width = 80L)
  [14:20:55.921]         {
  [14:20:55.921]             {
  [14:20:55.921]                 has_future <- base::requireNamespace("future", 
  [14:20:55.921]                   quietly = TRUE)
  [14:20:55.921]                 version <- if (has_future) 
  [14:20:55.921]                   utils::packageVersion("future")
  [14:20:55.921]                 else NULL
  [14:20:55.921]                 if (!has_future || version < "1.8.0") {
  [14:20:55.921]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:55.921]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:55.921]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:55.921]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:55.921]                       "release", "version")], collapse = " "), 
  [14:20:55.921]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:55.921]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:55.921]                     info)
  [14:20:55.921]                   info <- base::paste(info, collapse = "; ")
  [14:20:55.921]                   if (!has_future) {
  [14:20:55.921]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:55.921]                       info)
  [14:20:55.921]                   }
  [14:20:55.921]                   else {
  [14:20:55.921]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:55.921]                       info, version)
  [14:20:55.921]                   }
  [14:20:55.921]                   base::stop(msg)
  [14:20:55.921]                 }
  [14:20:55.921]             }
  [14:20:55.921]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:55.921]         }
  [14:20:55.921]     }
  [14:20:55.921]     if (base::is.na(TRUE)) {
  [14:20:55.921]     }
  [14:20:55.921]     else {
  [14:20:55.921]         if (TRUE) {
  [14:20:55.921]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:55.921]                 open = "w")
  [14:20:55.921]         }
  [14:20:55.921]         else {
  [14:20:55.921]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:55.921]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:55.921]         }
  [14:20:55.921]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:55.921]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:55.921]             base::sink(type = "output", split = FALSE)
  [14:20:55.921]             base::close(...future.stdout)
  [14:20:55.921]         }, add = TRUE)
  [14:20:55.921]     }
  [14:20:55.921]     ...future.frame <- base::sys.nframe()
  [14:20:55.921]     ...future.conditions <- base::list()
  [14:20:55.921]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:55.921]     ...future.result <- base::tryCatch({
  [14:20:55.921]         base::withCallingHandlers({
  [14:20:55.921]             ...future.value <- base::withVisible(base::local({
  [14:20:55.921]                 ...future.sendCondition <- local({
  [14:20:55.921]                   sendCondition <- NULL
  [14:20:55.921]                   function(frame = 1L) {
  [14:20:55.921]                     if (is.function(sendCondition)) 
  [14:20:55.921]                       return(sendCondition)
  [14:20:55.921]                     ns <- getNamespace("parallel")
  [14:20:55.921]                     if (exists("sendData", mode = "function", 
  [14:20:55.921]                       envir = ns)) {
  [14:20:55.921]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:55.921]                         envir = ns)
  [14:20:55.921]                       envir <- sys.frame(frame)
  [14:20:55.921]                       master <- NULL
  [14:20:55.921]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:55.921]                         !identical(envir, emptyenv())) {
  [14:20:55.921]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:55.921]                           inherits = FALSE)) {
  [14:20:55.921]                           master <- get("master", mode = "list", 
  [14:20:55.921]                             envir = envir, inherits = FALSE)
  [14:20:55.921]                           if (inherits(master, "SOCKnode")) {
  [14:20:55.921]                             sendCondition <<- function(cond) {
  [14:20:55.921]                               data <- list(type = "VALUE", value = cond, 
  [14:20:55.921]                                 success = TRUE)
  [14:20:55.921]                               parallel_sendData(master, data)
  [14:20:55.921]                             }
  [14:20:55.921]                             return(sendCondition)
  [14:20:55.921]                           }
  [14:20:55.921]                         }
  [14:20:55.921]                         frame <- frame + 1L
  [14:20:55.921]                         envir <- sys.frame(frame)
  [14:20:55.921]                       }
  [14:20:55.921]                     }
  [14:20:55.921]                     sendCondition <<- function(cond) NULL
  [14:20:55.921]                   }
  [14:20:55.921]                 })
  [14:20:55.921]                 withCallingHandlers({
  [14:20:55.921]                   NULL
  [14:20:55.921]                 }, immediateCondition = function(cond) {
  [14:20:55.921]                   sendCondition <- ...future.sendCondition()
  [14:20:55.921]                   sendCondition(cond)
  [14:20:55.921]                   muffleCondition <- function (cond) 
  [14:20:55.921]                   {
  [14:20:55.921]                     inherits <- base::inherits
  [14:20:55.921]                     invokeRestart <- base::invokeRestart
  [14:20:55.921]                     muffled <- FALSE
  [14:20:55.921]                     if (inherits(cond, "message")) {
  [14:20:55.921]                       invokeRestart("muffleMessage")
  [14:20:55.921]                       muffled <- TRUE
  [14:20:55.921]                     }
  [14:20:55.921]                     else if (inherits(cond, "warning")) {
  [14:20:55.921]                       invokeRestart("muffleWarning")
  [14:20:55.921]                       muffled <- TRUE
  [14:20:55.921]                     }
  [14:20:55.921]                     else if (inherits(cond, "condition")) {
  [14:20:55.921]                       computeRestarts <- base::computeRestarts
  [14:20:55.921]                       grepl <- base::grepl
  [14:20:55.921]                       is.null <- base::is.null
  [14:20:55.921]                       restarts <- computeRestarts(cond)
  [14:20:55.921]                       for (restart in restarts) {
  [14:20:55.921]                         name <- restart$name
  [14:20:55.921]                         if (is.null(name)) 
  [14:20:55.921]                           next
  [14:20:55.921]                         if (!grepl("^muffle", name)) 
  [14:20:55.921]                           next
  [14:20:55.921]                         invokeRestart(restart)
  [14:20:55.921]                         muffled <- TRUE
  [14:20:55.921]                         break
  [14:20:55.921]                       }
  [14:20:55.921]                     }
  [14:20:55.921]                     invisible(muffled)
  [14:20:55.921]                   }
  [14:20:55.921]                   muffleCondition(cond)
  [14:20:55.921]                 })
  [14:20:55.921]             }))
  [14:20:55.921]             future::FutureResult(value = ...future.value$value, 
  [14:20:55.921]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.921]                   ...future.rng), started = ...future.startTime, 
  [14:20:55.921]                 version = "1.8")
  [14:20:55.921]         }, condition = base::local({
  [14:20:55.921]             c <- base::c
  [14:20:55.921]             inherits <- base::inherits
  [14:20:55.921]             invokeRestart <- base::invokeRestart
  [14:20:55.921]             length <- base::length
  [14:20:55.921]             list <- base::list
  [14:20:55.921]             seq.int <- base::seq.int
  [14:20:55.921]             signalCondition <- base::signalCondition
  [14:20:55.921]             sys.calls <- base::sys.calls
  [14:20:55.921]             Sys.time <- base::Sys.time
  [14:20:55.921]             `[[` <- base::`[[`
  [14:20:55.921]             `+` <- base::`+`
  [14:20:55.921]             `<<-` <- base::`<<-`
  [14:20:55.921]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:55.921]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:55.921]                   3L)]
  [14:20:55.921]             }
  [14:20:55.921]             function(cond) {
  [14:20:55.921]                 if (inherits(cond, "error")) {
  [14:20:55.921]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.921]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:55.921]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:55.921]                   signalCondition(cond)
  [14:20:55.921]                 }
  [14:20:55.921]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:55.921]                 ))) {
  [14:20:55.921]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:55.921]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:55.921]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:55.921]                   if (!signal) {
  [14:20:55.921]                     muffleCondition <- function (cond) 
  [14:20:55.921]                     {
  [14:20:55.921]                       inherits <- base::inherits
  [14:20:55.921]                       invokeRestart <- base::invokeRestart
  [14:20:55.921]                       muffled <- FALSE
  [14:20:55.921]                       if (inherits(cond, "message")) {
  [14:20:55.921]                         invokeRestart("muffleMessage")
  [14:20:55.921]                         muffled <- TRUE
  [14:20:55.921]                       }
  [14:20:55.921]                       else if (inherits(cond, "warning")) {
  [14:20:55.921]                         invokeRestart("muffleWarning")
  [14:20:55.921]                         muffled <- TRUE
  [14:20:55.921]                       }
  [14:20:55.921]                       else if (inherits(cond, "condition")) {
  [14:20:55.921]                         computeRestarts <- base::computeRestarts
  [14:20:55.921]                         grepl <- base::grepl
  [14:20:55.921]                         is.null <- base::is.null
  [14:20:55.921]                         restarts <- computeRestarts(cond)
  [14:20:55.921]                         for (restart in restarts) {
  [14:20:55.921]                           name <- restart$name
  [14:20:55.921]                           if (is.null(name)) 
  [14:20:55.921]                             next
  [14:20:55.921]                           if (!grepl("^muffle", name)) 
  [14:20:55.921]                             next
  [14:20:55.921]                           invokeRestart(restart)
  [14:20:55.921]                           muffled <- TRUE
  [14:20:55.921]                           break
  [14:20:55.921]                         }
  [14:20:55.921]                       }
  [14:20:55.921]                       invisible(muffled)
  [14:20:55.921]                     }
  [14:20:55.921]                     muffleCondition(cond)
  [14:20:55.921]                   }
  [14:20:55.921]                 }
  [14:20:55.921]             }
  [14:20:55.921]         }))
  [14:20:55.921]     }, error = function(ex) {
  [14:20:55.921]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:55.921]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:55.921]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:55.921]     }, finally = {
  [14:20:55.921]         {
  [14:20:55.921]             NULL
  [14:20:55.921]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:55.921]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:55.921]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:55.921]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:55.921]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:55.921]                 ...) 
  [14:20:55.921]             {
  [14:20:55.921]                 if (substitute) 
  [14:20:55.921]                   expr <- substitute(expr)
  [14:20:55.921]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:55.921]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:55.921]                   globals = globals, persistent = persistent, 
  [14:20:55.921]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:55.921]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:55.921]                   label = label, ...)
  [14:20:55.921]                 if (!future$lazy) 
  [14:20:55.921]                   future <- run(future)
  [14:20:55.921]                 invisible(future)
  [14:20:55.921]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:55.921]         }
  [14:20:55.921]         base::options(...future.oldOptions)
  [14:20:55.921]     })
  [14:20:55.921]     Sys.time
  [14:20:55.921]     if (base::is.na(TRUE)) {
  [14:20:55.921]     }
  [14:20:55.921]     else {
  [14:20:55.921]         base::sink(type = "output", split = FALSE)
  [14:20:55.921]         if (TRUE) {
  [14:20:55.921]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:55.921]         }
  [14:20:55.921]         else {
  [14:20:55.921]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:55.921]         }
  [14:20:55.921]         base::close(...future.stdout)
  [14:20:55.921]         ...future.stdout <- NULL
  [14:20:55.921]     }
  [14:20:55.921]     ...future.result$conditions <- ...future.conditions
  [14:20:55.921]     ...future.result
  [14:20:55.921] }
  [14:20:55.927] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:20:55.940] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:55.941] - Validating connection of ClusterFuture
  [14:20:55.941] - received message: FutureResult
  [14:20:55.942] - Received FutureResult
  [14:20:55.942] - Erased future from FutureRegistry
  [14:20:55.942] result() for ClusterFuture ...
  [14:20:55.943] - result already collected: FutureResult
  [14:20:55.943] result() for ClusterFuture ... done
  [14:20:55.944] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:55.944] result() for ClusterFuture ...
  [14:20:55.944] - result already collected: FutureResult
  [14:20:55.945] result() for ClusterFuture ... done
  [14:20:55.945] result() for ClusterFuture ...
  [14:20:55.946] - result already collected: FutureResult
  [14:20:55.946] result() for ClusterFuture ... done
  [14:20:55.949] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa2a2838> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa57cd60> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa2a2838> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa57cd60> 
   $  : NULL
   $  : NULL
   $  : num 6
  [14:20:55.995] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:55.996] - Validating connection of ClusterFuture
  [14:20:55.996] - received message: FutureResult
  [14:20:55.996] - Received FutureResult
  [14:20:55.997] - Erased future from FutureRegistry
  [14:20:55.997] result() for ClusterFuture ...
  [14:20:55.997] - result already collected: FutureResult
  [14:20:55.998] result() for ClusterFuture ... done
  [14:20:55.998] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [14:20:56.007] resolve() on list ...
  [14:20:56.008]  recursive: 0
  [14:20:56.008]  length: 6
  [14:20:56.008]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:56.009] signalConditionsASAP(numeric, pos=1) ...
  [14:20:56.009] - nx: 6
  [14:20:56.009] - relay: TRUE
  [14:20:56.010] - stdout: TRUE
  [14:20:56.010] - signal: TRUE
  [14:20:56.010] - resignal: FALSE
  [14:20:56.011] - force: TRUE
  [14:20:56.011] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.011] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.012]  - until=2
  [14:20:56.012]  - relaying element #2
  [14:20:56.012] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.013] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.013] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:56.013]  length: 5 (resolved future 1)
  [14:20:56.014] Future #2
  [14:20:56.014] result() for ClusterFuture ...
  [14:20:56.014] - result already collected: FutureResult
  [14:20:56.026] result() for ClusterFuture ... done
  [14:20:56.027] result() for ClusterFuture ...
  [14:20:56.027] - result already collected: FutureResult
  [14:20:56.028] result() for ClusterFuture ... done
  [14:20:56.028] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:20:56.028] - nx: 6
  [14:20:56.029] - relay: TRUE
  [14:20:56.029] - stdout: TRUE
  [14:20:56.029] - signal: TRUE
  [14:20:56.030] - resignal: FALSE
  [14:20:56.030] - force: TRUE
  [14:20:56.031] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.031] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.031]  - until=2
  [14:20:56.032]  - relaying element #2
  [14:20:56.032] result() for ClusterFuture ...
  [14:20:56.032] - result already collected: FutureResult
  [14:20:56.033] result() for ClusterFuture ... done
  [14:20:56.033] result() for ClusterFuture ...
  [14:20:56.033] - result already collected: FutureResult
  [14:20:56.034] result() for ClusterFuture ... done
  [14:20:56.034] result() for ClusterFuture ...
  [14:20:56.034] - result already collected: FutureResult
  [14:20:56.035] result() for ClusterFuture ... done
  [14:20:56.035] result() for ClusterFuture ...
  [14:20:56.035] - result already collected: FutureResult
  [14:20:56.036] result() for ClusterFuture ... done
  [14:20:56.036] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.036] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.037] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:20:56.037]  length: 4 (resolved future 2)
  [14:20:56.037] Future #3
  [14:20:56.038] result() for ClusterFuture ...
  [14:20:56.038] - result already collected: FutureResult
  [14:20:56.055] result() for ClusterFuture ... done
  [14:20:56.055] result() for ClusterFuture ...
  [14:20:56.055] - result already collected: FutureResult
  [14:20:56.056] result() for ClusterFuture ... done
  [14:20:56.056] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:20:56.057] - nx: 6
  [14:20:56.057] - relay: TRUE
  [14:20:56.057] - stdout: TRUE
  [14:20:56.057] - signal: TRUE
  [14:20:56.058] - resignal: FALSE
  [14:20:56.058] - force: TRUE
  [14:20:56.058] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.059] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.059]  - until=3
  [14:20:56.060]  - relaying element #3
  [14:20:56.060] result() for ClusterFuture ...
  [14:20:56.060] - result already collected: FutureResult
  [14:20:56.061] result() for ClusterFuture ... done
  [14:20:56.061] result() for ClusterFuture ...
  [14:20:56.061] - result already collected: FutureResult
  [14:20:56.062] result() for ClusterFuture ... done
  [14:20:56.062] result() for ClusterFuture ...
  [14:20:56.063] - result already collected: FutureResult
  [14:20:56.063] result() for ClusterFuture ... done
  [14:20:56.063] result() for ClusterFuture ...
  [14:20:56.064] - result already collected: FutureResult
  [14:20:56.064] result() for ClusterFuture ... done
  [14:20:56.064] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.065] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.065] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:20:56.065]  length: 3 (resolved future 3)
  [14:20:56.066] signalConditionsASAP(NULL, pos=4) ...
  [14:20:56.066] - nx: 6
  [14:20:56.066] - relay: TRUE
  [14:20:56.067] - stdout: TRUE
  [14:20:56.067] - signal: TRUE
  [14:20:56.067] - resignal: FALSE
  [14:20:56.068] - force: TRUE
  [14:20:56.068] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.068] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.069]  - until=5
  [14:20:56.069]  - relaying element #5
  [14:20:56.069] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.070] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.070] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:56.070]  length: 2 (resolved future 4)
  [14:20:56.071] signalConditionsASAP(NULL, pos=5) ...
  [14:20:56.071] - nx: 6
  [14:20:56.071] - relay: TRUE
  [14:20:56.071] - stdout: TRUE
  [14:20:56.072] - signal: TRUE
  [14:20:56.072] - resignal: FALSE
  [14:20:56.072] - force: TRUE
  [14:20:56.073] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.073] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.073]  - until=6
  [14:20:56.073]  - relaying element #6
  [14:20:56.074] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.074] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.074] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:56.075]  length: 1 (resolved future 5)
  [14:20:56.075] signalConditionsASAP(numeric, pos=6) ...
  [14:20:56.075] - nx: 6
  [14:20:56.076] - relay: TRUE
  [14:20:56.076] - stdout: TRUE
  [14:20:56.083] - signal: TRUE
  [14:20:56.083] - resignal: FALSE
  [14:20:56.084] - force: TRUE
  [14:20:56.084] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.084] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.085]  - until=6
  [14:20:56.085] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.085] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.086] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:56.086]  length: 0 (resolved future 6)
  [14:20:56.086] Relaying remaining futures
  [14:20:56.087] signalConditionsASAP(NULL, pos=0) ...
  [14:20:56.087] - nx: 6
  [14:20:56.087] - relay: TRUE
  [14:20:56.088] - stdout: TRUE
  [14:20:56.088] - signal: TRUE
  [14:20:56.088] - resignal: FALSE
  [14:20:56.089] - force: TRUE
  [14:20:56.089] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.089] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:56.090] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.090] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.091] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:56.091] resolve() on list ... DONE
  [14:20:56.091] result() for ClusterFuture ...
  [14:20:56.092] - result already collected: FutureResult
  [14:20:56.092] result() for ClusterFuture ... done
  [14:20:56.092] result() for ClusterFuture ...
  [14:20:56.093] - result already collected: FutureResult
  [14:20:56.093] result() for ClusterFuture ... done
  [14:20:56.093] result() for ClusterFuture ...
  [14:20:56.094] - result already collected: FutureResult
  [14:20:56.094] result() for ClusterFuture ... done
  [14:20:56.094] result() for ClusterFuture ...
  [14:20:56.095] - result already collected: FutureResult
  [14:20:56.095] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [14:20:56.107] getGlobalsAndPackages() ...
  [14:20:56.107] Searching for globals...
  [14:20:56.108] 
  [14:20:56.109] Searching for globals ... DONE
  [14:20:56.109] - globals: [0] <none>
  [14:20:56.109] getGlobalsAndPackages() ... DONE
  [14:20:56.114] Packages needed by the future expression (n = 0): <none>
  [14:20:56.115] Packages needed by future strategies (n = 0): <none>
  [14:20:56.121] {
  [14:20:56.121]     {
  [14:20:56.121]         ...future.startTime <- base::Sys.time()
  [14:20:56.121]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.121]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.121]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.121]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.121]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.121]         {
  [14:20:56.121]             {
  [14:20:56.121]                 has_future <- base::requireNamespace("future", 
  [14:20:56.121]                   quietly = TRUE)
  [14:20:56.121]                 version <- if (has_future) 
  [14:20:56.121]                   utils::packageVersion("future")
  [14:20:56.121]                 else NULL
  [14:20:56.121]                 if (!has_future || version < "1.8.0") {
  [14:20:56.121]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.121]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.121]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.121]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.121]                       "release", "version")], collapse = " "), 
  [14:20:56.121]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.121]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.121]                     info)
  [14:20:56.121]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.121]                   if (!has_future) {
  [14:20:56.121]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.121]                       info)
  [14:20:56.121]                   }
  [14:20:56.121]                   else {
  [14:20:56.121]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.121]                       info, version)
  [14:20:56.121]                   }
  [14:20:56.121]                   base::stop(msg)
  [14:20:56.121]                 }
  [14:20:56.121]             }
  [14:20:56.121]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.121]         }
  [14:20:56.121]     }
  [14:20:56.121]     if (base::is.na(TRUE)) {
  [14:20:56.121]     }
  [14:20:56.121]     else {
  [14:20:56.121]         if (TRUE) {
  [14:20:56.121]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.121]                 open = "w")
  [14:20:56.121]         }
  [14:20:56.121]         else {
  [14:20:56.121]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.121]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.121]         }
  [14:20:56.121]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.121]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.121]             base::sink(type = "output", split = FALSE)
  [14:20:56.121]             base::close(...future.stdout)
  [14:20:56.121]         }, add = TRUE)
  [14:20:56.121]     }
  [14:20:56.121]     ...future.frame <- base::sys.nframe()
  [14:20:56.121]     ...future.conditions <- base::list()
  [14:20:56.121]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.121]     ...future.result <- base::tryCatch({
  [14:20:56.121]         base::withCallingHandlers({
  [14:20:56.121]             ...future.value <- base::withVisible(base::local({
  [14:20:56.121]                 ...future.sendCondition <- local({
  [14:20:56.121]                   sendCondition <- NULL
  [14:20:56.121]                   function(frame = 1L) {
  [14:20:56.121]                     if (is.function(sendCondition)) 
  [14:20:56.121]                       return(sendCondition)
  [14:20:56.121]                     ns <- getNamespace("parallel")
  [14:20:56.121]                     if (exists("sendData", mode = "function", 
  [14:20:56.121]                       envir = ns)) {
  [14:20:56.121]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.121]                         envir = ns)
  [14:20:56.121]                       envir <- sys.frame(frame)
  [14:20:56.121]                       master <- NULL
  [14:20:56.121]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.121]                         !identical(envir, emptyenv())) {
  [14:20:56.121]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.121]                           inherits = FALSE)) {
  [14:20:56.121]                           master <- get("master", mode = "list", 
  [14:20:56.121]                             envir = envir, inherits = FALSE)
  [14:20:56.121]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.121]                             sendCondition <<- function(cond) {
  [14:20:56.121]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.121]                                 success = TRUE)
  [14:20:56.121]                               parallel_sendData(master, data)
  [14:20:56.121]                             }
  [14:20:56.121]                             return(sendCondition)
  [14:20:56.121]                           }
  [14:20:56.121]                         }
  [14:20:56.121]                         frame <- frame + 1L
  [14:20:56.121]                         envir <- sys.frame(frame)
  [14:20:56.121]                       }
  [14:20:56.121]                     }
  [14:20:56.121]                     sendCondition <<- function(cond) NULL
  [14:20:56.121]                   }
  [14:20:56.121]                 })
  [14:20:56.121]                 withCallingHandlers({
  [14:20:56.121]                   2
  [14:20:56.121]                 }, immediateCondition = function(cond) {
  [14:20:56.121]                   sendCondition <- ...future.sendCondition()
  [14:20:56.121]                   sendCondition(cond)
  [14:20:56.121]                   muffleCondition <- function (cond) 
  [14:20:56.121]                   {
  [14:20:56.121]                     inherits <- base::inherits
  [14:20:56.121]                     invokeRestart <- base::invokeRestart
  [14:20:56.121]                     muffled <- FALSE
  [14:20:56.121]                     if (inherits(cond, "message")) {
  [14:20:56.121]                       invokeRestart("muffleMessage")
  [14:20:56.121]                       muffled <- TRUE
  [14:20:56.121]                     }
  [14:20:56.121]                     else if (inherits(cond, "warning")) {
  [14:20:56.121]                       invokeRestart("muffleWarning")
  [14:20:56.121]                       muffled <- TRUE
  [14:20:56.121]                     }
  [14:20:56.121]                     else if (inherits(cond, "condition")) {
  [14:20:56.121]                       computeRestarts <- base::computeRestarts
  [14:20:56.121]                       grepl <- base::grepl
  [14:20:56.121]                       is.null <- base::is.null
  [14:20:56.121]                       restarts <- computeRestarts(cond)
  [14:20:56.121]                       for (restart in restarts) {
  [14:20:56.121]                         name <- restart$name
  [14:20:56.121]                         if (is.null(name)) 
  [14:20:56.121]                           next
  [14:20:56.121]                         if (!grepl("^muffle", name)) 
  [14:20:56.121]                           next
  [14:20:56.121]                         invokeRestart(restart)
  [14:20:56.121]                         muffled <- TRUE
  [14:20:56.121]                         break
  [14:20:56.121]                       }
  [14:20:56.121]                     }
  [14:20:56.121]                     invisible(muffled)
  [14:20:56.121]                   }
  [14:20:56.121]                   muffleCondition(cond)
  [14:20:56.121]                 })
  [14:20:56.121]             }))
  [14:20:56.121]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.121]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.121]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.121]                 version = "1.8")
  [14:20:56.121]         }, condition = base::local({
  [14:20:56.121]             c <- base::c
  [14:20:56.121]             inherits <- base::inherits
  [14:20:56.121]             invokeRestart <- base::invokeRestart
  [14:20:56.121]             length <- base::length
  [14:20:56.121]             list <- base::list
  [14:20:56.121]             seq.int <- base::seq.int
  [14:20:56.121]             signalCondition <- base::signalCondition
  [14:20:56.121]             sys.calls <- base::sys.calls
  [14:20:56.121]             Sys.time <- base::Sys.time
  [14:20:56.121]             `[[` <- base::`[[`
  [14:20:56.121]             `+` <- base::`+`
  [14:20:56.121]             `<<-` <- base::`<<-`
  [14:20:56.121]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.121]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.121]                   3L)]
  [14:20:56.121]             }
  [14:20:56.121]             function(cond) {
  [14:20:56.121]                 if (inherits(cond, "error")) {
  [14:20:56.121]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.121]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.121]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.121]                   signalCondition(cond)
  [14:20:56.121]                 }
  [14:20:56.121]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.121]                 ))) {
  [14:20:56.121]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.121]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.121]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.121]                   if (!signal) {
  [14:20:56.121]                     muffleCondition <- function (cond) 
  [14:20:56.121]                     {
  [14:20:56.121]                       inherits <- base::inherits
  [14:20:56.121]                       invokeRestart <- base::invokeRestart
  [14:20:56.121]                       muffled <- FALSE
  [14:20:56.121]                       if (inherits(cond, "message")) {
  [14:20:56.121]                         invokeRestart("muffleMessage")
  [14:20:56.121]                         muffled <- TRUE
  [14:20:56.121]                       }
  [14:20:56.121]                       else if (inherits(cond, "warning")) {
  [14:20:56.121]                         invokeRestart("muffleWarning")
  [14:20:56.121]                         muffled <- TRUE
  [14:20:56.121]                       }
  [14:20:56.121]                       else if (inherits(cond, "condition")) {
  [14:20:56.121]                         computeRestarts <- base::computeRestarts
  [14:20:56.121]                         grepl <- base::grepl
  [14:20:56.121]                         is.null <- base::is.null
  [14:20:56.121]                         restarts <- computeRestarts(cond)
  [14:20:56.121]                         for (restart in restarts) {
  [14:20:56.121]                           name <- restart$name
  [14:20:56.121]                           if (is.null(name)) 
  [14:20:56.121]                             next
  [14:20:56.121]                           if (!grepl("^muffle", name)) 
  [14:20:56.121]                             next
  [14:20:56.121]                           invokeRestart(restart)
  [14:20:56.121]                           muffled <- TRUE
  [14:20:56.121]                           break
  [14:20:56.121]                         }
  [14:20:56.121]                       }
  [14:20:56.121]                       invisible(muffled)
  [14:20:56.121]                     }
  [14:20:56.121]                     muffleCondition(cond)
  [14:20:56.121]                   }
  [14:20:56.121]                 }
  [14:20:56.121]             }
  [14:20:56.121]         }))
  [14:20:56.121]     }, error = function(ex) {
  [14:20:56.121]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.121]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.121]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.121]     }, finally = {
  [14:20:56.121]         {
  [14:20:56.121]             NULL
  [14:20:56.121]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.121]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.121]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.121]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.121]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.121]                 ...) 
  [14:20:56.121]             {
  [14:20:56.121]                 if (substitute) 
  [14:20:56.121]                   expr <- substitute(expr)
  [14:20:56.121]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.121]                   globals = globals, persistent = persistent, 
  [14:20:56.121]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.121]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.121]                   label = label, ...)
  [14:20:56.121]                 if (!future$lazy) 
  [14:20:56.121]                   future <- run(future)
  [14:20:56.121]                 invisible(future)
  [14:20:56.121]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.121]         }
  [14:20:56.121]         base::options(...future.oldOptions)
  [14:20:56.121]     })
  [14:20:56.121]     Sys.time
  [14:20:56.121]     if (base::is.na(TRUE)) {
  [14:20:56.121]     }
  [14:20:56.121]     else {
  [14:20:56.121]         base::sink(type = "output", split = FALSE)
  [14:20:56.121]         if (TRUE) {
  [14:20:56.121]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.121]         }
  [14:20:56.121]         else {
  [14:20:56.121]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.121]         }
  [14:20:56.121]         base::close(...future.stdout)
  [14:20:56.121]         ...future.stdout <- NULL
  [14:20:56.121]     }
  [14:20:56.121]     ...future.result$conditions <- ...future.conditions
  [14:20:56.121]     ...future.result
  [14:20:56.121] }
  [14:20:56.129] ClusterFuture started
  [14:20:56.136] getGlobalsAndPackages() ...
  [14:20:56.136] Searching for globals...
  [14:20:56.137] 
  [14:20:56.138] Searching for globals ... DONE
  [14:20:56.138] - globals: [0] <none>
  [14:20:56.138] getGlobalsAndPackages() ... DONE
  [14:20:56.143] Packages needed by the future expression (n = 0): <none>
  [14:20:56.143] Packages needed by future strategies (n = 0): <none>
  [14:20:56.149] {
  [14:20:56.149]     {
  [14:20:56.149]         ...future.startTime <- base::Sys.time()
  [14:20:56.149]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.149]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.149]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.149]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.149]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.149]         {
  [14:20:56.149]             {
  [14:20:56.149]                 has_future <- base::requireNamespace("future", 
  [14:20:56.149]                   quietly = TRUE)
  [14:20:56.149]                 version <- if (has_future) 
  [14:20:56.149]                   utils::packageVersion("future")
  [14:20:56.149]                 else NULL
  [14:20:56.149]                 if (!has_future || version < "1.8.0") {
  [14:20:56.149]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.149]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.149]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.149]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.149]                       "release", "version")], collapse = " "), 
  [14:20:56.149]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.149]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.149]                     info)
  [14:20:56.149]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.149]                   if (!has_future) {
  [14:20:56.149]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.149]                       info)
  [14:20:56.149]                   }
  [14:20:56.149]                   else {
  [14:20:56.149]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.149]                       info, version)
  [14:20:56.149]                   }
  [14:20:56.149]                   base::stop(msg)
  [14:20:56.149]                 }
  [14:20:56.149]             }
  [14:20:56.149]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.149]         }
  [14:20:56.149]     }
  [14:20:56.149]     if (base::is.na(TRUE)) {
  [14:20:56.149]     }
  [14:20:56.149]     else {
  [14:20:56.149]         if (TRUE) {
  [14:20:56.149]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.149]                 open = "w")
  [14:20:56.149]         }
  [14:20:56.149]         else {
  [14:20:56.149]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.149]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.149]         }
  [14:20:56.149]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.149]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.149]             base::sink(type = "output", split = FALSE)
  [14:20:56.149]             base::close(...future.stdout)
  [14:20:56.149]         }, add = TRUE)
  [14:20:56.149]     }
  [14:20:56.149]     ...future.frame <- base::sys.nframe()
  [14:20:56.149]     ...future.conditions <- base::list()
  [14:20:56.149]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.149]     ...future.result <- base::tryCatch({
  [14:20:56.149]         base::withCallingHandlers({
  [14:20:56.149]             ...future.value <- base::withVisible(base::local({
  [14:20:56.149]                 ...future.sendCondition <- local({
  [14:20:56.149]                   sendCondition <- NULL
  [14:20:56.149]                   function(frame = 1L) {
  [14:20:56.149]                     if (is.function(sendCondition)) 
  [14:20:56.149]                       return(sendCondition)
  [14:20:56.149]                     ns <- getNamespace("parallel")
  [14:20:56.149]                     if (exists("sendData", mode = "function", 
  [14:20:56.149]                       envir = ns)) {
  [14:20:56.149]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.149]                         envir = ns)
  [14:20:56.149]                       envir <- sys.frame(frame)
  [14:20:56.149]                       master <- NULL
  [14:20:56.149]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.149]                         !identical(envir, emptyenv())) {
  [14:20:56.149]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.149]                           inherits = FALSE)) {
  [14:20:56.149]                           master <- get("master", mode = "list", 
  [14:20:56.149]                             envir = envir, inherits = FALSE)
  [14:20:56.149]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.149]                             sendCondition <<- function(cond) {
  [14:20:56.149]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.149]                                 success = TRUE)
  [14:20:56.149]                               parallel_sendData(master, data)
  [14:20:56.149]                             }
  [14:20:56.149]                             return(sendCondition)
  [14:20:56.149]                           }
  [14:20:56.149]                         }
  [14:20:56.149]                         frame <- frame + 1L
  [14:20:56.149]                         envir <- sys.frame(frame)
  [14:20:56.149]                       }
  [14:20:56.149]                     }
  [14:20:56.149]                     sendCondition <<- function(cond) NULL
  [14:20:56.149]                   }
  [14:20:56.149]                 })
  [14:20:56.149]                 withCallingHandlers({
  [14:20:56.149]                   NULL
  [14:20:56.149]                 }, immediateCondition = function(cond) {
  [14:20:56.149]                   sendCondition <- ...future.sendCondition()
  [14:20:56.149]                   sendCondition(cond)
  [14:20:56.149]                   muffleCondition <- function (cond) 
  [14:20:56.149]                   {
  [14:20:56.149]                     inherits <- base::inherits
  [14:20:56.149]                     invokeRestart <- base::invokeRestart
  [14:20:56.149]                     muffled <- FALSE
  [14:20:56.149]                     if (inherits(cond, "message")) {
  [14:20:56.149]                       invokeRestart("muffleMessage")
  [14:20:56.149]                       muffled <- TRUE
  [14:20:56.149]                     }
  [14:20:56.149]                     else if (inherits(cond, "warning")) {
  [14:20:56.149]                       invokeRestart("muffleWarning")
  [14:20:56.149]                       muffled <- TRUE
  [14:20:56.149]                     }
  [14:20:56.149]                     else if (inherits(cond, "condition")) {
  [14:20:56.149]                       computeRestarts <- base::computeRestarts
  [14:20:56.149]                       grepl <- base::grepl
  [14:20:56.149]                       is.null <- base::is.null
  [14:20:56.149]                       restarts <- computeRestarts(cond)
  [14:20:56.149]                       for (restart in restarts) {
  [14:20:56.149]                         name <- restart$name
  [14:20:56.149]                         if (is.null(name)) 
  [14:20:56.149]                           next
  [14:20:56.149]                         if (!grepl("^muffle", name)) 
  [14:20:56.149]                           next
  [14:20:56.149]                         invokeRestart(restart)
  [14:20:56.149]                         muffled <- TRUE
  [14:20:56.149]                         break
  [14:20:56.149]                       }
  [14:20:56.149]                     }
  [14:20:56.149]                     invisible(muffled)
  [14:20:56.149]                   }
  [14:20:56.149]                   muffleCondition(cond)
  [14:20:56.149]                 })
  [14:20:56.149]             }))
  [14:20:56.149]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.149]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.149]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.149]                 version = "1.8")
  [14:20:56.149]         }, condition = base::local({
  [14:20:56.149]             c <- base::c
  [14:20:56.149]             inherits <- base::inherits
  [14:20:56.149]             invokeRestart <- base::invokeRestart
  [14:20:56.149]             length <- base::length
  [14:20:56.149]             list <- base::list
  [14:20:56.149]             seq.int <- base::seq.int
  [14:20:56.149]             signalCondition <- base::signalCondition
  [14:20:56.149]             sys.calls <- base::sys.calls
  [14:20:56.149]             Sys.time <- base::Sys.time
  [14:20:56.149]             `[[` <- base::`[[`
  [14:20:56.149]             `+` <- base::`+`
  [14:20:56.149]             `<<-` <- base::`<<-`
  [14:20:56.149]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.149]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.149]                   3L)]
  [14:20:56.149]             }
  [14:20:56.149]             function(cond) {
  [14:20:56.149]                 if (inherits(cond, "error")) {
  [14:20:56.149]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.149]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.149]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.149]                   signalCondition(cond)
  [14:20:56.149]                 }
  [14:20:56.149]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.149]                 ))) {
  [14:20:56.149]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.149]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.149]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.149]                   if (!signal) {
  [14:20:56.149]                     muffleCondition <- function (cond) 
  [14:20:56.149]                     {
  [14:20:56.149]                       inherits <- base::inherits
  [14:20:56.149]                       invokeRestart <- base::invokeRestart
  [14:20:56.149]                       muffled <- FALSE
  [14:20:56.149]                       if (inherits(cond, "message")) {
  [14:20:56.149]                         invokeRestart("muffleMessage")
  [14:20:56.149]                         muffled <- TRUE
  [14:20:56.149]                       }
  [14:20:56.149]                       else if (inherits(cond, "warning")) {
  [14:20:56.149]                         invokeRestart("muffleWarning")
  [14:20:56.149]                         muffled <- TRUE
  [14:20:56.149]                       }
  [14:20:56.149]                       else if (inherits(cond, "condition")) {
  [14:20:56.149]                         computeRestarts <- base::computeRestarts
  [14:20:56.149]                         grepl <- base::grepl
  [14:20:56.149]                         is.null <- base::is.null
  [14:20:56.149]                         restarts <- computeRestarts(cond)
  [14:20:56.149]                         for (restart in restarts) {
  [14:20:56.149]                           name <- restart$name
  [14:20:56.149]                           if (is.null(name)) 
  [14:20:56.149]                             next
  [14:20:56.149]                           if (!grepl("^muffle", name)) 
  [14:20:56.149]                             next
  [14:20:56.149]                           invokeRestart(restart)
  [14:20:56.149]                           muffled <- TRUE
  [14:20:56.149]                           break
  [14:20:56.149]                         }
  [14:20:56.149]                       }
  [14:20:56.149]                       invisible(muffled)
  [14:20:56.149]                     }
  [14:20:56.149]                     muffleCondition(cond)
  [14:20:56.149]                   }
  [14:20:56.149]                 }
  [14:20:56.149]             }
  [14:20:56.149]         }))
  [14:20:56.149]     }, error = function(ex) {
  [14:20:56.149]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.149]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.149]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.149]     }, finally = {
  [14:20:56.149]         {
  [14:20:56.149]             NULL
  [14:20:56.149]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.149]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.149]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.149]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.149]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.149]                 ...) 
  [14:20:56.149]             {
  [14:20:56.149]                 if (substitute) 
  [14:20:56.149]                   expr <- substitute(expr)
  [14:20:56.149]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.149]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.149]                   globals = globals, persistent = persistent, 
  [14:20:56.149]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.149]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.149]                   label = label, ...)
  [14:20:56.149]                 if (!future$lazy) 
  [14:20:56.149]                   future <- run(future)
  [14:20:56.149]                 invisible(future)
  [14:20:56.149]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.149]         }
  [14:20:56.149]         base::options(...future.oldOptions)
  [14:20:56.149]     })
  [14:20:56.149]     Sys.time
  [14:20:56.149]     if (base::is.na(TRUE)) {
  [14:20:56.149]     }
  [14:20:56.149]     else {
  [14:20:56.149]         base::sink(type = "output", split = FALSE)
  [14:20:56.149]         if (TRUE) {
  [14:20:56.149]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.149]         }
  [14:20:56.149]         else {
  [14:20:56.149]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.149]         }
  [14:20:56.149]         base::close(...future.stdout)
  [14:20:56.149]         ...future.stdout <- NULL
  [14:20:56.149]     }
  [14:20:56.149]     ...future.result$conditions <- ...future.conditions
  [14:20:56.149]     ...future.result
  [14:20:56.149] }
  [14:20:56.156] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:20:56.208] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.209] - Validating connection of ClusterFuture
  [14:20:56.209] - received message: FutureResult
  [14:20:56.210] - Received FutureResult
  [14:20:56.210] - Erased future from FutureRegistry
  [14:20:56.211] result() for ClusterFuture ...
  [14:20:56.211] - result already collected: FutureResult
  [14:20:56.211] result() for ClusterFuture ... done
  [14:20:56.212] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:56.212] result() for ClusterFuture ...
  [14:20:56.213] - result already collected: FutureResult
  [14:20:56.213] result() for ClusterFuture ... done
  [14:20:56.213] result() for ClusterFuture ...
  [14:20:56.214] - result already collected: FutureResult
  [14:20:56.214] result() for ClusterFuture ... done
  [14:20:56.217] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f90c4e08> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa2d5f90> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f90c4e08> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa2d5f90> 
   $  : 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" ...
  [14:20:56.263] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.264] - Validating connection of ClusterFuture
  [14:20:56.264] - received message: FutureResult
  [14:20:56.265] - Received FutureResult
  [14:20:56.265] - Erased future from FutureRegistry
  [14:20:56.265] result() for ClusterFuture ...
  [14:20:56.266] - result already collected: FutureResult
  [14:20:56.266] result() for ClusterFuture ... done
  [14:20:56.266] 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" "" ...
  [14:20:56.272] resolve() on list ...
  [14:20:56.272]  recursive: 0
  [14:20:56.273]  length: 6
  [14:20:56.273]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:56.273] signalConditionsASAP(numeric, pos=1) ...
  [14:20:56.274] - nx: 6
  [14:20:56.274] - relay: TRUE
  [14:20:56.274] - stdout: TRUE
  [14:20:56.275] - signal: TRUE
  [14:20:56.275] - resignal: FALSE
  [14:20:56.275] - force: TRUE
  [14:20:56.276] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.276] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.276]  - until=2
  [14:20:56.277]  - relaying element #2
  [14:20:56.277] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.277] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.278] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:56.278]  length: 5 (resolved future 1)
  [14:20:56.279] Future #2
  [14:20:56.279] result() for ClusterFuture ...
  [14:20:56.279] - result already collected: FutureResult
  [14:20:56.280] result() for ClusterFuture ... done
  [14:20:56.280] result() for ClusterFuture ...
  [14:20:56.280] - result already collected: FutureResult
  [14:20:56.281] result() for ClusterFuture ... done
  [14:20:56.281] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:20:56.281] - nx: 6
  [14:20:56.282] - relay: TRUE
  [14:20:56.282] - stdout: TRUE
  [14:20:56.282] - signal: TRUE
  [14:20:56.283] - resignal: FALSE
  [14:20:56.283] - force: TRUE
  [14:20:56.283] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.283] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.284]  - until=2
  [14:20:56.284]  - relaying element #2
  [14:20:56.285] result() for ClusterFuture ...
  [14:20:56.285] - result already collected: FutureResult
  [14:20:56.285] result() for ClusterFuture ... done
  [14:20:56.286] result() for ClusterFuture ...
  [14:20:56.286] - result already collected: FutureResult
  [14:20:56.286] result() for ClusterFuture ... done
  [14:20:56.287] result() for ClusterFuture ...
  [14:20:56.287] - result already collected: FutureResult
  [14:20:56.287] result() for ClusterFuture ... done
  [14:20:56.288] result() for ClusterFuture ...
  [14:20:56.288] - result already collected: FutureResult
  [14:20:56.288] result() for ClusterFuture ... done
  [14:20:56.311] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.312] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.312] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:20:56.312]  length: 4 (resolved future 2)
  [14:20:56.313] Future #3
  [14:20:56.313] result() for ClusterFuture ...
  [14:20:56.314] - result already collected: FutureResult
  [14:20:56.314] result() for ClusterFuture ... done
  [14:20:56.314] result() for ClusterFuture ...
  [14:20:56.315] - result already collected: FutureResult
  [14:20:56.315] result() for ClusterFuture ... done
  [14:20:56.315] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:20:56.316] - nx: 6
  [14:20:56.316] - relay: TRUE
  [14:20:56.316] - stdout: TRUE
  [14:20:56.317] - signal: TRUE
  [14:20:56.317] - resignal: FALSE
  [14:20:56.317] - force: TRUE
  [14:20:56.318] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.318] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.330]  - until=3
  [14:20:56.331]  - relaying element #3
  [14:20:56.331] result() for ClusterFuture ...
  [14:20:56.332] - result already collected: FutureResult
  [14:20:56.332] result() for ClusterFuture ... done
  [14:20:56.332] result() for ClusterFuture ...
  [14:20:56.333] - result already collected: FutureResult
  [14:20:56.333] result() for ClusterFuture ... done
  [14:20:56.334] result() for ClusterFuture ...
  [14:20:56.334] - result already collected: FutureResult
  [14:20:56.334] result() for ClusterFuture ... done
  [14:20:56.335] result() for ClusterFuture ...
  [14:20:56.335] - result already collected: FutureResult
  [14:20:56.335] result() for ClusterFuture ... done
  [14:20:56.336] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.336] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.336] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:20:56.337]  length: 3 (resolved future 3)
  [14:20:56.337] signalConditionsASAP(NULL, pos=4) ...
  [14:20:56.337] - nx: 6
  [14:20:56.338] - relay: TRUE
  [14:20:56.338] - stdout: TRUE
  [14:20:56.338] - signal: TRUE
  [14:20:56.339] - resignal: FALSE
  [14:20:56.339] - force: TRUE
  [14:20:56.339] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.339] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.340]  - until=5
  [14:20:56.340]  - relaying element #5
  [14:20:56.340] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.341] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.341] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:56.342]  length: 2 (resolved future 4)
  [14:20:56.342] signalConditionsASAP(NULL, pos=5) ...
  [14:20:56.342] - nx: 6
  [14:20:56.342] - relay: TRUE
  [14:20:56.343] - stdout: TRUE
  [14:20:56.343] - signal: TRUE
  [14:20:56.343] - resignal: FALSE
  [14:20:56.344] - force: TRUE
  [14:20:56.344] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.344] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.345]  - until=6
  [14:20:56.345]  - relaying element #6
  [14:20:56.345] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.346] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.346] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:56.346]  length: 1 (resolved future 5)
  [14:20:56.347] signalConditionsASAP(numeric, pos=6) ...
  [14:20:56.347] - nx: 6
  [14:20:56.347] - relay: TRUE
  [14:20:56.348] - stdout: TRUE
  [14:20:56.348] - signal: TRUE
  [14:20:56.348] - resignal: FALSE
  [14:20:56.349] - force: TRUE
  [14:20:56.349] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.349] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.350]  - until=6
  [14:20:56.350] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.350] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.351] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:56.351]  length: 0 (resolved future 6)
  [14:20:56.351] Relaying remaining futures
  [14:20:56.352] signalConditionsASAP(NULL, pos=0) ...
  [14:20:56.352] - nx: 6
  [14:20:56.352] - relay: TRUE
  [14:20:56.353] - stdout: TRUE
  [14:20:56.353] - signal: TRUE
  [14:20:56.353] - resignal: FALSE
  [14:20:56.353] - force: TRUE
  [14:20:56.354] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.354] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:56.355] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.355] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.355] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:56.356] resolve() on list ... DONE
  [14:20:56.356] result() for ClusterFuture ...
  [14:20:56.356] - result already collected: FutureResult
  [14:20:56.357] result() for ClusterFuture ... done
  [14:20:56.357] result() for ClusterFuture ...
  [14:20:56.357] - result already collected: FutureResult
  [14:20:56.358] result() for ClusterFuture ... done
  [14:20:56.358] result() for ClusterFuture ...
  [14:20:56.359] - result already collected: FutureResult
  [14:20:56.359] result() for ClusterFuture ... done
  [14:20:56.359] result() for ClusterFuture ...
  [14:20:56.360] - result already collected: FutureResult
  [14:20:56.360] 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)
  [14:20:56.376] getGlobalsAndPackages() ...
  [14:20:56.376] Searching for globals...
  [14:20:56.377] 
  [14:20:56.377] Searching for globals ... DONE
  [14:20:56.378] - globals: [0] <none>
  [14:20:56.378] getGlobalsAndPackages() ... DONE
  [14:20:56.382] Packages needed by the future expression (n = 0): <none>
  [14:20:56.382] Packages needed by future strategies (n = 0): <none>
  [14:20:56.389] {
  [14:20:56.389]     {
  [14:20:56.389]         ...future.startTime <- base::Sys.time()
  [14:20:56.389]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.389]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.389]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.389]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.389]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.389]         {
  [14:20:56.389]             {
  [14:20:56.389]                 has_future <- base::requireNamespace("future", 
  [14:20:56.389]                   quietly = TRUE)
  [14:20:56.389]                 version <- if (has_future) 
  [14:20:56.389]                   utils::packageVersion("future")
  [14:20:56.389]                 else NULL
  [14:20:56.389]                 if (!has_future || version < "1.8.0") {
  [14:20:56.389]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.389]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.389]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.389]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.389]                       "release", "version")], collapse = " "), 
  [14:20:56.389]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.389]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.389]                     info)
  [14:20:56.389]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.389]                   if (!has_future) {
  [14:20:56.389]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.389]                       info)
  [14:20:56.389]                   }
  [14:20:56.389]                   else {
  [14:20:56.389]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.389]                       info, version)
  [14:20:56.389]                   }
  [14:20:56.389]                   base::stop(msg)
  [14:20:56.389]                 }
  [14:20:56.389]             }
  [14:20:56.389]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.389]         }
  [14:20:56.389]     }
  [14:20:56.389]     if (base::is.na(TRUE)) {
  [14:20:56.389]     }
  [14:20:56.389]     else {
  [14:20:56.389]         if (TRUE) {
  [14:20:56.389]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.389]                 open = "w")
  [14:20:56.389]         }
  [14:20:56.389]         else {
  [14:20:56.389]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.389]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.389]         }
  [14:20:56.389]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.389]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.389]             base::sink(type = "output", split = FALSE)
  [14:20:56.389]             base::close(...future.stdout)
  [14:20:56.389]         }, add = TRUE)
  [14:20:56.389]     }
  [14:20:56.389]     ...future.frame <- base::sys.nframe()
  [14:20:56.389]     ...future.conditions <- base::list()
  [14:20:56.389]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.389]     ...future.result <- base::tryCatch({
  [14:20:56.389]         base::withCallingHandlers({
  [14:20:56.389]             ...future.value <- base::withVisible(base::local({
  [14:20:56.389]                 ...future.sendCondition <- local({
  [14:20:56.389]                   sendCondition <- NULL
  [14:20:56.389]                   function(frame = 1L) {
  [14:20:56.389]                     if (is.function(sendCondition)) 
  [14:20:56.389]                       return(sendCondition)
  [14:20:56.389]                     ns <- getNamespace("parallel")
  [14:20:56.389]                     if (exists("sendData", mode = "function", 
  [14:20:56.389]                       envir = ns)) {
  [14:20:56.389]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.389]                         envir = ns)
  [14:20:56.389]                       envir <- sys.frame(frame)
  [14:20:56.389]                       master <- NULL
  [14:20:56.389]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.389]                         !identical(envir, emptyenv())) {
  [14:20:56.389]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.389]                           inherits = FALSE)) {
  [14:20:56.389]                           master <- get("master", mode = "list", 
  [14:20:56.389]                             envir = envir, inherits = FALSE)
  [14:20:56.389]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.389]                             sendCondition <<- function(cond) {
  [14:20:56.389]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.389]                                 success = TRUE)
  [14:20:56.389]                               parallel_sendData(master, data)
  [14:20:56.389]                             }
  [14:20:56.389]                             return(sendCondition)
  [14:20:56.389]                           }
  [14:20:56.389]                         }
  [14:20:56.389]                         frame <- frame + 1L
  [14:20:56.389]                         envir <- sys.frame(frame)
  [14:20:56.389]                       }
  [14:20:56.389]                     }
  [14:20:56.389]                     sendCondition <<- function(cond) NULL
  [14:20:56.389]                   }
  [14:20:56.389]                 })
  [14:20:56.389]                 withCallingHandlers({
  [14:20:56.389]                   2
  [14:20:56.389]                 }, immediateCondition = function(cond) {
  [14:20:56.389]                   sendCondition <- ...future.sendCondition()
  [14:20:56.389]                   sendCondition(cond)
  [14:20:56.389]                   muffleCondition <- function (cond) 
  [14:20:56.389]                   {
  [14:20:56.389]                     inherits <- base::inherits
  [14:20:56.389]                     invokeRestart <- base::invokeRestart
  [14:20:56.389]                     muffled <- FALSE
  [14:20:56.389]                     if (inherits(cond, "message")) {
  [14:20:56.389]                       invokeRestart("muffleMessage")
  [14:20:56.389]                       muffled <- TRUE
  [14:20:56.389]                     }
  [14:20:56.389]                     else if (inherits(cond, "warning")) {
  [14:20:56.389]                       invokeRestart("muffleWarning")
  [14:20:56.389]                       muffled <- TRUE
  [14:20:56.389]                     }
  [14:20:56.389]                     else if (inherits(cond, "condition")) {
  [14:20:56.389]                       computeRestarts <- base::computeRestarts
  [14:20:56.389]                       grepl <- base::grepl
  [14:20:56.389]                       is.null <- base::is.null
  [14:20:56.389]                       restarts <- computeRestarts(cond)
  [14:20:56.389]                       for (restart in restarts) {
  [14:20:56.389]                         name <- restart$name
  [14:20:56.389]                         if (is.null(name)) 
  [14:20:56.389]                           next
  [14:20:56.389]                         if (!grepl("^muffle", name)) 
  [14:20:56.389]                           next
  [14:20:56.389]                         invokeRestart(restart)
  [14:20:56.389]                         muffled <- TRUE
  [14:20:56.389]                         break
  [14:20:56.389]                       }
  [14:20:56.389]                     }
  [14:20:56.389]                     invisible(muffled)
  [14:20:56.389]                   }
  [14:20:56.389]                   muffleCondition(cond)
  [14:20:56.389]                 })
  [14:20:56.389]             }))
  [14:20:56.389]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.389]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.389]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.389]                 version = "1.8")
  [14:20:56.389]         }, condition = base::local({
  [14:20:56.389]             c <- base::c
  [14:20:56.389]             inherits <- base::inherits
  [14:20:56.389]             invokeRestart <- base::invokeRestart
  [14:20:56.389]             length <- base::length
  [14:20:56.389]             list <- base::list
  [14:20:56.389]             seq.int <- base::seq.int
  [14:20:56.389]             signalCondition <- base::signalCondition
  [14:20:56.389]             sys.calls <- base::sys.calls
  [14:20:56.389]             Sys.time <- base::Sys.time
  [14:20:56.389]             `[[` <- base::`[[`
  [14:20:56.389]             `+` <- base::`+`
  [14:20:56.389]             `<<-` <- base::`<<-`
  [14:20:56.389]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.389]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.389]                   3L)]
  [14:20:56.389]             }
  [14:20:56.389]             function(cond) {
  [14:20:56.389]                 if (inherits(cond, "error")) {
  [14:20:56.389]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.389]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.389]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.389]                   signalCondition(cond)
  [14:20:56.389]                 }
  [14:20:56.389]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.389]                 ))) {
  [14:20:56.389]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.389]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.389]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.389]                   if (!signal) {
  [14:20:56.389]                     muffleCondition <- function (cond) 
  [14:20:56.389]                     {
  [14:20:56.389]                       inherits <- base::inherits
  [14:20:56.389]                       invokeRestart <- base::invokeRestart
  [14:20:56.389]                       muffled <- FALSE
  [14:20:56.389]                       if (inherits(cond, "message")) {
  [14:20:56.389]                         invokeRestart("muffleMessage")
  [14:20:56.389]                         muffled <- TRUE
  [14:20:56.389]                       }
  [14:20:56.389]                       else if (inherits(cond, "warning")) {
  [14:20:56.389]                         invokeRestart("muffleWarning")
  [14:20:56.389]                         muffled <- TRUE
  [14:20:56.389]                       }
  [14:20:56.389]                       else if (inherits(cond, "condition")) {
  [14:20:56.389]                         computeRestarts <- base::computeRestarts
  [14:20:56.389]                         grepl <- base::grepl
  [14:20:56.389]                         is.null <- base::is.null
  [14:20:56.389]                         restarts <- computeRestarts(cond)
  [14:20:56.389]                         for (restart in restarts) {
  [14:20:56.389]                           name <- restart$name
  [14:20:56.389]                           if (is.null(name)) 
  [14:20:56.389]                             next
  [14:20:56.389]                           if (!grepl("^muffle", name)) 
  [14:20:56.389]                             next
  [14:20:56.389]                           invokeRestart(restart)
  [14:20:56.389]                           muffled <- TRUE
  [14:20:56.389]                           break
  [14:20:56.389]                         }
  [14:20:56.389]                       }
  [14:20:56.389]                       invisible(muffled)
  [14:20:56.389]                     }
  [14:20:56.389]                     muffleCondition(cond)
  [14:20:56.389]                   }
  [14:20:56.389]                 }
  [14:20:56.389]             }
  [14:20:56.389]         }))
  [14:20:56.389]     }, error = function(ex) {
  [14:20:56.389]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.389]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.389]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.389]     }, finally = {
  [14:20:56.389]         {
  [14:20:56.389]             NULL
  [14:20:56.389]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.389]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.389]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.389]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.389]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.389]                 ...) 
  [14:20:56.389]             {
  [14:20:56.389]                 if (substitute) 
  [14:20:56.389]                   expr <- substitute(expr)
  [14:20:56.389]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.389]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.389]                   globals = globals, persistent = persistent, 
  [14:20:56.389]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.389]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.389]                   label = label, ...)
  [14:20:56.389]                 if (!future$lazy) 
  [14:20:56.389]                   future <- run(future)
  [14:20:56.389]                 invisible(future)
  [14:20:56.389]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.389]         }
  [14:20:56.389]         base::options(...future.oldOptions)
  [14:20:56.389]     })
  [14:20:56.389]     Sys.time
  [14:20:56.389]     if (base::is.na(TRUE)) {
  [14:20:56.389]     }
  [14:20:56.389]     else {
  [14:20:56.389]         base::sink(type = "output", split = FALSE)
  [14:20:56.389]         if (TRUE) {
  [14:20:56.389]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.389]         }
  [14:20:56.389]         else {
  [14:20:56.389]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.389]         }
  [14:20:56.389]         base::close(...future.stdout)
  [14:20:56.389]         ...future.stdout <- NULL
  [14:20:56.389]     }
  [14:20:56.389]     ...future.result$conditions <- ...future.conditions
  [14:20:56.389]     ...future.result
  [14:20:56.389] }
  [14:20:56.412] ClusterFuture started
  [14:20:56.417] getGlobalsAndPackages() ...
  [14:20:56.418] Searching for globals...
  [14:20:56.419] 
  [14:20:56.419] Searching for globals ... DONE
  [14:20:56.426] - globals: [0] <none>
  [14:20:56.426] getGlobalsAndPackages() ... DONE
  [14:20:56.447] Packages needed by the future expression (n = 0): <none>
  [14:20:56.447] Packages needed by future strategies (n = 0): <none>
  [14:20:56.453] {
  [14:20:56.453]     {
  [14:20:56.453]         ...future.startTime <- base::Sys.time()
  [14:20:56.453]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.453]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.453]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.453]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.453]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.453]         {
  [14:20:56.453]             {
  [14:20:56.453]                 has_future <- base::requireNamespace("future", 
  [14:20:56.453]                   quietly = TRUE)
  [14:20:56.453]                 version <- if (has_future) 
  [14:20:56.453]                   utils::packageVersion("future")
  [14:20:56.453]                 else NULL
  [14:20:56.453]                 if (!has_future || version < "1.8.0") {
  [14:20:56.453]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.453]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.453]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.453]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.453]                       "release", "version")], collapse = " "), 
  [14:20:56.453]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.453]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.453]                     info)
  [14:20:56.453]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.453]                   if (!has_future) {
  [14:20:56.453]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.453]                       info)
  [14:20:56.453]                   }
  [14:20:56.453]                   else {
  [14:20:56.453]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.453]                       info, version)
  [14:20:56.453]                   }
  [14:20:56.453]                   base::stop(msg)
  [14:20:56.453]                 }
  [14:20:56.453]             }
  [14:20:56.453]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.453]         }
  [14:20:56.453]     }
  [14:20:56.453]     if (base::is.na(TRUE)) {
  [14:20:56.453]     }
  [14:20:56.453]     else {
  [14:20:56.453]         if (TRUE) {
  [14:20:56.453]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.453]                 open = "w")
  [14:20:56.453]         }
  [14:20:56.453]         else {
  [14:20:56.453]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.453]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.453]         }
  [14:20:56.453]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.453]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.453]             base::sink(type = "output", split = FALSE)
  [14:20:56.453]             base::close(...future.stdout)
  [14:20:56.453]         }, add = TRUE)
  [14:20:56.453]     }
  [14:20:56.453]     ...future.frame <- base::sys.nframe()
  [14:20:56.453]     ...future.conditions <- base::list()
  [14:20:56.453]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.453]     ...future.result <- base::tryCatch({
  [14:20:56.453]         base::withCallingHandlers({
  [14:20:56.453]             ...future.value <- base::withVisible(base::local({
  [14:20:56.453]                 ...future.sendCondition <- local({
  [14:20:56.453]                   sendCondition <- NULL
  [14:20:56.453]                   function(frame = 1L) {
  [14:20:56.453]                     if (is.function(sendCondition)) 
  [14:20:56.453]                       return(sendCondition)
  [14:20:56.453]                     ns <- getNamespace("parallel")
  [14:20:56.453]                     if (exists("sendData", mode = "function", 
  [14:20:56.453]                       envir = ns)) {
  [14:20:56.453]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.453]                         envir = ns)
  [14:20:56.453]                       envir <- sys.frame(frame)
  [14:20:56.453]                       master <- NULL
  [14:20:56.453]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.453]                         !identical(envir, emptyenv())) {
  [14:20:56.453]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.453]                           inherits = FALSE)) {
  [14:20:56.453]                           master <- get("master", mode = "list", 
  [14:20:56.453]                             envir = envir, inherits = FALSE)
  [14:20:56.453]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.453]                             sendCondition <<- function(cond) {
  [14:20:56.453]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.453]                                 success = TRUE)
  [14:20:56.453]                               parallel_sendData(master, data)
  [14:20:56.453]                             }
  [14:20:56.453]                             return(sendCondition)
  [14:20:56.453]                           }
  [14:20:56.453]                         }
  [14:20:56.453]                         frame <- frame + 1L
  [14:20:56.453]                         envir <- sys.frame(frame)
  [14:20:56.453]                       }
  [14:20:56.453]                     }
  [14:20:56.453]                     sendCondition <<- function(cond) NULL
  [14:20:56.453]                   }
  [14:20:56.453]                 })
  [14:20:56.453]                 withCallingHandlers({
  [14:20:56.453]                   NULL
  [14:20:56.453]                 }, immediateCondition = function(cond) {
  [14:20:56.453]                   sendCondition <- ...future.sendCondition()
  [14:20:56.453]                   sendCondition(cond)
  [14:20:56.453]                   muffleCondition <- function (cond) 
  [14:20:56.453]                   {
  [14:20:56.453]                     inherits <- base::inherits
  [14:20:56.453]                     invokeRestart <- base::invokeRestart
  [14:20:56.453]                     muffled <- FALSE
  [14:20:56.453]                     if (inherits(cond, "message")) {
  [14:20:56.453]                       invokeRestart("muffleMessage")
  [14:20:56.453]                       muffled <- TRUE
  [14:20:56.453]                     }
  [14:20:56.453]                     else if (inherits(cond, "warning")) {
  [14:20:56.453]                       invokeRestart("muffleWarning")
  [14:20:56.453]                       muffled <- TRUE
  [14:20:56.453]                     }
  [14:20:56.453]                     else if (inherits(cond, "condition")) {
  [14:20:56.453]                       computeRestarts <- base::computeRestarts
  [14:20:56.453]                       grepl <- base::grepl
  [14:20:56.453]                       is.null <- base::is.null
  [14:20:56.453]                       restarts <- computeRestarts(cond)
  [14:20:56.453]                       for (restart in restarts) {
  [14:20:56.453]                         name <- restart$name
  [14:20:56.453]                         if (is.null(name)) 
  [14:20:56.453]                           next
  [14:20:56.453]                         if (!grepl("^muffle", name)) 
  [14:20:56.453]                           next
  [14:20:56.453]                         invokeRestart(restart)
  [14:20:56.453]                         muffled <- TRUE
  [14:20:56.453]                         break
  [14:20:56.453]                       }
  [14:20:56.453]                     }
  [14:20:56.453]                     invisible(muffled)
  [14:20:56.453]                   }
  [14:20:56.453]                   muffleCondition(cond)
  [14:20:56.453]                 })
  [14:20:56.453]             }))
  [14:20:56.453]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.453]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.453]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.453]                 version = "1.8")
  [14:20:56.453]         }, condition = base::local({
  [14:20:56.453]             c <- base::c
  [14:20:56.453]             inherits <- base::inherits
  [14:20:56.453]             invokeRestart <- base::invokeRestart
  [14:20:56.453]             length <- base::length
  [14:20:56.453]             list <- base::list
  [14:20:56.453]             seq.int <- base::seq.int
  [14:20:56.453]             signalCondition <- base::signalCondition
  [14:20:56.453]             sys.calls <- base::sys.calls
  [14:20:56.453]             Sys.time <- base::Sys.time
  [14:20:56.453]             `[[` <- base::`[[`
  [14:20:56.453]             `+` <- base::`+`
  [14:20:56.453]             `<<-` <- base::`<<-`
  [14:20:56.453]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.453]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.453]                   3L)]
  [14:20:56.453]             }
  [14:20:56.453]             function(cond) {
  [14:20:56.453]                 if (inherits(cond, "error")) {
  [14:20:56.453]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.453]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.453]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.453]                   signalCondition(cond)
  [14:20:56.453]                 }
  [14:20:56.453]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.453]                 ))) {
  [14:20:56.453]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.453]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.453]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.453]                   if (!signal) {
  [14:20:56.453]                     muffleCondition <- function (cond) 
  [14:20:56.453]                     {
  [14:20:56.453]                       inherits <- base::inherits
  [14:20:56.453]                       invokeRestart <- base::invokeRestart
  [14:20:56.453]                       muffled <- FALSE
  [14:20:56.453]                       if (inherits(cond, "message")) {
  [14:20:56.453]                         invokeRestart("muffleMessage")
  [14:20:56.453]                         muffled <- TRUE
  [14:20:56.453]                       }
  [14:20:56.453]                       else if (inherits(cond, "warning")) {
  [14:20:56.453]                         invokeRestart("muffleWarning")
  [14:20:56.453]                         muffled <- TRUE
  [14:20:56.453]                       }
  [14:20:56.453]                       else if (inherits(cond, "condition")) {
  [14:20:56.453]                         computeRestarts <- base::computeRestarts
  [14:20:56.453]                         grepl <- base::grepl
  [14:20:56.453]                         is.null <- base::is.null
  [14:20:56.453]                         restarts <- computeRestarts(cond)
  [14:20:56.453]                         for (restart in restarts) {
  [14:20:56.453]                           name <- restart$name
  [14:20:56.453]                           if (is.null(name)) 
  [14:20:56.453]                             next
  [14:20:56.453]                           if (!grepl("^muffle", name)) 
  [14:20:56.453]                             next
  [14:20:56.453]                           invokeRestart(restart)
  [14:20:56.453]                           muffled <- TRUE
  [14:20:56.453]                           break
  [14:20:56.453]                         }
  [14:20:56.453]                       }
  [14:20:56.453]                       invisible(muffled)
  [14:20:56.453]                     }
  [14:20:56.453]                     muffleCondition(cond)
  [14:20:56.453]                   }
  [14:20:56.453]                 }
  [14:20:56.453]             }
  [14:20:56.453]         }))
  [14:20:56.453]     }, error = function(ex) {
  [14:20:56.453]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.453]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.453]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.453]     }, finally = {
  [14:20:56.453]         {
  [14:20:56.453]             NULL
  [14:20:56.453]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.453]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.453]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.453]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.453]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.453]                 ...) 
  [14:20:56.453]             {
  [14:20:56.453]                 if (substitute) 
  [14:20:56.453]                   expr <- substitute(expr)
  [14:20:56.453]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.453]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.453]                   globals = globals, persistent = persistent, 
  [14:20:56.453]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.453]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.453]                   label = label, ...)
  [14:20:56.453]                 if (!future$lazy) 
  [14:20:56.453]                   future <- run(future)
  [14:20:56.453]                 invisible(future)
  [14:20:56.453]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.453]         }
  [14:20:56.453]         base::options(...future.oldOptions)
  [14:20:56.453]     })
  [14:20:56.453]     Sys.time
  [14:20:56.453]     if (base::is.na(TRUE)) {
  [14:20:56.453]     }
  [14:20:56.453]     else {
  [14:20:56.453]         base::sink(type = "output", split = FALSE)
  [14:20:56.453]         if (TRUE) {
  [14:20:56.453]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.453]         }
  [14:20:56.453]         else {
  [14:20:56.453]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.453]         }
  [14:20:56.453]         base::close(...future.stdout)
  [14:20:56.453]         ...future.stdout <- NULL
  [14:20:56.453]     }
  [14:20:56.453]     ...future.result$conditions <- ...future.conditions
  [14:20:56.453]     ...future.result
  [14:20:56.453] }
  [14:20:56.476] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:20:56.488] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.488] - Validating connection of ClusterFuture
  [14:20:56.489] - received message: FutureResult
  [14:20:56.489] - Received FutureResult
  [14:20:56.490] - Erased future from FutureRegistry
  [14:20:56.490] result() for ClusterFuture ...
  [14:20:56.490] - result already collected: FutureResult
  [14:20:56.491] result() for ClusterFuture ... done
  [14:20:56.491] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:56.492] result() for ClusterFuture ...
  [14:20:56.492] - result already collected: FutureResult
  [14:20:56.492] result() for ClusterFuture ... done
  [14:20:56.493] result() for ClusterFuture ...
  [14:20:56.493] - result already collected: FutureResult
  [14:20:56.493] result() for ClusterFuture ... done
  [14:20:56.496] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa445df8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f9521bc0> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa445df8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f9521bc0> 
   $  : 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"
  [14:20:56.543] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.543] - Validating connection of ClusterFuture
  [14:20:56.544] - received message: FutureResult
  [14:20:56.544] - Received FutureResult
  [14:20:56.544] - Erased future from FutureRegistry
  [14:20:56.545] result() for ClusterFuture ...
  [14:20:56.545] - result already collected: FutureResult
  [14:20:56.546] result() for ClusterFuture ... done
  [14:20:56.546] 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" "" ...
  [14:20:56.551] resolve() on list ...
  [14:20:56.551]  recursive: 0
  [14:20:56.551]  length: 6
  [14:20:56.552]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:56.552] signalConditionsASAP(numeric, pos=1) ...
  [14:20:56.552] - nx: 6
  [14:20:56.553] - relay: TRUE
  [14:20:56.553] - stdout: TRUE
  [14:20:56.553] - signal: TRUE
  [14:20:56.554] - resignal: FALSE
  [14:20:56.554] - force: TRUE
  [14:20:56.554] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.555] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.555]  - until=2
  [14:20:56.555]  - relaying element #2
  [14:20:56.556] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.556] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.556] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:56.557]  length: 5 (resolved future 1)
  [14:20:56.557] Future #2
  [14:20:56.557] result() for ClusterFuture ...
  [14:20:56.558] - result already collected: FutureResult
  [14:20:56.558] result() for ClusterFuture ... done
  [14:20:56.558] result() for ClusterFuture ...
  [14:20:56.559] - result already collected: FutureResult
  [14:20:56.559] result() for ClusterFuture ... done
  [14:20:56.559] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:20:56.560] - nx: 6
  [14:20:56.560] - relay: TRUE
  [14:20:56.560] - stdout: TRUE
  [14:20:56.561] - signal: TRUE
  [14:20:56.561] - resignal: FALSE
  [14:20:56.561] - force: TRUE
  [14:20:56.561] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.562] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.562]  - until=2
  [14:20:56.562]  - relaying element #2
  [14:20:56.563] result() for ClusterFuture ...
  [14:20:56.563] - result already collected: FutureResult
  [14:20:56.563] result() for ClusterFuture ... done
  [14:20:56.564] result() for ClusterFuture ...
  [14:20:56.564] - result already collected: FutureResult
  [14:20:56.564] result() for ClusterFuture ... done
  [14:20:56.565] result() for ClusterFuture ...
  [14:20:56.565] - result already collected: FutureResult
  [14:20:56.566] result() for ClusterFuture ... done
  [14:20:56.566] result() for ClusterFuture ...
  [14:20:56.566] - result already collected: FutureResult
  [14:20:56.567] result() for ClusterFuture ... done
  [14:20:56.567] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.567] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.567] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:20:56.568]  length: 4 (resolved future 2)
  [14:20:56.568] Future #3
  [14:20:56.575] result() for ClusterFuture ...
  [14:20:56.576] - result already collected: FutureResult
  [14:20:56.576] result() for ClusterFuture ... done
  [14:20:56.576] result() for ClusterFuture ...
  [14:20:56.577] - result already collected: FutureResult
  [14:20:56.577] result() for ClusterFuture ... done
  [14:20:56.577] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:20:56.578] - nx: 6
  [14:20:56.578] - relay: TRUE
  [14:20:56.578] - stdout: TRUE
  [14:20:56.579] - signal: TRUE
  [14:20:56.579] - resignal: FALSE
  [14:20:56.579] - force: TRUE
  [14:20:56.580] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.580] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.580]  - until=3
  [14:20:56.581]  - relaying element #3
  [14:20:56.581] result() for ClusterFuture ...
  [14:20:56.581] - result already collected: FutureResult
  [14:20:56.581] result() for ClusterFuture ... done
  [14:20:56.582] result() for ClusterFuture ...
  [14:20:56.582] - result already collected: FutureResult
  [14:20:56.583] result() for ClusterFuture ... done
  [14:20:56.583] result() for ClusterFuture ...
  [14:20:56.583] - result already collected: FutureResult
  [14:20:56.584] result() for ClusterFuture ... done
  [14:20:56.584] result() for ClusterFuture ...
  [14:20:56.584] - result already collected: FutureResult
  [14:20:56.584] result() for ClusterFuture ... done
  [14:20:56.585] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.585] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.585] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:20:56.586]  length: 3 (resolved future 3)
  [14:20:56.586] signalConditionsASAP(NULL, pos=4) ...
  [14:20:56.586] - nx: 6
  [14:20:56.587] - relay: TRUE
  [14:20:56.587] - stdout: TRUE
  [14:20:56.587] - signal: TRUE
  [14:20:56.587] - resignal: FALSE
  [14:20:56.588] - force: TRUE
  [14:20:56.588] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.588] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.589]  - until=5
  [14:20:56.589]  - relaying element #5
  [14:20:56.589] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.590] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.590] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:56.590]  length: 2 (resolved future 4)
  [14:20:56.591] signalConditionsASAP(NULL, pos=5) ...
  [14:20:56.591] - nx: 6
  [14:20:56.591] - relay: TRUE
  [14:20:56.591] - stdout: TRUE
  [14:20:56.592] - signal: TRUE
  [14:20:56.592] - resignal: FALSE
  [14:20:56.592] - force: TRUE
  [14:20:56.593] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.593] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.593]  - until=6
  [14:20:56.593]  - relaying element #6
  [14:20:56.594] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.594] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.594] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:56.595]  length: 1 (resolved future 5)
  [14:20:56.595] signalConditionsASAP(numeric, pos=6) ...
  [14:20:56.595] - nx: 6
  [14:20:56.596] - relay: TRUE
  [14:20:56.596] - stdout: TRUE
  [14:20:56.596] - signal: TRUE
  [14:20:56.596] - resignal: FALSE
  [14:20:56.597] - force: TRUE
  [14:20:56.597] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.597] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.598]  - until=6
  [14:20:56.598] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.598] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.598] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:56.599]  length: 0 (resolved future 6)
  [14:20:56.599] Relaying remaining futures
  [14:20:56.599] signalConditionsASAP(NULL, pos=0) ...
  [14:20:56.600] - nx: 6
  [14:20:56.600] - relay: TRUE
  [14:20:56.600] - stdout: TRUE
  [14:20:56.601] - signal: TRUE
  [14:20:56.601] - resignal: FALSE
  [14:20:56.601] - force: TRUE
  [14:20:56.601] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.602] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:56.602] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.603] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.603] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:56.603] resolve() on list ... DONE
  [14:20:56.604] result() for ClusterFuture ...
  [14:20:56.604] - result already collected: FutureResult
  [14:20:56.604] result() for ClusterFuture ... done
  [14:20:56.605] result() for ClusterFuture ...
  [14:20:56.605] - result already collected: FutureResult
  [14:20:56.605] result() for ClusterFuture ... done
  [14:20:56.606] result() for ClusterFuture ...
  [14:20:56.606] - result already collected: FutureResult
  [14:20:56.606] result() for ClusterFuture ... done
  [14:20:56.607] result() for ClusterFuture ...
  [14:20:56.607] - result already collected: FutureResult
  [14:20:56.607] 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)
  [14:20:56.623] getGlobalsAndPackages() ...
  [14:20:56.624] Searching for globals...
  [14:20:56.625] 
  [14:20:56.625] Searching for globals ... DONE
  [14:20:56.626] - globals: [0] <none>
  [14:20:56.626] getGlobalsAndPackages() ... DONE
  [14:20:56.630] Packages needed by the future expression (n = 0): <none>
  [14:20:56.631] Packages needed by future strategies (n = 0): <none>
  [14:20:56.653] {
  [14:20:56.653]     {
  [14:20:56.653]         ...future.startTime <- base::Sys.time()
  [14:20:56.653]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.653]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.653]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.653]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.653]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.653]         {
  [14:20:56.653]             {
  [14:20:56.653]                 has_future <- base::requireNamespace("future", 
  [14:20:56.653]                   quietly = TRUE)
  [14:20:56.653]                 version <- if (has_future) 
  [14:20:56.653]                   utils::packageVersion("future")
  [14:20:56.653]                 else NULL
  [14:20:56.653]                 if (!has_future || version < "1.8.0") {
  [14:20:56.653]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.653]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.653]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.653]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.653]                       "release", "version")], collapse = " "), 
  [14:20:56.653]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.653]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.653]                     info)
  [14:20:56.653]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.653]                   if (!has_future) {
  [14:20:56.653]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.653]                       info)
  [14:20:56.653]                   }
  [14:20:56.653]                   else {
  [14:20:56.653]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.653]                       info, version)
  [14:20:56.653]                   }
  [14:20:56.653]                   base::stop(msg)
  [14:20:56.653]                 }
  [14:20:56.653]             }
  [14:20:56.653]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.653]         }
  [14:20:56.653]     }
  [14:20:56.653]     if (base::is.na(TRUE)) {
  [14:20:56.653]     }
  [14:20:56.653]     else {
  [14:20:56.653]         if (TRUE) {
  [14:20:56.653]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.653]                 open = "w")
  [14:20:56.653]         }
  [14:20:56.653]         else {
  [14:20:56.653]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.653]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.653]         }
  [14:20:56.653]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.653]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.653]             base::sink(type = "output", split = FALSE)
  [14:20:56.653]             base::close(...future.stdout)
  [14:20:56.653]         }, add = TRUE)
  [14:20:56.653]     }
  [14:20:56.653]     ...future.frame <- base::sys.nframe()
  [14:20:56.653]     ...future.conditions <- base::list()
  [14:20:56.653]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.653]     ...future.result <- base::tryCatch({
  [14:20:56.653]         base::withCallingHandlers({
  [14:20:56.653]             ...future.value <- base::withVisible(base::local({
  [14:20:56.653]                 ...future.sendCondition <- local({
  [14:20:56.653]                   sendCondition <- NULL
  [14:20:56.653]                   function(frame = 1L) {
  [14:20:56.653]                     if (is.function(sendCondition)) 
  [14:20:56.653]                       return(sendCondition)
  [14:20:56.653]                     ns <- getNamespace("parallel")
  [14:20:56.653]                     if (exists("sendData", mode = "function", 
  [14:20:56.653]                       envir = ns)) {
  [14:20:56.653]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.653]                         envir = ns)
  [14:20:56.653]                       envir <- sys.frame(frame)
  [14:20:56.653]                       master <- NULL
  [14:20:56.653]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.653]                         !identical(envir, emptyenv())) {
  [14:20:56.653]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.653]                           inherits = FALSE)) {
  [14:20:56.653]                           master <- get("master", mode = "list", 
  [14:20:56.653]                             envir = envir, inherits = FALSE)
  [14:20:56.653]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.653]                             sendCondition <<- function(cond) {
  [14:20:56.653]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.653]                                 success = TRUE)
  [14:20:56.653]                               parallel_sendData(master, data)
  [14:20:56.653]                             }
  [14:20:56.653]                             return(sendCondition)
  [14:20:56.653]                           }
  [14:20:56.653]                         }
  [14:20:56.653]                         frame <- frame + 1L
  [14:20:56.653]                         envir <- sys.frame(frame)
  [14:20:56.653]                       }
  [14:20:56.653]                     }
  [14:20:56.653]                     sendCondition <<- function(cond) NULL
  [14:20:56.653]                   }
  [14:20:56.653]                 })
  [14:20:56.653]                 withCallingHandlers({
  [14:20:56.653]                   2
  [14:20:56.653]                 }, immediateCondition = function(cond) {
  [14:20:56.653]                   sendCondition <- ...future.sendCondition()
  [14:20:56.653]                   sendCondition(cond)
  [14:20:56.653]                   muffleCondition <- function (cond) 
  [14:20:56.653]                   {
  [14:20:56.653]                     inherits <- base::inherits
  [14:20:56.653]                     invokeRestart <- base::invokeRestart
  [14:20:56.653]                     muffled <- FALSE
  [14:20:56.653]                     if (inherits(cond, "message")) {
  [14:20:56.653]                       invokeRestart("muffleMessage")
  [14:20:56.653]                       muffled <- TRUE
  [14:20:56.653]                     }
  [14:20:56.653]                     else if (inherits(cond, "warning")) {
  [14:20:56.653]                       invokeRestart("muffleWarning")
  [14:20:56.653]                       muffled <- TRUE
  [14:20:56.653]                     }
  [14:20:56.653]                     else if (inherits(cond, "condition")) {
  [14:20:56.653]                       computeRestarts <- base::computeRestarts
  [14:20:56.653]                       grepl <- base::grepl
  [14:20:56.653]                       is.null <- base::is.null
  [14:20:56.653]                       restarts <- computeRestarts(cond)
  [14:20:56.653]                       for (restart in restarts) {
  [14:20:56.653]                         name <- restart$name
  [14:20:56.653]                         if (is.null(name)) 
  [14:20:56.653]                           next
  [14:20:56.653]                         if (!grepl("^muffle", name)) 
  [14:20:56.653]                           next
  [14:20:56.653]                         invokeRestart(restart)
  [14:20:56.653]                         muffled <- TRUE
  [14:20:56.653]                         break
  [14:20:56.653]                       }
  [14:20:56.653]                     }
  [14:20:56.653]                     invisible(muffled)
  [14:20:56.653]                   }
  [14:20:56.653]                   muffleCondition(cond)
  [14:20:56.653]                 })
  [14:20:56.653]             }))
  [14:20:56.653]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.653]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.653]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.653]                 version = "1.8")
  [14:20:56.653]         }, condition = base::local({
  [14:20:56.653]             c <- base::c
  [14:20:56.653]             inherits <- base::inherits
  [14:20:56.653]             invokeRestart <- base::invokeRestart
  [14:20:56.653]             length <- base::length
  [14:20:56.653]             list <- base::list
  [14:20:56.653]             seq.int <- base::seq.int
  [14:20:56.653]             signalCondition <- base::signalCondition
  [14:20:56.653]             sys.calls <- base::sys.calls
  [14:20:56.653]             Sys.time <- base::Sys.time
  [14:20:56.653]             `[[` <- base::`[[`
  [14:20:56.653]             `+` <- base::`+`
  [14:20:56.653]             `<<-` <- base::`<<-`
  [14:20:56.653]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.653]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.653]                   3L)]
  [14:20:56.653]             }
  [14:20:56.653]             function(cond) {
  [14:20:56.653]                 if (inherits(cond, "error")) {
  [14:20:56.653]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.653]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.653]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.653]                   signalCondition(cond)
  [14:20:56.653]                 }
  [14:20:56.653]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.653]                 ))) {
  [14:20:56.653]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.653]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.653]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.653]                   if (!signal) {
  [14:20:56.653]                     muffleCondition <- function (cond) 
  [14:20:56.653]                     {
  [14:20:56.653]                       inherits <- base::inherits
  [14:20:56.653]                       invokeRestart <- base::invokeRestart
  [14:20:56.653]                       muffled <- FALSE
  [14:20:56.653]                       if (inherits(cond, "message")) {
  [14:20:56.653]                         invokeRestart("muffleMessage")
  [14:20:56.653]                         muffled <- TRUE
  [14:20:56.653]                       }
  [14:20:56.653]                       else if (inherits(cond, "warning")) {
  [14:20:56.653]                         invokeRestart("muffleWarning")
  [14:20:56.653]                         muffled <- TRUE
  [14:20:56.653]                       }
  [14:20:56.653]                       else if (inherits(cond, "condition")) {
  [14:20:56.653]                         computeRestarts <- base::computeRestarts
  [14:20:56.653]                         grepl <- base::grepl
  [14:20:56.653]                         is.null <- base::is.null
  [14:20:56.653]                         restarts <- computeRestarts(cond)
  [14:20:56.653]                         for (restart in restarts) {
  [14:20:56.653]                           name <- restart$name
  [14:20:56.653]                           if (is.null(name)) 
  [14:20:56.653]                             next
  [14:20:56.653]                           if (!grepl("^muffle", name)) 
  [14:20:56.653]                             next
  [14:20:56.653]                           invokeRestart(restart)
  [14:20:56.653]                           muffled <- TRUE
  [14:20:56.653]                           break
  [14:20:56.653]                         }
  [14:20:56.653]                       }
  [14:20:56.653]                       invisible(muffled)
  [14:20:56.653]                     }
  [14:20:56.653]                     muffleCondition(cond)
  [14:20:56.653]                   }
  [14:20:56.653]                 }
  [14:20:56.653]             }
  [14:20:56.653]         }))
  [14:20:56.653]     }, error = function(ex) {
  [14:20:56.653]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.653]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.653]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.653]     }, finally = {
  [14:20:56.653]         {
  [14:20:56.653]             NULL
  [14:20:56.653]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.653]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.653]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.653]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.653]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.653]                 ...) 
  [14:20:56.653]             {
  [14:20:56.653]                 if (substitute) 
  [14:20:56.653]                   expr <- substitute(expr)
  [14:20:56.653]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.653]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.653]                   globals = globals, persistent = persistent, 
  [14:20:56.653]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.653]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.653]                   label = label, ...)
  [14:20:56.653]                 if (!future$lazy) 
  [14:20:56.653]                   future <- run(future)
  [14:20:56.653]                 invisible(future)
  [14:20:56.653]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.653]         }
  [14:20:56.653]         base::options(...future.oldOptions)
  [14:20:56.653]     })
  [14:20:56.653]     Sys.time
  [14:20:56.653]     if (base::is.na(TRUE)) {
  [14:20:56.653]     }
  [14:20:56.653]     else {
  [14:20:56.653]         base::sink(type = "output", split = FALSE)
  [14:20:56.653]         if (TRUE) {
  [14:20:56.653]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.653]         }
  [14:20:56.653]         else {
  [14:20:56.653]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.653]         }
  [14:20:56.653]         base::close(...future.stdout)
  [14:20:56.653]         ...future.stdout <- NULL
  [14:20:56.653]     }
  [14:20:56.653]     ...future.result$conditions <- ...future.conditions
  [14:20:56.653]     ...future.result
  [14:20:56.653] }
  [14:20:56.661] ClusterFuture started
  [14:20:56.667] getGlobalsAndPackages() ...
  [14:20:56.668] Searching for globals...
  [14:20:56.668] 
  [14:20:56.669] Searching for globals ... DONE
  [14:20:56.669] - globals: [0] <none>
  [14:20:56.670] getGlobalsAndPackages() ... DONE
  [14:20:56.697] Packages needed by the future expression (n = 0): <none>
  [14:20:56.697] Packages needed by future strategies (n = 0): <none>
  [14:20:56.723] {
  [14:20:56.723]     {
  [14:20:56.723]         ...future.startTime <- base::Sys.time()
  [14:20:56.723]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.723]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.723]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.723]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.723]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.723]         {
  [14:20:56.723]             {
  [14:20:56.723]                 has_future <- base::requireNamespace("future", 
  [14:20:56.723]                   quietly = TRUE)
  [14:20:56.723]                 version <- if (has_future) 
  [14:20:56.723]                   utils::packageVersion("future")
  [14:20:56.723]                 else NULL
  [14:20:56.723]                 if (!has_future || version < "1.8.0") {
  [14:20:56.723]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.723]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.723]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.723]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.723]                       "release", "version")], collapse = " "), 
  [14:20:56.723]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.723]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.723]                     info)
  [14:20:56.723]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.723]                   if (!has_future) {
  [14:20:56.723]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.723]                       info)
  [14:20:56.723]                   }
  [14:20:56.723]                   else {
  [14:20:56.723]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.723]                       info, version)
  [14:20:56.723]                   }
  [14:20:56.723]                   base::stop(msg)
  [14:20:56.723]                 }
  [14:20:56.723]             }
  [14:20:56.723]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.723]         }
  [14:20:56.723]     }
  [14:20:56.723]     if (base::is.na(TRUE)) {
  [14:20:56.723]     }
  [14:20:56.723]     else {
  [14:20:56.723]         if (TRUE) {
  [14:20:56.723]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.723]                 open = "w")
  [14:20:56.723]         }
  [14:20:56.723]         else {
  [14:20:56.723]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.723]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.723]         }
  [14:20:56.723]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.723]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.723]             base::sink(type = "output", split = FALSE)
  [14:20:56.723]             base::close(...future.stdout)
  [14:20:56.723]         }, add = TRUE)
  [14:20:56.723]     }
  [14:20:56.723]     ...future.frame <- base::sys.nframe()
  [14:20:56.723]     ...future.conditions <- base::list()
  [14:20:56.723]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.723]     ...future.result <- base::tryCatch({
  [14:20:56.723]         base::withCallingHandlers({
  [14:20:56.723]             ...future.value <- base::withVisible(base::local({
  [14:20:56.723]                 ...future.sendCondition <- local({
  [14:20:56.723]                   sendCondition <- NULL
  [14:20:56.723]                   function(frame = 1L) {
  [14:20:56.723]                     if (is.function(sendCondition)) 
  [14:20:56.723]                       return(sendCondition)
  [14:20:56.723]                     ns <- getNamespace("parallel")
  [14:20:56.723]                     if (exists("sendData", mode = "function", 
  [14:20:56.723]                       envir = ns)) {
  [14:20:56.723]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.723]                         envir = ns)
  [14:20:56.723]                       envir <- sys.frame(frame)
  [14:20:56.723]                       master <- NULL
  [14:20:56.723]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.723]                         !identical(envir, emptyenv())) {
  [14:20:56.723]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.723]                           inherits = FALSE)) {
  [14:20:56.723]                           master <- get("master", mode = "list", 
  [14:20:56.723]                             envir = envir, inherits = FALSE)
  [14:20:56.723]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.723]                             sendCondition <<- function(cond) {
  [14:20:56.723]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.723]                                 success = TRUE)
  [14:20:56.723]                               parallel_sendData(master, data)
  [14:20:56.723]                             }
  [14:20:56.723]                             return(sendCondition)
  [14:20:56.723]                           }
  [14:20:56.723]                         }
  [14:20:56.723]                         frame <- frame + 1L
  [14:20:56.723]                         envir <- sys.frame(frame)
  [14:20:56.723]                       }
  [14:20:56.723]                     }
  [14:20:56.723]                     sendCondition <<- function(cond) NULL
  [14:20:56.723]                   }
  [14:20:56.723]                 })
  [14:20:56.723]                 withCallingHandlers({
  [14:20:56.723]                   NULL
  [14:20:56.723]                 }, immediateCondition = function(cond) {
  [14:20:56.723]                   sendCondition <- ...future.sendCondition()
  [14:20:56.723]                   sendCondition(cond)
  [14:20:56.723]                   muffleCondition <- function (cond) 
  [14:20:56.723]                   {
  [14:20:56.723]                     inherits <- base::inherits
  [14:20:56.723]                     invokeRestart <- base::invokeRestart
  [14:20:56.723]                     muffled <- FALSE
  [14:20:56.723]                     if (inherits(cond, "message")) {
  [14:20:56.723]                       invokeRestart("muffleMessage")
  [14:20:56.723]                       muffled <- TRUE
  [14:20:56.723]                     }
  [14:20:56.723]                     else if (inherits(cond, "warning")) {
  [14:20:56.723]                       invokeRestart("muffleWarning")
  [14:20:56.723]                       muffled <- TRUE
  [14:20:56.723]                     }
  [14:20:56.723]                     else if (inherits(cond, "condition")) {
  [14:20:56.723]                       computeRestarts <- base::computeRestarts
  [14:20:56.723]                       grepl <- base::grepl
  [14:20:56.723]                       is.null <- base::is.null
  [14:20:56.723]                       restarts <- computeRestarts(cond)
  [14:20:56.723]                       for (restart in restarts) {
  [14:20:56.723]                         name <- restart$name
  [14:20:56.723]                         if (is.null(name)) 
  [14:20:56.723]                           next
  [14:20:56.723]                         if (!grepl("^muffle", name)) 
  [14:20:56.723]                           next
  [14:20:56.723]                         invokeRestart(restart)
  [14:20:56.723]                         muffled <- TRUE
  [14:20:56.723]                         break
  [14:20:56.723]                       }
  [14:20:56.723]                     }
  [14:20:56.723]                     invisible(muffled)
  [14:20:56.723]                   }
  [14:20:56.723]                   muffleCondition(cond)
  [14:20:56.723]                 })
  [14:20:56.723]             }))
  [14:20:56.723]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.723]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.723]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.723]                 version = "1.8")
  [14:20:56.723]         }, condition = base::local({
  [14:20:56.723]             c <- base::c
  [14:20:56.723]             inherits <- base::inherits
  [14:20:56.723]             invokeRestart <- base::invokeRestart
  [14:20:56.723]             length <- base::length
  [14:20:56.723]             list <- base::list
  [14:20:56.723]             seq.int <- base::seq.int
  [14:20:56.723]             signalCondition <- base::signalCondition
  [14:20:56.723]             sys.calls <- base::sys.calls
  [14:20:56.723]             Sys.time <- base::Sys.time
  [14:20:56.723]             `[[` <- base::`[[`
  [14:20:56.723]             `+` <- base::`+`
  [14:20:56.723]             `<<-` <- base::`<<-`
  [14:20:56.723]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.723]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.723]                   3L)]
  [14:20:56.723]             }
  [14:20:56.723]             function(cond) {
  [14:20:56.723]                 if (inherits(cond, "error")) {
  [14:20:56.723]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.723]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.723]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.723]                   signalCondition(cond)
  [14:20:56.723]                 }
  [14:20:56.723]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.723]                 ))) {
  [14:20:56.723]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.723]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.723]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.723]                   if (!signal) {
  [14:20:56.723]                     muffleCondition <- function (cond) 
  [14:20:56.723]                     {
  [14:20:56.723]                       inherits <- base::inherits
  [14:20:56.723]                       invokeRestart <- base::invokeRestart
  [14:20:56.723]                       muffled <- FALSE
  [14:20:56.723]                       if (inherits(cond, "message")) {
  [14:20:56.723]                         invokeRestart("muffleMessage")
  [14:20:56.723]                         muffled <- TRUE
  [14:20:56.723]                       }
  [14:20:56.723]                       else if (inherits(cond, "warning")) {
  [14:20:56.723]                         invokeRestart("muffleWarning")
  [14:20:56.723]                         muffled <- TRUE
  [14:20:56.723]                       }
  [14:20:56.723]                       else if (inherits(cond, "condition")) {
  [14:20:56.723]                         computeRestarts <- base::computeRestarts
  [14:20:56.723]                         grepl <- base::grepl
  [14:20:56.723]                         is.null <- base::is.null
  [14:20:56.723]                         restarts <- computeRestarts(cond)
  [14:20:56.723]                         for (restart in restarts) {
  [14:20:56.723]                           name <- restart$name
  [14:20:56.723]                           if (is.null(name)) 
  [14:20:56.723]                             next
  [14:20:56.723]                           if (!grepl("^muffle", name)) 
  [14:20:56.723]                             next
  [14:20:56.723]                           invokeRestart(restart)
  [14:20:56.723]                           muffled <- TRUE
  [14:20:56.723]                           break
  [14:20:56.723]                         }
  [14:20:56.723]                       }
  [14:20:56.723]                       invisible(muffled)
  [14:20:56.723]                     }
  [14:20:56.723]                     muffleCondition(cond)
  [14:20:56.723]                   }
  [14:20:56.723]                 }
  [14:20:56.723]             }
  [14:20:56.723]         }))
  [14:20:56.723]     }, error = function(ex) {
  [14:20:56.723]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.723]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.723]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.723]     }, finally = {
  [14:20:56.723]         {
  [14:20:56.723]             NULL
  [14:20:56.723]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.723]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.723]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.723]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.723]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.723]                 ...) 
  [14:20:56.723]             {
  [14:20:56.723]                 if (substitute) 
  [14:20:56.723]                   expr <- substitute(expr)
  [14:20:56.723]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.723]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.723]                   globals = globals, persistent = persistent, 
  [14:20:56.723]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.723]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.723]                   label = label, ...)
  [14:20:56.723]                 if (!future$lazy) 
  [14:20:56.723]                   future <- run(future)
  [14:20:56.723]                 invisible(future)
  [14:20:56.723]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.723]         }
  [14:20:56.723]         base::options(...future.oldOptions)
  [14:20:56.723]     })
  [14:20:56.723]     Sys.time
  [14:20:56.723]     if (base::is.na(TRUE)) {
  [14:20:56.723]     }
  [14:20:56.723]     else {
  [14:20:56.723]         base::sink(type = "output", split = FALSE)
  [14:20:56.723]         if (TRUE) {
  [14:20:56.723]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.723]         }
  [14:20:56.723]         else {
  [14:20:56.723]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.723]         }
  [14:20:56.723]         base::close(...future.stdout)
  [14:20:56.723]         ...future.stdout <- NULL
  [14:20:56.723]     }
  [14:20:56.723]     ...future.result$conditions <- ...future.conditions
  [14:20:56.723]     ...future.result
  [14:20:56.723] }
  [14:20:56.730] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:20:56.742] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.743] - Validating connection of ClusterFuture
  [14:20:56.743] - received message: FutureResult
  [14:20:56.744] - Received FutureResult
  [14:20:56.744] - Erased future from FutureRegistry
  [14:20:56.745] result() for ClusterFuture ...
  [14:20:56.745] - result already collected: FutureResult
  [14:20:56.745] result() for ClusterFuture ... done
  [14:20:56.746] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:56.746] result() for ClusterFuture ...
  [14:20:56.747] - result already collected: FutureResult
  [14:20:56.747] result() for ClusterFuture ... done
  [14:20:56.747] result() for ClusterFuture ...
  [14:20:56.748] - result already collected: FutureResult
  [14:20:56.748] result() for ClusterFuture ... done
  [14:20:56.751] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa404e18> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f969d018> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa404e18> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f969d018> 
   $  : 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"
  [14:20:56.795] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.796] - Validating connection of ClusterFuture
  [14:20:56.796] - received message: FutureResult
  [14:20:56.796] - Received FutureResult
  [14:20:56.797] - Erased future from FutureRegistry
  [14:20:56.797] result() for ClusterFuture ...
  [14:20:56.798] - result already collected: FutureResult
  [14:20:56.798] result() for ClusterFuture ... done
  [14:20:56.798] 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" "" ...
  [14:20:56.804] resolve() on list ...
  [14:20:56.804]  recursive: 0
  [14:20:56.805]  length: 6
  [14:20:56.805]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:56.805] signalConditionsASAP(numeric, pos=1) ...
  [14:20:56.806] - nx: 6
  [14:20:56.806] - relay: TRUE
  [14:20:56.806] - stdout: TRUE
  [14:20:56.807] - signal: TRUE
  [14:20:56.807] - resignal: FALSE
  [14:20:56.807] - force: TRUE
  [14:20:56.808] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.808] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.808]  - until=2
  [14:20:56.809]  - relaying element #2
  [14:20:56.809] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.809] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.810] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:56.810]  length: 5 (resolved future 1)
  [14:20:56.810] Future #2
  [14:20:56.811] result() for ClusterFuture ...
  [14:20:56.811] - result already collected: FutureResult
  [14:20:56.811] result() for ClusterFuture ... done
  [14:20:56.812] result() for ClusterFuture ...
  [14:20:56.812] - result already collected: FutureResult
  [14:20:56.813] result() for ClusterFuture ... done
  [14:20:56.813] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:20:56.813] - nx: 6
  [14:20:56.814] - relay: TRUE
  [14:20:56.814] - stdout: TRUE
  [14:20:56.814] - signal: TRUE
  [14:20:56.814] - resignal: FALSE
  [14:20:56.815] - force: TRUE
  [14:20:56.815] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.815] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.816]  - until=2
  [14:20:56.816]  - relaying element #2
  [14:20:56.816] result() for ClusterFuture ...
  [14:20:56.817] - result already collected: FutureResult
  [14:20:56.817] result() for ClusterFuture ... done
  [14:20:56.817] result() for ClusterFuture ...
  [14:20:56.818] - result already collected: FutureResult
  [14:20:56.818] result() for ClusterFuture ... done
  [14:20:56.819] result() for ClusterFuture ...
  [14:20:56.819] - result already collected: FutureResult
  [14:20:56.819] result() for ClusterFuture ... done
  [14:20:56.820] result() for ClusterFuture ...
  [14:20:56.820] - result already collected: FutureResult
  [14:20:56.843] result() for ClusterFuture ... done
  [14:20:56.844] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.844] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.845] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:20:56.845]  length: 4 (resolved future 2)
  [14:20:56.846] Future #3
  [14:20:56.846] result() for ClusterFuture ...
  [14:20:56.847] - result already collected: FutureResult
  [14:20:56.847] result() for ClusterFuture ... done
  [14:20:56.847] result() for ClusterFuture ...
  [14:20:56.848] - result already collected: FutureResult
  [14:20:56.848] result() for ClusterFuture ... done
  [14:20:56.849] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:20:56.849] - nx: 6
  [14:20:56.849] - relay: TRUE
  [14:20:56.849] - stdout: TRUE
  [14:20:56.850] - signal: TRUE
  [14:20:56.850] - resignal: FALSE
  [14:20:56.851] - force: TRUE
  [14:20:56.853] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.853] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:56.853]  - until=3
  [14:20:56.854]  - relaying element #3
  [14:20:56.854] result() for ClusterFuture ...
  [14:20:56.855] - result already collected: FutureResult
  [14:20:56.855] result() for ClusterFuture ... done
  [14:20:56.855] result() for ClusterFuture ...
  [14:20:56.856] - result already collected: FutureResult
  [14:20:56.856] result() for ClusterFuture ... done
  [14:20:56.856] result() for ClusterFuture ...
  [14:20:56.857] - result already collected: FutureResult
  [14:20:56.857] result() for ClusterFuture ... done
  [14:20:56.858] result() for ClusterFuture ...
  [14:20:56.858] - result already collected: FutureResult
  [14:20:56.858] result() for ClusterFuture ... done
  [14:20:56.859] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.859] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.859] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:20:56.860]  length: 3 (resolved future 3)
  [14:20:56.860] signalConditionsASAP(NULL, pos=4) ...
  [14:20:56.860] - nx: 6
  [14:20:56.861] - relay: TRUE
  [14:20:56.861] - stdout: TRUE
  [14:20:56.861] - signal: TRUE
  [14:20:56.862] - resignal: FALSE
  [14:20:56.862] - force: TRUE
  [14:20:56.862] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.863] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.863]  - until=5
  [14:20:56.863]  - relaying element #5
  [14:20:56.864] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.864] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.864] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:56.865]  length: 2 (resolved future 4)
  [14:20:56.865] signalConditionsASAP(NULL, pos=5) ...
  [14:20:56.865] - nx: 6
  [14:20:56.866] - relay: TRUE
  [14:20:56.866] - stdout: TRUE
  [14:20:56.866] - signal: TRUE
  [14:20:56.867] - resignal: FALSE
  [14:20:56.867] - force: TRUE
  [14:20:56.867] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:56.868] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.868]  - until=6
  [14:20:56.868]  - relaying element #6
  [14:20:56.869] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.869] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.870] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:56.870]  length: 1 (resolved future 5)
  [14:20:56.870] signalConditionsASAP(numeric, pos=6) ...
  [14:20:56.871] - nx: 6
  [14:20:56.871] - relay: TRUE
  [14:20:56.871] - stdout: TRUE
  [14:20:56.871] - signal: TRUE
  [14:20:56.872] - resignal: FALSE
  [14:20:56.872] - force: TRUE
  [14:20:56.872] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:56.873] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.873]  - until=6
  [14:20:56.873] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.874] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.874] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:56.874]  length: 0 (resolved future 6)
  [14:20:56.875] Relaying remaining futures
  [14:20:56.875] signalConditionsASAP(NULL, pos=0) ...
  [14:20:56.875] - nx: 6
  [14:20:56.876] - relay: TRUE
  [14:20:56.876] - stdout: TRUE
  [14:20:56.876] - signal: TRUE
  [14:20:56.876] - resignal: FALSE
  [14:20:56.877] - force: TRUE
  [14:20:56.877] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.877] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:56.878] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:56.878] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:56.879] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:56.879] resolve() on list ... DONE
  [14:20:56.879] result() for ClusterFuture ...
  [14:20:56.880] - result already collected: FutureResult
  [14:20:56.880] result() for ClusterFuture ... done
  [14:20:56.880] result() for ClusterFuture ...
  [14:20:56.881] - result already collected: FutureResult
  [14:20:56.881] result() for ClusterFuture ... done
  [14:20:56.881] result() for ClusterFuture ...
  [14:20:56.882] - result already collected: FutureResult
  [14:20:56.882] result() for ClusterFuture ... done
  [14:20:56.882] result() for ClusterFuture ...
  [14:20:56.883] - result already collected: FutureResult
  [14:20:56.883] 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)
  [14:20:56.900] getGlobalsAndPackages() ...
  [14:20:56.901] Searching for globals...
  [14:20:56.902] 
  [14:20:56.902] Searching for globals ... DONE
  [14:20:56.902] - globals: [0] <none>
  [14:20:56.903] getGlobalsAndPackages() ... DONE
  [14:20:56.907] Packages needed by the future expression (n = 0): <none>
  [14:20:56.908] Packages needed by future strategies (n = 0): <none>
  [14:20:56.914] {
  [14:20:56.914]     {
  [14:20:56.914]         ...future.startTime <- base::Sys.time()
  [14:20:56.914]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.914]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.914]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.914]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.914]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.914]         {
  [14:20:56.914]             {
  [14:20:56.914]                 has_future <- base::requireNamespace("future", 
  [14:20:56.914]                   quietly = TRUE)
  [14:20:56.914]                 version <- if (has_future) 
  [14:20:56.914]                   utils::packageVersion("future")
  [14:20:56.914]                 else NULL
  [14:20:56.914]                 if (!has_future || version < "1.8.0") {
  [14:20:56.914]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.914]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.914]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.914]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.914]                       "release", "version")], collapse = " "), 
  [14:20:56.914]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.914]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.914]                     info)
  [14:20:56.914]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.914]                   if (!has_future) {
  [14:20:56.914]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.914]                       info)
  [14:20:56.914]                   }
  [14:20:56.914]                   else {
  [14:20:56.914]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.914]                       info, version)
  [14:20:56.914]                   }
  [14:20:56.914]                   base::stop(msg)
  [14:20:56.914]                 }
  [14:20:56.914]             }
  [14:20:56.914]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.914]         }
  [14:20:56.914]     }
  [14:20:56.914]     if (base::is.na(TRUE)) {
  [14:20:56.914]     }
  [14:20:56.914]     else {
  [14:20:56.914]         if (TRUE) {
  [14:20:56.914]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.914]                 open = "w")
  [14:20:56.914]         }
  [14:20:56.914]         else {
  [14:20:56.914]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.914]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.914]         }
  [14:20:56.914]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.914]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.914]             base::sink(type = "output", split = FALSE)
  [14:20:56.914]             base::close(...future.stdout)
  [14:20:56.914]         }, add = TRUE)
  [14:20:56.914]     }
  [14:20:56.914]     ...future.frame <- base::sys.nframe()
  [14:20:56.914]     ...future.conditions <- base::list()
  [14:20:56.914]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.914]     ...future.result <- base::tryCatch({
  [14:20:56.914]         base::withCallingHandlers({
  [14:20:56.914]             ...future.value <- base::withVisible(base::local({
  [14:20:56.914]                 ...future.sendCondition <- local({
  [14:20:56.914]                   sendCondition <- NULL
  [14:20:56.914]                   function(frame = 1L) {
  [14:20:56.914]                     if (is.function(sendCondition)) 
  [14:20:56.914]                       return(sendCondition)
  [14:20:56.914]                     ns <- getNamespace("parallel")
  [14:20:56.914]                     if (exists("sendData", mode = "function", 
  [14:20:56.914]                       envir = ns)) {
  [14:20:56.914]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.914]                         envir = ns)
  [14:20:56.914]                       envir <- sys.frame(frame)
  [14:20:56.914]                       master <- NULL
  [14:20:56.914]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.914]                         !identical(envir, emptyenv())) {
  [14:20:56.914]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.914]                           inherits = FALSE)) {
  [14:20:56.914]                           master <- get("master", mode = "list", 
  [14:20:56.914]                             envir = envir, inherits = FALSE)
  [14:20:56.914]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.914]                             sendCondition <<- function(cond) {
  [14:20:56.914]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.914]                                 success = TRUE)
  [14:20:56.914]                               parallel_sendData(master, data)
  [14:20:56.914]                             }
  [14:20:56.914]                             return(sendCondition)
  [14:20:56.914]                           }
  [14:20:56.914]                         }
  [14:20:56.914]                         frame <- frame + 1L
  [14:20:56.914]                         envir <- sys.frame(frame)
  [14:20:56.914]                       }
  [14:20:56.914]                     }
  [14:20:56.914]                     sendCondition <<- function(cond) NULL
  [14:20:56.914]                   }
  [14:20:56.914]                 })
  [14:20:56.914]                 withCallingHandlers({
  [14:20:56.914]                   2
  [14:20:56.914]                 }, immediateCondition = function(cond) {
  [14:20:56.914]                   sendCondition <- ...future.sendCondition()
  [14:20:56.914]                   sendCondition(cond)
  [14:20:56.914]                   muffleCondition <- function (cond) 
  [14:20:56.914]                   {
  [14:20:56.914]                     inherits <- base::inherits
  [14:20:56.914]                     invokeRestart <- base::invokeRestart
  [14:20:56.914]                     muffled <- FALSE
  [14:20:56.914]                     if (inherits(cond, "message")) {
  [14:20:56.914]                       invokeRestart("muffleMessage")
  [14:20:56.914]                       muffled <- TRUE
  [14:20:56.914]                     }
  [14:20:56.914]                     else if (inherits(cond, "warning")) {
  [14:20:56.914]                       invokeRestart("muffleWarning")
  [14:20:56.914]                       muffled <- TRUE
  [14:20:56.914]                     }
  [14:20:56.914]                     else if (inherits(cond, "condition")) {
  [14:20:56.914]                       computeRestarts <- base::computeRestarts
  [14:20:56.914]                       grepl <- base::grepl
  [14:20:56.914]                       is.null <- base::is.null
  [14:20:56.914]                       restarts <- computeRestarts(cond)
  [14:20:56.914]                       for (restart in restarts) {
  [14:20:56.914]                         name <- restart$name
  [14:20:56.914]                         if (is.null(name)) 
  [14:20:56.914]                           next
  [14:20:56.914]                         if (!grepl("^muffle", name)) 
  [14:20:56.914]                           next
  [14:20:56.914]                         invokeRestart(restart)
  [14:20:56.914]                         muffled <- TRUE
  [14:20:56.914]                         break
  [14:20:56.914]                       }
  [14:20:56.914]                     }
  [14:20:56.914]                     invisible(muffled)
  [14:20:56.914]                   }
  [14:20:56.914]                   muffleCondition(cond)
  [14:20:56.914]                 })
  [14:20:56.914]             }))
  [14:20:56.914]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.914]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.914]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.914]                 version = "1.8")
  [14:20:56.914]         }, condition = base::local({
  [14:20:56.914]             c <- base::c
  [14:20:56.914]             inherits <- base::inherits
  [14:20:56.914]             invokeRestart <- base::invokeRestart
  [14:20:56.914]             length <- base::length
  [14:20:56.914]             list <- base::list
  [14:20:56.914]             seq.int <- base::seq.int
  [14:20:56.914]             signalCondition <- base::signalCondition
  [14:20:56.914]             sys.calls <- base::sys.calls
  [14:20:56.914]             Sys.time <- base::Sys.time
  [14:20:56.914]             `[[` <- base::`[[`
  [14:20:56.914]             `+` <- base::`+`
  [14:20:56.914]             `<<-` <- base::`<<-`
  [14:20:56.914]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.914]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.914]                   3L)]
  [14:20:56.914]             }
  [14:20:56.914]             function(cond) {
  [14:20:56.914]                 if (inherits(cond, "error")) {
  [14:20:56.914]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.914]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.914]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.914]                   signalCondition(cond)
  [14:20:56.914]                 }
  [14:20:56.914]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.914]                 ))) {
  [14:20:56.914]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.914]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.914]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.914]                   if (!signal) {
  [14:20:56.914]                     muffleCondition <- function (cond) 
  [14:20:56.914]                     {
  [14:20:56.914]                       inherits <- base::inherits
  [14:20:56.914]                       invokeRestart <- base::invokeRestart
  [14:20:56.914]                       muffled <- FALSE
  [14:20:56.914]                       if (inherits(cond, "message")) {
  [14:20:56.914]                         invokeRestart("muffleMessage")
  [14:20:56.914]                         muffled <- TRUE
  [14:20:56.914]                       }
  [14:20:56.914]                       else if (inherits(cond, "warning")) {
  [14:20:56.914]                         invokeRestart("muffleWarning")
  [14:20:56.914]                         muffled <- TRUE
  [14:20:56.914]                       }
  [14:20:56.914]                       else if (inherits(cond, "condition")) {
  [14:20:56.914]                         computeRestarts <- base::computeRestarts
  [14:20:56.914]                         grepl <- base::grepl
  [14:20:56.914]                         is.null <- base::is.null
  [14:20:56.914]                         restarts <- computeRestarts(cond)
  [14:20:56.914]                         for (restart in restarts) {
  [14:20:56.914]                           name <- restart$name
  [14:20:56.914]                           if (is.null(name)) 
  [14:20:56.914]                             next
  [14:20:56.914]                           if (!grepl("^muffle", name)) 
  [14:20:56.914]                             next
  [14:20:56.914]                           invokeRestart(restart)
  [14:20:56.914]                           muffled <- TRUE
  [14:20:56.914]                           break
  [14:20:56.914]                         }
  [14:20:56.914]                       }
  [14:20:56.914]                       invisible(muffled)
  [14:20:56.914]                     }
  [14:20:56.914]                     muffleCondition(cond)
  [14:20:56.914]                   }
  [14:20:56.914]                 }
  [14:20:56.914]             }
  [14:20:56.914]         }))
  [14:20:56.914]     }, error = function(ex) {
  [14:20:56.914]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.914]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.914]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.914]     }, finally = {
  [14:20:56.914]         {
  [14:20:56.914]             NULL
  [14:20:56.914]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.914]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.914]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.914]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.914]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.914]                 ...) 
  [14:20:56.914]             {
  [14:20:56.914]                 if (substitute) 
  [14:20:56.914]                   expr <- substitute(expr)
  [14:20:56.914]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.914]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.914]                   globals = globals, persistent = persistent, 
  [14:20:56.914]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.914]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.914]                   label = label, ...)
  [14:20:56.914]                 if (!future$lazy) 
  [14:20:56.914]                   future <- run(future)
  [14:20:56.914]                 invisible(future)
  [14:20:56.914]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.914]         }
  [14:20:56.914]         base::options(...future.oldOptions)
  [14:20:56.914]     })
  [14:20:56.914]     Sys.time
  [14:20:56.914]     if (base::is.na(TRUE)) {
  [14:20:56.914]     }
  [14:20:56.914]     else {
  [14:20:56.914]         base::sink(type = "output", split = FALSE)
  [14:20:56.914]         if (TRUE) {
  [14:20:56.914]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.914]         }
  [14:20:56.914]         else {
  [14:20:56.914]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.914]         }
  [14:20:56.914]         base::close(...future.stdout)
  [14:20:56.914]         ...future.stdout <- NULL
  [14:20:56.914]     }
  [14:20:56.914]     ...future.result$conditions <- ...future.conditions
  [14:20:56.914]     ...future.result
  [14:20:56.914] }
  [14:20:56.923] ClusterFuture started
  [14:20:56.935] getGlobalsAndPackages() ...
  [14:20:56.935] Searching for globals...
  [14:20:56.936] 
  [14:20:56.937] Searching for globals ... DONE
  [14:20:56.937] - globals: [0] <none>
  [14:20:56.937] getGlobalsAndPackages() ... DONE
  [14:20:56.947] Packages needed by the future expression (n = 0): <none>
  [14:20:56.949] Packages needed by future strategies (n = 0): <none>
  [14:20:56.956] {
  [14:20:56.956]     {
  [14:20:56.956]         ...future.startTime <- base::Sys.time()
  [14:20:56.956]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:56.956]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:56.956]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:56.956]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:56.956]             future.resolve.recursive = NULL, width = 80L)
  [14:20:56.956]         {
  [14:20:56.956]             {
  [14:20:56.956]                 has_future <- base::requireNamespace("future", 
  [14:20:56.956]                   quietly = TRUE)
  [14:20:56.956]                 version <- if (has_future) 
  [14:20:56.956]                   utils::packageVersion("future")
  [14:20:56.956]                 else NULL
  [14:20:56.956]                 if (!has_future || version < "1.8.0") {
  [14:20:56.956]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:56.956]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:56.956]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:56.956]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:56.956]                       "release", "version")], collapse = " "), 
  [14:20:56.956]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:56.956]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:56.956]                     info)
  [14:20:56.956]                   info <- base::paste(info, collapse = "; ")
  [14:20:56.956]                   if (!has_future) {
  [14:20:56.956]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:56.956]                       info)
  [14:20:56.956]                   }
  [14:20:56.956]                   else {
  [14:20:56.956]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:56.956]                       info, version)
  [14:20:56.956]                   }
  [14:20:56.956]                   base::stop(msg)
  [14:20:56.956]                 }
  [14:20:56.956]             }
  [14:20:56.956]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:56.956]         }
  [14:20:56.956]     }
  [14:20:56.956]     if (base::is.na(TRUE)) {
  [14:20:56.956]     }
  [14:20:56.956]     else {
  [14:20:56.956]         if (TRUE) {
  [14:20:56.956]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:56.956]                 open = "w")
  [14:20:56.956]         }
  [14:20:56.956]         else {
  [14:20:56.956]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:56.956]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:56.956]         }
  [14:20:56.956]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:56.956]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:56.956]             base::sink(type = "output", split = FALSE)
  [14:20:56.956]             base::close(...future.stdout)
  [14:20:56.956]         }, add = TRUE)
  [14:20:56.956]     }
  [14:20:56.956]     ...future.frame <- base::sys.nframe()
  [14:20:56.956]     ...future.conditions <- base::list()
  [14:20:56.956]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:56.956]     ...future.result <- base::tryCatch({
  [14:20:56.956]         base::withCallingHandlers({
  [14:20:56.956]             ...future.value <- base::withVisible(base::local({
  [14:20:56.956]                 ...future.sendCondition <- local({
  [14:20:56.956]                   sendCondition <- NULL
  [14:20:56.956]                   function(frame = 1L) {
  [14:20:56.956]                     if (is.function(sendCondition)) 
  [14:20:56.956]                       return(sendCondition)
  [14:20:56.956]                     ns <- getNamespace("parallel")
  [14:20:56.956]                     if (exists("sendData", mode = "function", 
  [14:20:56.956]                       envir = ns)) {
  [14:20:56.956]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:20:56.956]                         envir = ns)
  [14:20:56.956]                       envir <- sys.frame(frame)
  [14:20:56.956]                       master <- NULL
  [14:20:56.956]                       while (!identical(envir, .GlobalEnv) && 
  [14:20:56.956]                         !identical(envir, emptyenv())) {
  [14:20:56.956]                         if (exists("master", mode = "list", envir = envir, 
  [14:20:56.956]                           inherits = FALSE)) {
  [14:20:56.956]                           master <- get("master", mode = "list", 
  [14:20:56.956]                             envir = envir, inherits = FALSE)
  [14:20:56.956]                           if (inherits(master, "SOCKnode")) {
  [14:20:56.956]                             sendCondition <<- function(cond) {
  [14:20:56.956]                               data <- list(type = "VALUE", value = cond, 
  [14:20:56.956]                                 success = TRUE)
  [14:20:56.956]                               parallel_sendData(master, data)
  [14:20:56.956]                             }
  [14:20:56.956]                             return(sendCondition)
  [14:20:56.956]                           }
  [14:20:56.956]                         }
  [14:20:56.956]                         frame <- frame + 1L
  [14:20:56.956]                         envir <- sys.frame(frame)
  [14:20:56.956]                       }
  [14:20:56.956]                     }
  [14:20:56.956]                     sendCondition <<- function(cond) NULL
  [14:20:56.956]                   }
  [14:20:56.956]                 })
  [14:20:56.956]                 withCallingHandlers({
  [14:20:56.956]                   NULL
  [14:20:56.956]                 }, immediateCondition = function(cond) {
  [14:20:56.956]                   sendCondition <- ...future.sendCondition()
  [14:20:56.956]                   sendCondition(cond)
  [14:20:56.956]                   muffleCondition <- function (cond) 
  [14:20:56.956]                   {
  [14:20:56.956]                     inherits <- base::inherits
  [14:20:56.956]                     invokeRestart <- base::invokeRestart
  [14:20:56.956]                     muffled <- FALSE
  [14:20:56.956]                     if (inherits(cond, "message")) {
  [14:20:56.956]                       invokeRestart("muffleMessage")
  [14:20:56.956]                       muffled <- TRUE
  [14:20:56.956]                     }
  [14:20:56.956]                     else if (inherits(cond, "warning")) {
  [14:20:56.956]                       invokeRestart("muffleWarning")
  [14:20:56.956]                       muffled <- TRUE
  [14:20:56.956]                     }
  [14:20:56.956]                     else if (inherits(cond, "condition")) {
  [14:20:56.956]                       computeRestarts <- base::computeRestarts
  [14:20:56.956]                       grepl <- base::grepl
  [14:20:56.956]                       is.null <- base::is.null
  [14:20:56.956]                       restarts <- computeRestarts(cond)
  [14:20:56.956]                       for (restart in restarts) {
  [14:20:56.956]                         name <- restart$name
  [14:20:56.956]                         if (is.null(name)) 
  [14:20:56.956]                           next
  [14:20:56.956]                         if (!grepl("^muffle", name)) 
  [14:20:56.956]                           next
  [14:20:56.956]                         invokeRestart(restart)
  [14:20:56.956]                         muffled <- TRUE
  [14:20:56.956]                         break
  [14:20:56.956]                       }
  [14:20:56.956]                     }
  [14:20:56.956]                     invisible(muffled)
  [14:20:56.956]                   }
  [14:20:56.956]                   muffleCondition(cond)
  [14:20:56.956]                 })
  [14:20:56.956]             }))
  [14:20:56.956]             future::FutureResult(value = ...future.value$value, 
  [14:20:56.956]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.956]                   ...future.rng), started = ...future.startTime, 
  [14:20:56.956]                 version = "1.8")
  [14:20:56.956]         }, condition = base::local({
  [14:20:56.956]             c <- base::c
  [14:20:56.956]             inherits <- base::inherits
  [14:20:56.956]             invokeRestart <- base::invokeRestart
  [14:20:56.956]             length <- base::length
  [14:20:56.956]             list <- base::list
  [14:20:56.956]             seq.int <- base::seq.int
  [14:20:56.956]             signalCondition <- base::signalCondition
  [14:20:56.956]             sys.calls <- base::sys.calls
  [14:20:56.956]             Sys.time <- base::Sys.time
  [14:20:56.956]             `[[` <- base::`[[`
  [14:20:56.956]             `+` <- base::`+`
  [14:20:56.956]             `<<-` <- base::`<<-`
  [14:20:56.956]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:56.956]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:56.956]                   3L)]
  [14:20:56.956]             }
  [14:20:56.956]             function(cond) {
  [14:20:56.956]                 if (inherits(cond, "error")) {
  [14:20:56.956]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.956]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:56.956]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:56.956]                   signalCondition(cond)
  [14:20:56.956]                 }
  [14:20:56.956]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:56.956]                 ))) {
  [14:20:56.956]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:56.956]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:56.956]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:56.956]                   if (!signal) {
  [14:20:56.956]                     muffleCondition <- function (cond) 
  [14:20:56.956]                     {
  [14:20:56.956]                       inherits <- base::inherits
  [14:20:56.956]                       invokeRestart <- base::invokeRestart
  [14:20:56.956]                       muffled <- FALSE
  [14:20:56.956]                       if (inherits(cond, "message")) {
  [14:20:56.956]                         invokeRestart("muffleMessage")
  [14:20:56.956]                         muffled <- TRUE
  [14:20:56.956]                       }
  [14:20:56.956]                       else if (inherits(cond, "warning")) {
  [14:20:56.956]                         invokeRestart("muffleWarning")
  [14:20:56.956]                         muffled <- TRUE
  [14:20:56.956]                       }
  [14:20:56.956]                       else if (inherits(cond, "condition")) {
  [14:20:56.956]                         computeRestarts <- base::computeRestarts
  [14:20:56.956]                         grepl <- base::grepl
  [14:20:56.956]                         is.null <- base::is.null
  [14:20:56.956]                         restarts <- computeRestarts(cond)
  [14:20:56.956]                         for (restart in restarts) {
  [14:20:56.956]                           name <- restart$name
  [14:20:56.956]                           if (is.null(name)) 
  [14:20:56.956]                             next
  [14:20:56.956]                           if (!grepl("^muffle", name)) 
  [14:20:56.956]                             next
  [14:20:56.956]                           invokeRestart(restart)
  [14:20:56.956]                           muffled <- TRUE
  [14:20:56.956]                           break
  [14:20:56.956]                         }
  [14:20:56.956]                       }
  [14:20:56.956]                       invisible(muffled)
  [14:20:56.956]                     }
  [14:20:56.956]                     muffleCondition(cond)
  [14:20:56.956]                   }
  [14:20:56.956]                 }
  [14:20:56.956]             }
  [14:20:56.956]         }))
  [14:20:56.956]     }, error = function(ex) {
  [14:20:56.956]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:56.956]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:56.956]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:56.956]     }, finally = {
  [14:20:56.956]         {
  [14:20:56.956]             NULL
  [14:20:56.956]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:56.956]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:56.956]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:20:56.956]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:20:56.956]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:20:56.956]                 ...) 
  [14:20:56.956]             {
  [14:20:56.956]                 if (substitute) 
  [14:20:56.956]                   expr <- substitute(expr)
  [14:20:56.956]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:20:56.956]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:56.956]                   globals = globals, persistent = persistent, 
  [14:20:56.956]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:20:56.956]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:20:56.956]                   label = label, ...)
  [14:20:56.956]                 if (!future$lazy) 
  [14:20:56.956]                   future <- run(future)
  [14:20:56.956]                 invisible(future)
  [14:20:56.956]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:56.956]         }
  [14:20:56.956]         base::options(...future.oldOptions)
  [14:20:56.956]     })
  [14:20:56.956]     Sys.time
  [14:20:56.956]     if (base::is.na(TRUE)) {
  [14:20:56.956]     }
  [14:20:56.956]     else {
  [14:20:56.956]         base::sink(type = "output", split = FALSE)
  [14:20:56.956]         if (TRUE) {
  [14:20:56.956]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:56.956]         }
  [14:20:56.956]         else {
  [14:20:56.956]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:56.956]         }
  [14:20:56.956]         base::close(...future.stdout)
  [14:20:56.956]         ...future.stdout <- NULL
  [14:20:56.956]     }
  [14:20:56.956]     ...future.result$conditions <- ...future.conditions
  [14:20:56.956]     ...future.result
  [14:20:56.956] }
  [14:20:56.971] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:20:56.985] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:56.985] - Validating connection of ClusterFuture
  [14:20:56.986] - received message: FutureResult
  [14:20:56.987] - Received FutureResult
  [14:20:56.987] - Erased future from FutureRegistry
  [14:20:56.988] result() for ClusterFuture ...
  [14:20:56.988] - result already collected: FutureResult
  [14:20:56.989] result() for ClusterFuture ... done
  [14:20:56.989] receiveMessageFromWorker() for ClusterFuture ... done
  [14:20:56.990] result() for ClusterFuture ...
  [14:20:56.991] - result already collected: FutureResult
  [14:20:56.991] result() for ClusterFuture ... done
  [14:20:56.991] result() for ClusterFuture ...
  [14:20:56.992] - result already collected: FutureResult
  [14:20:56.992] result() for ClusterFuture ... done
  [14:20:57.047] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa49b258> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f8fcd270> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574fa49b258> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x5574f8fcd270> 
   $  : 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"
  [14:20:57.090] receiveMessageFromWorker() for ClusterFuture ...
  [14:20:57.090] - Validating connection of ClusterFuture
  [14:20:57.091] - received message: FutureResult
  [14:20:57.091] - Received FutureResult
  [14:20:57.092] - Erased future from FutureRegistry
  [14:20:57.092] result() for ClusterFuture ...
  [14:20:57.093] - result already collected: FutureResult
  [14:20:57.093] result() for ClusterFuture ... done
  [14:20:57.093] 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" "" ...
  [14:20:57.123] resolve() on list ...
  [14:20:57.123]  recursive: 0
  [14:20:57.124]  length: 6
  [14:20:57.124]  elements: 'a', 'b', 'c', '', '', ''
  [14:20:57.125] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.125] - nx: 6
  [14:20:57.126] - relay: TRUE
  [14:20:57.126] - stdout: TRUE
  [14:20:57.134] - signal: TRUE
  [14:20:57.134] - resignal: FALSE
  [14:20:57.135] - force: TRUE
  [14:20:57.135] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.136] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.136]  - until=2
  [14:20:57.137]  - relaying element #2
  [14:20:57.137] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.138] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.138] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.139]  length: 5 (resolved future 1)
  [14:20:57.139] Future #2
  [14:20:57.146] result() for ClusterFuture ...
  [14:20:57.147] - result already collected: FutureResult
  [14:20:57.147] result() for ClusterFuture ... done
  [14:20:57.148] result() for ClusterFuture ...
  [14:20:57.148] - result already collected: FutureResult
  [14:20:57.149] result() for ClusterFuture ... done
  [14:20:57.149] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:20:57.150] - nx: 6
  [14:20:57.187] - relay: TRUE
  [14:20:57.187] - stdout: TRUE
  [14:20:57.188] - signal: TRUE
  [14:20:57.188] - resignal: FALSE
  [14:20:57.188] - force: TRUE
  [14:20:57.189] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.189] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.190]  - until=2
  [14:20:57.190]  - relaying element #2
  [14:20:57.190] result() for ClusterFuture ...
  [14:20:57.191] - result already collected: FutureResult
  [14:20:57.191] result() for ClusterFuture ... done
  [14:20:57.192] result() for ClusterFuture ...
  [14:20:57.192] - result already collected: FutureResult
  [14:20:57.192] result() for ClusterFuture ... done
  [14:20:57.193] result() for ClusterFuture ...
  [14:20:57.193] - result already collected: FutureResult
  [14:20:57.194] result() for ClusterFuture ... done
  [14:20:57.194] result() for ClusterFuture ...
  [14:20:57.194] - result already collected: FutureResult
  [14:20:57.194] result() for ClusterFuture ... done
  [14:20:57.195] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.195] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.195] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:20:57.196]  length: 4 (resolved future 2)
  [14:20:57.196] Future #3
  [14:20:57.196] result() for ClusterFuture ...
  [14:20:57.197] - result already collected: FutureResult
  [14:20:57.197] result() for ClusterFuture ... done
  [14:20:57.197] result() for ClusterFuture ...
  [14:20:57.198] - result already collected: FutureResult
  [14:20:57.198] result() for ClusterFuture ... done
  [14:20:57.198] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:20:57.199] - nx: 6
  [14:20:57.199] - relay: TRUE
  [14:20:57.199] - stdout: TRUE
  [14:20:57.199] - signal: TRUE
  [14:20:57.200] - resignal: FALSE
  [14:20:57.200] - force: TRUE
  [14:20:57.200] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.200] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:20:57.201]  - until=3
  [14:20:57.201]  - relaying element #3
  [14:20:57.201] result() for ClusterFuture ...
  [14:20:57.202] - result already collected: FutureResult
  [14:20:57.202] result() for ClusterFuture ... done
  [14:20:57.202] result() for ClusterFuture ...
  [14:20:57.203] - result already collected: FutureResult
  [14:20:57.203] result() for ClusterFuture ... done
  [14:20:57.203] result() for ClusterFuture ...
  [14:20:57.204] - result already collected: FutureResult
  [14:20:57.204] result() for ClusterFuture ... done
  [14:20:57.204] result() for ClusterFuture ...
  [14:20:57.205] - result already collected: FutureResult
  [14:20:57.205] result() for ClusterFuture ... done
  [14:20:57.205] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.205] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.206] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:20:57.206]  length: 3 (resolved future 3)
  [14:20:57.206] signalConditionsASAP(NULL, pos=4) ...
  [14:20:57.207] - nx: 6
  [14:20:57.207] - relay: TRUE
  [14:20:57.207] - stdout: TRUE
  [14:20:57.207] - signal: TRUE
  [14:20:57.208] - resignal: FALSE
  [14:20:57.208] - force: TRUE
  [14:20:57.208] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.209] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.209]  - until=5
  [14:20:57.209]  - relaying element #5
  [14:20:57.209] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:57.210] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.210] signalConditionsASAP(NULL, pos=4) ... done
  [14:20:57.210]  length: 2 (resolved future 4)
  [14:20:57.211] signalConditionsASAP(NULL, pos=5) ...
  [14:20:57.211] - nx: 6
  [14:20:57.211] - relay: TRUE
  [14:20:57.211] - stdout: TRUE
  [14:20:57.212] - signal: TRUE
  [14:20:57.212] - resignal: FALSE
  [14:20:57.212] - force: TRUE
  [14:20:57.213] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:20:57.213] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.213]  - until=6
  [14:20:57.213]  - relaying element #6
  [14:20:57.214] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:57.214] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.214] signalConditionsASAP(NULL, pos=5) ... done
  [14:20:57.215]  length: 1 (resolved future 5)
  [14:20:57.215] signalConditionsASAP(numeric, pos=6) ...
  [14:20:57.215] - nx: 6
  [14:20:57.215] - relay: TRUE
  [14:20:57.216] - stdout: TRUE
  [14:20:57.216] - signal: TRUE
  [14:20:57.216] - resignal: FALSE
  [14:20:57.217] - force: TRUE
  [14:20:57.217] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:20:57.217] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.217]  - until=6
  [14:20:57.218] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:57.218] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.218] signalConditionsASAP(numeric, pos=6) ... done
  [14:20:57.219]  length: 0 (resolved future 6)
  [14:20:57.219] Relaying remaining futures
  [14:20:57.219] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.219] - nx: 6
  [14:20:57.220] - relay: TRUE
  [14:20:57.220] - stdout: TRUE
  [14:20:57.220] - signal: TRUE
  [14:20:57.220] - resignal: FALSE
  [14:20:57.221] - force: TRUE
  [14:20:57.221] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:57.221] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [14:20:57.222] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:20:57.222] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:20:57.222] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.223] resolve() on list ... DONE
  [14:20:57.223] result() for ClusterFuture ...
  [14:20:57.223] - result already collected: FutureResult
  [14:20:57.224] result() for ClusterFuture ... done
  [14:20:57.224] result() for ClusterFuture ...
  [14:20:57.224] - result already collected: FutureResult
  [14:20:57.224] result() for ClusterFuture ... done
  [14:20:57.225] result() for ClusterFuture ...
  [14:20:57.225] - result already collected: FutureResult
  [14:20:57.225] result() for ClusterFuture ... done
  [14:20:57.226] result() for ClusterFuture ...
  [14:20:57.226] - result already collected: FutureResult
  [14:20:57.226] 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
  [14:20:57.314] plan(): Setting new future strategy stack:
  [14:20:57.315] List of future strategies:
  [14:20:57.315] 1. sequential:
  [14:20:57.315]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.315]    - tweaked: FALSE
  [14:20:57.315]    - call: plan(strategy)
  [14:20:57.316] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [14:20:57.317] getGlobalsAndPackages() ...
  [14:20:57.318] Searching for globals...
  [14:20:57.318] 
  [14:20:57.319] Searching for globals ... DONE
  [14:20:57.319] - globals: [0] <none>
  [14:20:57.319] getGlobalsAndPackages() ... DONE
  [14:20:57.322] Packages needed by the future expression (n = 0): <none>
  [14:20:57.322] Packages needed by future strategies (n = 0): <none>
  [14:20:57.328] {
  [14:20:57.328]     {
  [14:20:57.328]         ...future.startTime <- base::Sys.time()
  [14:20:57.328]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.328]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.328]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.328]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.328]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.328]         {
  [14:20:57.328]             {
  [14:20:57.328]                 has_future <- base::requireNamespace("future", 
  [14:20:57.328]                   quietly = TRUE)
  [14:20:57.328]                 version <- if (has_future) 
  [14:20:57.328]                   utils::packageVersion("future")
  [14:20:57.328]                 else NULL
  [14:20:57.328]                 if (!has_future || version < "1.8.0") {
  [14:20:57.328]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.328]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.328]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.328]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.328]                       "release", "version")], collapse = " "), 
  [14:20:57.328]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.328]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.328]                     info)
  [14:20:57.328]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.328]                   if (!has_future) {
  [14:20:57.328]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.328]                       info)
  [14:20:57.328]                   }
  [14:20:57.328]                   else {
  [14:20:57.328]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.328]                       info, version)
  [14:20:57.328]                   }
  [14:20:57.328]                   base::stop(msg)
  [14:20:57.328]                 }
  [14:20:57.328]             }
  [14:20:57.328]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.328]         }
  [14:20:57.328]     }
  [14:20:57.328]     if (base::is.na(TRUE)) {
  [14:20:57.328]     }
  [14:20:57.328]     else {
  [14:20:57.328]         if (TRUE) {
  [14:20:57.328]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.328]                 open = "w")
  [14:20:57.328]         }
  [14:20:57.328]         else {
  [14:20:57.328]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.328]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.328]         }
  [14:20:57.328]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.328]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.328]             base::sink(type = "output", split = FALSE)
  [14:20:57.328]             base::close(...future.stdout)
  [14:20:57.328]         }, add = TRUE)
  [14:20:57.328]     }
  [14:20:57.328]     ...future.frame <- base::sys.nframe()
  [14:20:57.328]     ...future.conditions <- base::list()
  [14:20:57.328]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.328]     ...future.result <- base::tryCatch({
  [14:20:57.328]         base::withCallingHandlers({
  [14:20:57.328]             ...future.value <- base::withVisible(base::local(2))
  [14:20:57.328]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.328]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.328]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.328]                 version = "1.8")
  [14:20:57.328]         }, condition = base::local({
  [14:20:57.328]             c <- base::c
  [14:20:57.328]             inherits <- base::inherits
  [14:20:57.328]             invokeRestart <- base::invokeRestart
  [14:20:57.328]             length <- base::length
  [14:20:57.328]             list <- base::list
  [14:20:57.328]             seq.int <- base::seq.int
  [14:20:57.328]             signalCondition <- base::signalCondition
  [14:20:57.328]             sys.calls <- base::sys.calls
  [14:20:57.328]             Sys.time <- base::Sys.time
  [14:20:57.328]             `[[` <- base::`[[`
  [14:20:57.328]             `+` <- base::`+`
  [14:20:57.328]             `<<-` <- base::`<<-`
  [14:20:57.328]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.328]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.328]                   3L)]
  [14:20:57.328]             }
  [14:20:57.328]             function(cond) {
  [14:20:57.328]                 if (inherits(cond, "error")) {
  [14:20:57.328]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.328]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.328]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.328]                   signalCondition(cond)
  [14:20:57.328]                 }
  [14:20:57.328]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.328]                 ))) {
  [14:20:57.328]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.328]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.328]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.328]                   if (!signal) {
  [14:20:57.328]                     muffleCondition <- function (cond) 
  [14:20:57.328]                     {
  [14:20:57.328]                       inherits <- base::inherits
  [14:20:57.328]                       invokeRestart <- base::invokeRestart
  [14:20:57.328]                       muffled <- FALSE
  [14:20:57.328]                       if (inherits(cond, "message")) {
  [14:20:57.328]                         invokeRestart("muffleMessage")
  [14:20:57.328]                         muffled <- TRUE
  [14:20:57.328]                       }
  [14:20:57.328]                       else if (inherits(cond, "warning")) {
  [14:20:57.328]                         invokeRestart("muffleWarning")
  [14:20:57.328]                         muffled <- TRUE
  [14:20:57.328]                       }
  [14:20:57.328]                       else if (inherits(cond, "condition")) {
  [14:20:57.328]                         computeRestarts <- base::computeRestarts
  [14:20:57.328]                         grepl <- base::grepl
  [14:20:57.328]                         is.null <- base::is.null
  [14:20:57.328]                         restarts <- computeRestarts(cond)
  [14:20:57.328]                         for (restart in restarts) {
  [14:20:57.328]                           name <- restart$name
  [14:20:57.328]                           if (is.null(name)) 
  [14:20:57.328]                             next
  [14:20:57.328]                           if (!grepl("^muffle", name)) 
  [14:20:57.328]                             next
  [14:20:57.328]                           invokeRestart(restart)
  [14:20:57.328]                           muffled <- TRUE
  [14:20:57.328]                           break
  [14:20:57.328]                         }
  [14:20:57.328]                       }
  [14:20:57.328]                       invisible(muffled)
  [14:20:57.328]                     }
  [14:20:57.328]                     muffleCondition(cond)
  [14:20:57.328]                   }
  [14:20:57.328]                 }
  [14:20:57.328]             }
  [14:20:57.328]         }))
  [14:20:57.328]     }, error = function(ex) {
  [14:20:57.328]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.328]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.328]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.328]     }, finally = {
  [14:20:57.328]         {
  [14:20:57.328]             NULL
  [14:20:57.328]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.328]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.328]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.328]                 label = NULL, ...) 
  [14:20:57.328]             {
  [14:20:57.328]                 if (substitute) 
  [14:20:57.328]                   expr <- substitute(expr)
  [14:20:57.328]                 local <- as.logical(local)
  [14:20:57.328]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.328]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.328]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.328]                   label = label, ...)
  [14:20:57.328]                 if (!future$lazy) 
  [14:20:57.328]                   future <- run(future)
  [14:20:57.328]                 invisible(future)
  [14:20:57.328]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.328]         }
  [14:20:57.328]         base::options(...future.oldOptions)
  [14:20:57.328]     })
  [14:20:57.328]     Sys.time
  [14:20:57.328]     if (base::is.na(TRUE)) {
  [14:20:57.328]     }
  [14:20:57.328]     else {
  [14:20:57.328]         base::sink(type = "output", split = FALSE)
  [14:20:57.328]         if (TRUE) {
  [14:20:57.328]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.328]         }
  [14:20:57.328]         else {
  [14:20:57.328]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.328]         }
  [14:20:57.328]         base::close(...future.stdout)
  [14:20:57.328]         ...future.stdout <- NULL
  [14:20:57.328]     }
  [14:20:57.328]     ...future.result$conditions <- ...future.conditions
  [14:20:57.328]     ...future.result
  [14:20:57.328] }
  [14:20:57.334] plan(): Setting new future strategy stack:
  [14:20:57.334] List of future strategies:
  [14:20:57.334] 1. sequential:
  [14:20:57.334]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.334]    - tweaked: FALSE
  [14:20:57.334]    - call: NULL
  [14:20:57.335] plan(): nbrOfWorkers() = 1
  [14:20:57.337] plan(): Setting new future strategy stack:
  [14:20:57.337] List of future strategies:
  [14:20:57.337] 1. sequential:
  [14:20:57.337]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.337]    - tweaked: FALSE
  [14:20:57.337]    - call: plan(strategy)
  [14:20:57.338] plan(): nbrOfWorkers() = 1
  [14:20:57.339] SequentialFuture started (and completed)
  [14:20:57.339] getGlobalsAndPackages() ...
  [14:20:57.339] Searching for globals...
  [14:20:57.340] 
  [14:20:57.341] Searching for globals ... DONE
  [14:20:57.341] - globals: [0] <none>
  [14:20:57.341] getGlobalsAndPackages() ... DONE
  [14:20:57.343] Packages needed by the future expression (n = 0): <none>
  [14:20:57.344] Packages needed by future strategies (n = 0): <none>
  [14:20:57.349] {
  [14:20:57.349]     {
  [14:20:57.349]         ...future.startTime <- base::Sys.time()
  [14:20:57.349]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.349]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.349]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.349]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.349]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.349]         {
  [14:20:57.349]             {
  [14:20:57.349]                 has_future <- base::requireNamespace("future", 
  [14:20:57.349]                   quietly = TRUE)
  [14:20:57.349]                 version <- if (has_future) 
  [14:20:57.349]                   utils::packageVersion("future")
  [14:20:57.349]                 else NULL
  [14:20:57.349]                 if (!has_future || version < "1.8.0") {
  [14:20:57.349]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.349]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.349]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.349]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.349]                       "release", "version")], collapse = " "), 
  [14:20:57.349]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.349]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.349]                     info)
  [14:20:57.349]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.349]                   if (!has_future) {
  [14:20:57.349]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.349]                       info)
  [14:20:57.349]                   }
  [14:20:57.349]                   else {
  [14:20:57.349]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.349]                       info, version)
  [14:20:57.349]                   }
  [14:20:57.349]                   base::stop(msg)
  [14:20:57.349]                 }
  [14:20:57.349]             }
  [14:20:57.349]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.349]         }
  [14:20:57.349]     }
  [14:20:57.349]     if (base::is.na(TRUE)) {
  [14:20:57.349]     }
  [14:20:57.349]     else {
  [14:20:57.349]         if (TRUE) {
  [14:20:57.349]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.349]                 open = "w")
  [14:20:57.349]         }
  [14:20:57.349]         else {
  [14:20:57.349]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.349]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.349]         }
  [14:20:57.349]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.349]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.349]             base::sink(type = "output", split = FALSE)
  [14:20:57.349]             base::close(...future.stdout)
  [14:20:57.349]         }, add = TRUE)
  [14:20:57.349]     }
  [14:20:57.349]     ...future.frame <- base::sys.nframe()
  [14:20:57.349]     ...future.conditions <- base::list()
  [14:20:57.349]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.349]     ...future.result <- base::tryCatch({
  [14:20:57.349]         base::withCallingHandlers({
  [14:20:57.349]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:57.349]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.349]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.349]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.349]                 version = "1.8")
  [14:20:57.349]         }, condition = base::local({
  [14:20:57.349]             c <- base::c
  [14:20:57.349]             inherits <- base::inherits
  [14:20:57.349]             invokeRestart <- base::invokeRestart
  [14:20:57.349]             length <- base::length
  [14:20:57.349]             list <- base::list
  [14:20:57.349]             seq.int <- base::seq.int
  [14:20:57.349]             signalCondition <- base::signalCondition
  [14:20:57.349]             sys.calls <- base::sys.calls
  [14:20:57.349]             Sys.time <- base::Sys.time
  [14:20:57.349]             `[[` <- base::`[[`
  [14:20:57.349]             `+` <- base::`+`
  [14:20:57.349]             `<<-` <- base::`<<-`
  [14:20:57.349]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.349]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.349]                   3L)]
  [14:20:57.349]             }
  [14:20:57.349]             function(cond) {
  [14:20:57.349]                 if (inherits(cond, "error")) {
  [14:20:57.349]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.349]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.349]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.349]                   signalCondition(cond)
  [14:20:57.349]                 }
  [14:20:57.349]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.349]                 ))) {
  [14:20:57.349]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.349]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.349]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.349]                   if (!signal) {
  [14:20:57.349]                     muffleCondition <- function (cond) 
  [14:20:57.349]                     {
  [14:20:57.349]                       inherits <- base::inherits
  [14:20:57.349]                       invokeRestart <- base::invokeRestart
  [14:20:57.349]                       muffled <- FALSE
  [14:20:57.349]                       if (inherits(cond, "message")) {
  [14:20:57.349]                         invokeRestart("muffleMessage")
  [14:20:57.349]                         muffled <- TRUE
  [14:20:57.349]                       }
  [14:20:57.349]                       else if (inherits(cond, "warning")) {
  [14:20:57.349]                         invokeRestart("muffleWarning")
  [14:20:57.349]                         muffled <- TRUE
  [14:20:57.349]                       }
  [14:20:57.349]                       else if (inherits(cond, "condition")) {
  [14:20:57.349]                         computeRestarts <- base::computeRestarts
  [14:20:57.349]                         grepl <- base::grepl
  [14:20:57.349]                         is.null <- base::is.null
  [14:20:57.349]                         restarts <- computeRestarts(cond)
  [14:20:57.349]                         for (restart in restarts) {
  [14:20:57.349]                           name <- restart$name
  [14:20:57.349]                           if (is.null(name)) 
  [14:20:57.349]                             next
  [14:20:57.349]                           if (!grepl("^muffle", name)) 
  [14:20:57.349]                             next
  [14:20:57.349]                           invokeRestart(restart)
  [14:20:57.349]                           muffled <- TRUE
  [14:20:57.349]                           break
  [14:20:57.349]                         }
  [14:20:57.349]                       }
  [14:20:57.349]                       invisible(muffled)
  [14:20:57.349]                     }
  [14:20:57.349]                     muffleCondition(cond)
  [14:20:57.349]                   }
  [14:20:57.349]                 }
  [14:20:57.349]             }
  [14:20:57.349]         }))
  [14:20:57.349]     }, error = function(ex) {
  [14:20:57.349]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.349]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.349]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.349]     }, finally = {
  [14:20:57.349]         {
  [14:20:57.349]             NULL
  [14:20:57.349]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.349]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.349]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.349]                 label = NULL, ...) 
  [14:20:57.349]             {
  [14:20:57.349]                 if (substitute) 
  [14:20:57.349]                   expr <- substitute(expr)
  [14:20:57.349]                 local <- as.logical(local)
  [14:20:57.349]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.349]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.349]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.349]                   label = label, ...)
  [14:20:57.349]                 if (!future$lazy) 
  [14:20:57.349]                   future <- run(future)
  [14:20:57.349]                 invisible(future)
  [14:20:57.349]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.349]         }
  [14:20:57.349]         base::options(...future.oldOptions)
  [14:20:57.349]     })
  [14:20:57.349]     Sys.time
  [14:20:57.349]     if (base::is.na(TRUE)) {
  [14:20:57.349]     }
  [14:20:57.349]     else {
  [14:20:57.349]         base::sink(type = "output", split = FALSE)
  [14:20:57.349]         if (TRUE) {
  [14:20:57.349]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.349]         }
  [14:20:57.349]         else {
  [14:20:57.349]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.349]         }
  [14:20:57.349]         base::close(...future.stdout)
  [14:20:57.349]         ...future.stdout <- NULL
  [14:20:57.349]     }
  [14:20:57.349]     ...future.result$conditions <- ...future.conditions
  [14:20:57.349]     ...future.result
  [14:20:57.349] }
  [14:20:57.355] plan(): Setting new future strategy stack:
  [14:20:57.355] List of future strategies:
  [14:20:57.355] 1. sequential:
  [14:20:57.355]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.355]    - tweaked: FALSE
  [14:20:57.355]    - call: NULL
  [14:20:57.356] plan(): nbrOfWorkers() = 1
  [14:20:57.358] plan(): Setting new future strategy stack:
  [14:20:57.358] List of future strategies:
  [14:20:57.358] 1. sequential:
  [14:20:57.358]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.358]    - tweaked: FALSE
  [14:20:57.358]    - call: plan(strategy)
  [14:20:57.359] plan(): nbrOfWorkers() = 1
  [14:20:57.360] SequentialFuture started (and completed)
  [14:20:57.363] getGlobalsAndPackages() ...
  [14:20:57.364] Searching for globals...
  [14:20:57.369] - globals found: [1] '{'
  [14:20:57.370] Searching for globals ... DONE
  [14:20:57.370] Resolving globals: FALSE
  [14:20:57.372] 
  [14:20:57.372] 
  [14:20:57.372] getGlobalsAndPackages() ... DONE
  [14:20:57.374] Packages needed by the future expression (n = 0): <none>
  [14:20:57.375] Packages needed by future strategies (n = 0): <none>
  [14:20:57.380] {
  [14:20:57.380]     {
  [14:20:57.380]         ...future.startTime <- base::Sys.time()
  [14:20:57.380]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.380]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.380]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.380]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.380]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.380]         {
  [14:20:57.380]             {
  [14:20:57.380]                 has_future <- base::requireNamespace("future", 
  [14:20:57.380]                   quietly = TRUE)
  [14:20:57.380]                 version <- if (has_future) 
  [14:20:57.380]                   utils::packageVersion("future")
  [14:20:57.380]                 else NULL
  [14:20:57.380]                 if (!has_future || version < "1.8.0") {
  [14:20:57.380]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.380]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.380]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.380]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.380]                       "release", "version")], collapse = " "), 
  [14:20:57.380]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.380]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.380]                     info)
  [14:20:57.380]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.380]                   if (!has_future) {
  [14:20:57.380]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.380]                       info)
  [14:20:57.380]                   }
  [14:20:57.380]                   else {
  [14:20:57.380]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.380]                       info, version)
  [14:20:57.380]                   }
  [14:20:57.380]                   base::stop(msg)
  [14:20:57.380]                 }
  [14:20:57.380]             }
  [14:20:57.380]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.380]         }
  [14:20:57.380]     }
  [14:20:57.380]     if (base::is.na(TRUE)) {
  [14:20:57.380]     }
  [14:20:57.380]     else {
  [14:20:57.380]         if (TRUE) {
  [14:20:57.380]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.380]                 open = "w")
  [14:20:57.380]         }
  [14:20:57.380]         else {
  [14:20:57.380]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.380]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.380]         }
  [14:20:57.380]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.380]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.380]             base::sink(type = "output", split = FALSE)
  [14:20:57.380]             base::close(...future.stdout)
  [14:20:57.380]         }, add = TRUE)
  [14:20:57.380]     }
  [14:20:57.380]     ...future.frame <- base::sys.nframe()
  [14:20:57.380]     ...future.conditions <- base::list()
  [14:20:57.380]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.380]     ...future.result <- base::tryCatch({
  [14:20:57.380]         base::withCallingHandlers({
  [14:20:57.380]             ...future.value <- base::withVisible(base::local({
  [14:20:57.380]                 4
  [14:20:57.380]             }))
  [14:20:57.380]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.380]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.380]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.380]                 version = "1.8")
  [14:20:57.380]         }, condition = base::local({
  [14:20:57.380]             c <- base::c
  [14:20:57.380]             inherits <- base::inherits
  [14:20:57.380]             invokeRestart <- base::invokeRestart
  [14:20:57.380]             length <- base::length
  [14:20:57.380]             list <- base::list
  [14:20:57.380]             seq.int <- base::seq.int
  [14:20:57.380]             signalCondition <- base::signalCondition
  [14:20:57.380]             sys.calls <- base::sys.calls
  [14:20:57.380]             Sys.time <- base::Sys.time
  [14:20:57.380]             `[[` <- base::`[[`
  [14:20:57.380]             `+` <- base::`+`
  [14:20:57.380]             `<<-` <- base::`<<-`
  [14:20:57.380]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.380]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.380]                   3L)]
  [14:20:57.380]             }
  [14:20:57.380]             function(cond) {
  [14:20:57.380]                 if (inherits(cond, "error")) {
  [14:20:57.380]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.380]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.380]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.380]                   signalCondition(cond)
  [14:20:57.380]                 }
  [14:20:57.380]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.380]                 ))) {
  [14:20:57.380]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.380]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.380]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.380]                   if (!signal) {
  [14:20:57.380]                     muffleCondition <- function (cond) 
  [14:20:57.380]                     {
  [14:20:57.380]                       inherits <- base::inherits
  [14:20:57.380]                       invokeRestart <- base::invokeRestart
  [14:20:57.380]                       muffled <- FALSE
  [14:20:57.380]                       if (inherits(cond, "message")) {
  [14:20:57.380]                         invokeRestart("muffleMessage")
  [14:20:57.380]                         muffled <- TRUE
  [14:20:57.380]                       }
  [14:20:57.380]                       else if (inherits(cond, "warning")) {
  [14:20:57.380]                         invokeRestart("muffleWarning")
  [14:20:57.380]                         muffled <- TRUE
  [14:20:57.380]                       }
  [14:20:57.380]                       else if (inherits(cond, "condition")) {
  [14:20:57.380]                         computeRestarts <- base::computeRestarts
  [14:20:57.380]                         grepl <- base::grepl
  [14:20:57.380]                         is.null <- base::is.null
  [14:20:57.380]                         restarts <- computeRestarts(cond)
  [14:20:57.380]                         for (restart in restarts) {
  [14:20:57.380]                           name <- restart$name
  [14:20:57.380]                           if (is.null(name)) 
  [14:20:57.380]                             next
  [14:20:57.380]                           if (!grepl("^muffle", name)) 
  [14:20:57.380]                             next
  [14:20:57.380]                           invokeRestart(restart)
  [14:20:57.380]                           muffled <- TRUE
  [14:20:57.380]                           break
  [14:20:57.380]                         }
  [14:20:57.380]                       }
  [14:20:57.380]                       invisible(muffled)
  [14:20:57.380]                     }
  [14:20:57.380]                     muffleCondition(cond)
  [14:20:57.380]                   }
  [14:20:57.380]                 }
  [14:20:57.380]             }
  [14:20:57.380]         }))
  [14:20:57.380]     }, error = function(ex) {
  [14:20:57.380]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.380]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.380]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.380]     }, finally = {
  [14:20:57.380]         {
  [14:20:57.380]             NULL
  [14:20:57.380]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.380]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.380]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.380]                 label = NULL, ...) 
  [14:20:57.380]             {
  [14:20:57.380]                 if (substitute) 
  [14:20:57.380]                   expr <- substitute(expr)
  [14:20:57.380]                 local <- as.logical(local)
  [14:20:57.380]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.380]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.380]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.380]                   label = label, ...)
  [14:20:57.380]                 if (!future$lazy) 
  [14:20:57.380]                   future <- run(future)
  [14:20:57.380]                 invisible(future)
  [14:20:57.380]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.380]         }
  [14:20:57.380]         base::options(...future.oldOptions)
  [14:20:57.380]     })
  [14:20:57.380]     Sys.time
  [14:20:57.380]     if (base::is.na(TRUE)) {
  [14:20:57.380]     }
  [14:20:57.380]     else {
  [14:20:57.380]         base::sink(type = "output", split = FALSE)
  [14:20:57.380]         if (TRUE) {
  [14:20:57.380]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.380]         }
  [14:20:57.380]         else {
  [14:20:57.380]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.380]         }
  [14:20:57.380]         base::close(...future.stdout)
  [14:20:57.380]         ...future.stdout <- NULL
  [14:20:57.380]     }
  [14:20:57.380]     ...future.result$conditions <- ...future.conditions
  [14:20:57.380]     ...future.result
  [14:20:57.380] }
  [14:20:57.387] plan(): Setting new future strategy stack:
  [14:20:57.387] List of future strategies:
  [14:20:57.387] 1. sequential:
  [14:20:57.387]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.387]    - tweaked: FALSE
  [14:20:57.387]    - call: NULL
  [14:20:57.388] plan(): nbrOfWorkers() = 1
  [14:20:57.389] plan(): Setting new future strategy stack:
  [14:20:57.390] List of future strategies:
  [14:20:57.390] 1. sequential:
  [14:20:57.390]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.390]    - tweaked: FALSE
  [14:20:57.390]    - call: plan(strategy)
  [14:20:57.391] plan(): nbrOfWorkers() = 1
  [14:20:57.397] SequentialFuture started (and completed)
  <environment: 0x5574f913f030> 
  <environment: 0x5574fa6dc000> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:20:57.405] resolve() on environment ...
  [14:20:57.406]  recursive: 0
  [14:20:57.407]  elements: [4] 'a', 'b', 'c', 'd'
  [14:20:57.408] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.408] - nx: 4
  [14:20:57.408] - relay: TRUE
  [14:20:57.408] - stdout: TRUE
  [14:20:57.409] - signal: TRUE
  [14:20:57.410] - resignal: FALSE
  [14:20:57.410] - force: TRUE
  [14:20:57.411] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.411] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.411]  - until=2
  [14:20:57.412]  - relaying element #2
  [14:20:57.412] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.412] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.413] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.413]  length: 3 (resolved future 1)
  [14:20:57.413] Future #2
  [14:20:57.414] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:57.414] - nx: 4
  [14:20:57.415] - relay: TRUE
  [14:20:57.415] - stdout: TRUE
  [14:20:57.415] - signal: TRUE
  [14:20:57.415] - resignal: FALSE
  [14:20:57.416] - force: TRUE
  [14:20:57.416] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.416] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.417]  - until=2
  [14:20:57.417]  - relaying element #2
  [14:20:57.418] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.418] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.418] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:57.419]  length: 2 (resolved future 2)
  [14:20:57.419] Future #3
  [14:20:57.420] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:57.420] - nx: 4
  [14:20:57.420] - relay: TRUE
  [14:20:57.420] - stdout: TRUE
  [14:20:57.421] - signal: TRUE
  [14:20:57.421] - resignal: FALSE
  [14:20:57.421] - force: TRUE
  [14:20:57.422] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.422] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.422]  - until=3
  [14:20:57.423]  - relaying element #3
  [14:20:57.423] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.424] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.424] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:57.424]  length: 1 (resolved future 3)
  [14:20:57.425] Future #4
  [14:20:57.425] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:20:57.425] - nx: 4
  [14:20:57.426] - relay: TRUE
  [14:20:57.426] - stdout: TRUE
  [14:20:57.426] - signal: TRUE
  [14:20:57.427] - resignal: FALSE
  [14:20:57.427] - force: TRUE
  [14:20:57.427] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.428] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.428]  - until=4
  [14:20:57.428]  - relaying element #4
  [14:20:57.429] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.429] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.430] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:20:57.430]  length: 0 (resolved future 4)
  [14:20:57.430] Relaying remaining futures
  [14:20:57.431] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.431] - nx: 4
  [14:20:57.431] - relay: TRUE
  [14:20:57.431] - stdout: TRUE
  [14:20:57.432] - signal: TRUE
  [14:20:57.432] - resignal: FALSE
  [14:20:57.432] - force: TRUE
  [14:20:57.433] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.433] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:20:57.434] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.434] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.434] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.435] resolve() on environment ... DONE
  <environment: 0x5574f912ed90> 
  Dimensions: c(1, 6)
  [14:20:57.436] getGlobalsAndPackages() ...
  [14:20:57.437] Searching for globals...
  [14:20:57.437] 
  [14:20:57.438] Searching for globals ... DONE
  [14:20:57.438] - globals: [0] <none>
  [14:20:57.439] getGlobalsAndPackages() ... DONE
  [14:20:57.441] Packages needed by the future expression (n = 0): <none>
  [14:20:57.441] Packages needed by future strategies (n = 0): <none>
  [14:20:57.446] {
  [14:20:57.446]     {
  [14:20:57.446]         ...future.startTime <- base::Sys.time()
  [14:20:57.446]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.446]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.446]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.446]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.446]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.446]         {
  [14:20:57.446]             {
  [14:20:57.446]                 has_future <- base::requireNamespace("future", 
  [14:20:57.446]                   quietly = TRUE)
  [14:20:57.446]                 version <- if (has_future) 
  [14:20:57.446]                   utils::packageVersion("future")
  [14:20:57.446]                 else NULL
  [14:20:57.446]                 if (!has_future || version < "1.8.0") {
  [14:20:57.446]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.446]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.446]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.446]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.446]                       "release", "version")], collapse = " "), 
  [14:20:57.446]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.446]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.446]                     info)
  [14:20:57.446]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.446]                   if (!has_future) {
  [14:20:57.446]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.446]                       info)
  [14:20:57.446]                   }
  [14:20:57.446]                   else {
  [14:20:57.446]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.446]                       info, version)
  [14:20:57.446]                   }
  [14:20:57.446]                   base::stop(msg)
  [14:20:57.446]                 }
  [14:20:57.446]             }
  [14:20:57.446]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.446]         }
  [14:20:57.446]     }
  [14:20:57.446]     if (base::is.na(TRUE)) {
  [14:20:57.446]     }
  [14:20:57.446]     else {
  [14:20:57.446]         if (TRUE) {
  [14:20:57.446]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.446]                 open = "w")
  [14:20:57.446]         }
  [14:20:57.446]         else {
  [14:20:57.446]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.446]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.446]         }
  [14:20:57.446]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.446]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.446]             base::sink(type = "output", split = FALSE)
  [14:20:57.446]             base::close(...future.stdout)
  [14:20:57.446]         }, add = TRUE)
  [14:20:57.446]     }
  [14:20:57.446]     ...future.frame <- base::sys.nframe()
  [14:20:57.446]     ...future.conditions <- base::list()
  [14:20:57.446]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.446]     ...future.result <- base::tryCatch({
  [14:20:57.446]         base::withCallingHandlers({
  [14:20:57.446]             ...future.value <- base::withVisible(base::local(2))
  [14:20:57.446]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.446]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.446]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.446]                 version = "1.8")
  [14:20:57.446]         }, condition = base::local({
  [14:20:57.446]             c <- base::c
  [14:20:57.446]             inherits <- base::inherits
  [14:20:57.446]             invokeRestart <- base::invokeRestart
  [14:20:57.446]             length <- base::length
  [14:20:57.446]             list <- base::list
  [14:20:57.446]             seq.int <- base::seq.int
  [14:20:57.446]             signalCondition <- base::signalCondition
  [14:20:57.446]             sys.calls <- base::sys.calls
  [14:20:57.446]             Sys.time <- base::Sys.time
  [14:20:57.446]             `[[` <- base::`[[`
  [14:20:57.446]             `+` <- base::`+`
  [14:20:57.446]             `<<-` <- base::`<<-`
  [14:20:57.446]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.446]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.446]                   3L)]
  [14:20:57.446]             }
  [14:20:57.446]             function(cond) {
  [14:20:57.446]                 if (inherits(cond, "error")) {
  [14:20:57.446]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.446]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.446]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.446]                   signalCondition(cond)
  [14:20:57.446]                 }
  [14:20:57.446]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.446]                 ))) {
  [14:20:57.446]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.446]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.446]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.446]                   if (!signal) {
  [14:20:57.446]                     muffleCondition <- function (cond) 
  [14:20:57.446]                     {
  [14:20:57.446]                       inherits <- base::inherits
  [14:20:57.446]                       invokeRestart <- base::invokeRestart
  [14:20:57.446]                       muffled <- FALSE
  [14:20:57.446]                       if (inherits(cond, "message")) {
  [14:20:57.446]                         invokeRestart("muffleMessage")
  [14:20:57.446]                         muffled <- TRUE
  [14:20:57.446]                       }
  [14:20:57.446]                       else if (inherits(cond, "warning")) {
  [14:20:57.446]                         invokeRestart("muffleWarning")
  [14:20:57.446]                         muffled <- TRUE
  [14:20:57.446]                       }
  [14:20:57.446]                       else if (inherits(cond, "condition")) {
  [14:20:57.446]                         computeRestarts <- base::computeRestarts
  [14:20:57.446]                         grepl <- base::grepl
  [14:20:57.446]                         is.null <- base::is.null
  [14:20:57.446]                         restarts <- computeRestarts(cond)
  [14:20:57.446]                         for (restart in restarts) {
  [14:20:57.446]                           name <- restart$name
  [14:20:57.446]                           if (is.null(name)) 
  [14:20:57.446]                             next
  [14:20:57.446]                           if (!grepl("^muffle", name)) 
  [14:20:57.446]                             next
  [14:20:57.446]                           invokeRestart(restart)
  [14:20:57.446]                           muffled <- TRUE
  [14:20:57.446]                           break
  [14:20:57.446]                         }
  [14:20:57.446]                       }
  [14:20:57.446]                       invisible(muffled)
  [14:20:57.446]                     }
  [14:20:57.446]                     muffleCondition(cond)
  [14:20:57.446]                   }
  [14:20:57.446]                 }
  [14:20:57.446]             }
  [14:20:57.446]         }))
  [14:20:57.446]     }, error = function(ex) {
  [14:20:57.446]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.446]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.446]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.446]     }, finally = {
  [14:20:57.446]         {
  [14:20:57.446]             NULL
  [14:20:57.446]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.446]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.446]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.446]                 label = NULL, ...) 
  [14:20:57.446]             {
  [14:20:57.446]                 if (substitute) 
  [14:20:57.446]                   expr <- substitute(expr)
  [14:20:57.446]                 local <- as.logical(local)
  [14:20:57.446]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.446]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.446]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.446]                   label = label, ...)
  [14:20:57.446]                 if (!future$lazy) 
  [14:20:57.446]                   future <- run(future)
  [14:20:57.446]                 invisible(future)
  [14:20:57.446]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.446]         }
  [14:20:57.446]         base::options(...future.oldOptions)
  [14:20:57.446]     })
  [14:20:57.446]     Sys.time
  [14:20:57.446]     if (base::is.na(TRUE)) {
  [14:20:57.446]     }
  [14:20:57.446]     else {
  [14:20:57.446]         base::sink(type = "output", split = FALSE)
  [14:20:57.446]         if (TRUE) {
  [14:20:57.446]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.446]         }
  [14:20:57.446]         else {
  [14:20:57.446]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.446]         }
  [14:20:57.446]         base::close(...future.stdout)
  [14:20:57.446]         ...future.stdout <- NULL
  [14:20:57.446]     }
  [14:20:57.446]     ...future.result$conditions <- ...future.conditions
  [14:20:57.446]     ...future.result
  [14:20:57.446] }
  [14:20:57.452] plan(): Setting new future strategy stack:
  [14:20:57.453] List of future strategies:
  [14:20:57.453] 1. sequential:
  [14:20:57.453]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.453]    - tweaked: FALSE
  [14:20:57.453]    - call: NULL
  [14:20:57.454] plan(): nbrOfWorkers() = 1
  [14:20:57.455] plan(): Setting new future strategy stack:
  [14:20:57.455] List of future strategies:
  [14:20:57.455] 1. sequential:
  [14:20:57.455]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.455]    - tweaked: FALSE
  [14:20:57.455]    - call: plan(strategy)
  [14:20:57.456] plan(): nbrOfWorkers() = 1
  [14:20:57.457] SequentialFuture started (and completed)
  [14:20:57.458] getGlobalsAndPackages() ...
  [14:20:57.458] Searching for globals...
  [14:20:57.459] 
  [14:20:57.459] Searching for globals ... DONE
  [14:20:57.460] - globals: [0] <none>
  [14:20:57.460] getGlobalsAndPackages() ... DONE
  [14:20:57.462] Packages needed by the future expression (n = 0): <none>
  [14:20:57.463] Packages needed by future strategies (n = 0): <none>
  [14:20:57.473] {
  [14:20:57.473]     {
  [14:20:57.473]         ...future.startTime <- base::Sys.time()
  [14:20:57.473]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.473]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.473]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.473]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.473]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.473]         {
  [14:20:57.473]             {
  [14:20:57.473]                 has_future <- base::requireNamespace("future", 
  [14:20:57.473]                   quietly = TRUE)
  [14:20:57.473]                 version <- if (has_future) 
  [14:20:57.473]                   utils::packageVersion("future")
  [14:20:57.473]                 else NULL
  [14:20:57.473]                 if (!has_future || version < "1.8.0") {
  [14:20:57.473]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.473]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.473]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.473]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.473]                       "release", "version")], collapse = " "), 
  [14:20:57.473]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.473]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.473]                     info)
  [14:20:57.473]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.473]                   if (!has_future) {
  [14:20:57.473]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.473]                       info)
  [14:20:57.473]                   }
  [14:20:57.473]                   else {
  [14:20:57.473]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.473]                       info, version)
  [14:20:57.473]                   }
  [14:20:57.473]                   base::stop(msg)
  [14:20:57.473]                 }
  [14:20:57.473]             }
  [14:20:57.473]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.473]         }
  [14:20:57.473]     }
  [14:20:57.473]     if (base::is.na(TRUE)) {
  [14:20:57.473]     }
  [14:20:57.473]     else {
  [14:20:57.473]         if (TRUE) {
  [14:20:57.473]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.473]                 open = "w")
  [14:20:57.473]         }
  [14:20:57.473]         else {
  [14:20:57.473]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.473]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.473]         }
  [14:20:57.473]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.473]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.473]             base::sink(type = "output", split = FALSE)
  [14:20:57.473]             base::close(...future.stdout)
  [14:20:57.473]         }, add = TRUE)
  [14:20:57.473]     }
  [14:20:57.473]     ...future.frame <- base::sys.nframe()
  [14:20:57.473]     ...future.conditions <- base::list()
  [14:20:57.473]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.473]     ...future.result <- base::tryCatch({
  [14:20:57.473]         base::withCallingHandlers({
  [14:20:57.473]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:57.473]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.473]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.473]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.473]                 version = "1.8")
  [14:20:57.473]         }, condition = base::local({
  [14:20:57.473]             c <- base::c
  [14:20:57.473]             inherits <- base::inherits
  [14:20:57.473]             invokeRestart <- base::invokeRestart
  [14:20:57.473]             length <- base::length
  [14:20:57.473]             list <- base::list
  [14:20:57.473]             seq.int <- base::seq.int
  [14:20:57.473]             signalCondition <- base::signalCondition
  [14:20:57.473]             sys.calls <- base::sys.calls
  [14:20:57.473]             Sys.time <- base::Sys.time
  [14:20:57.473]             `[[` <- base::`[[`
  [14:20:57.473]             `+` <- base::`+`
  [14:20:57.473]             `<<-` <- base::`<<-`
  [14:20:57.473]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.473]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.473]                   3L)]
  [14:20:57.473]             }
  [14:20:57.473]             function(cond) {
  [14:20:57.473]                 if (inherits(cond, "error")) {
  [14:20:57.473]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.473]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.473]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.473]                   signalCondition(cond)
  [14:20:57.473]                 }
  [14:20:57.473]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.473]                 ))) {
  [14:20:57.473]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.473]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.473]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.473]                   if (!signal) {
  [14:20:57.473]                     muffleCondition <- function (cond) 
  [14:20:57.473]                     {
  [14:20:57.473]                       inherits <- base::inherits
  [14:20:57.473]                       invokeRestart <- base::invokeRestart
  [14:20:57.473]                       muffled <- FALSE
  [14:20:57.473]                       if (inherits(cond, "message")) {
  [14:20:57.473]                         invokeRestart("muffleMessage")
  [14:20:57.473]                         muffled <- TRUE
  [14:20:57.473]                       }
  [14:20:57.473]                       else if (inherits(cond, "warning")) {
  [14:20:57.473]                         invokeRestart("muffleWarning")
  [14:20:57.473]                         muffled <- TRUE
  [14:20:57.473]                       }
  [14:20:57.473]                       else if (inherits(cond, "condition")) {
  [14:20:57.473]                         computeRestarts <- base::computeRestarts
  [14:20:57.473]                         grepl <- base::grepl
  [14:20:57.473]                         is.null <- base::is.null
  [14:20:57.473]                         restarts <- computeRestarts(cond)
  [14:20:57.473]                         for (restart in restarts) {
  [14:20:57.473]                           name <- restart$name
  [14:20:57.473]                           if (is.null(name)) 
  [14:20:57.473]                             next
  [14:20:57.473]                           if (!grepl("^muffle", name)) 
  [14:20:57.473]                             next
  [14:20:57.473]                           invokeRestart(restart)
  [14:20:57.473]                           muffled <- TRUE
  [14:20:57.473]                           break
  [14:20:57.473]                         }
  [14:20:57.473]                       }
  [14:20:57.473]                       invisible(muffled)
  [14:20:57.473]                     }
  [14:20:57.473]                     muffleCondition(cond)
  [14:20:57.473]                   }
  [14:20:57.473]                 }
  [14:20:57.473]             }
  [14:20:57.473]         }))
  [14:20:57.473]     }, error = function(ex) {
  [14:20:57.473]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.473]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.473]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.473]     }, finally = {
  [14:20:57.473]         {
  [14:20:57.473]             NULL
  [14:20:57.473]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.473]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.473]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.473]                 label = NULL, ...) 
  [14:20:57.473]             {
  [14:20:57.473]                 if (substitute) 
  [14:20:57.473]                   expr <- substitute(expr)
  [14:20:57.473]                 local <- as.logical(local)
  [14:20:57.473]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.473]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.473]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.473]                   label = label, ...)
  [14:20:57.473]                 if (!future$lazy) 
  [14:20:57.473]                   future <- run(future)
  [14:20:57.473]                 invisible(future)
  [14:20:57.473]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.473]         }
  [14:20:57.473]         base::options(...future.oldOptions)
  [14:20:57.473]     })
  [14:20:57.473]     Sys.time
  [14:20:57.473]     if (base::is.na(TRUE)) {
  [14:20:57.473]     }
  [14:20:57.473]     else {
  [14:20:57.473]         base::sink(type = "output", split = FALSE)
  [14:20:57.473]         if (TRUE) {
  [14:20:57.473]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.473]         }
  [14:20:57.473]         else {
  [14:20:57.473]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.473]         }
  [14:20:57.473]         base::close(...future.stdout)
  [14:20:57.473]         ...future.stdout <- NULL
  [14:20:57.473]     }
  [14:20:57.473]     ...future.result$conditions <- ...future.conditions
  [14:20:57.473]     ...future.result
  [14:20:57.473] }
  [14:20:57.479] plan(): Setting new future strategy stack:
  [14:20:57.480] List of future strategies:
  [14:20:57.480] 1. sequential:
  [14:20:57.480]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.480]    - tweaked: FALSE
  [14:20:57.480]    - call: NULL
  [14:20:57.481] plan(): nbrOfWorkers() = 1
  [14:20:57.482] plan(): Setting new future strategy stack:
  [14:20:57.483] List of future strategies:
  [14:20:57.483] 1. sequential:
  [14:20:57.483]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.483]    - tweaked: FALSE
  [14:20:57.483]    - call: plan(strategy)
  [14:20:57.484] plan(): nbrOfWorkers() = 1
  [14:20:57.484] SequentialFuture started (and completed)
  [14:20:57.485] getGlobalsAndPackages() ...
  [14:20:57.486] Searching for globals...
  [14:20:57.487] - globals found: [1] '{'
  [14:20:57.487] Searching for globals ... DONE
  [14:20:57.488] Resolving globals: FALSE
  [14:20:57.488] 
  [14:20:57.489] 
  [14:20:57.489] getGlobalsAndPackages() ... DONE
  [14:20:57.491] Packages needed by the future expression (n = 0): <none>
  [14:20:57.492] Packages needed by future strategies (n = 0): <none>
  [14:20:57.497] {
  [14:20:57.497]     {
  [14:20:57.497]         ...future.startTime <- base::Sys.time()
  [14:20:57.497]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.497]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.497]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.497]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.497]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.497]         {
  [14:20:57.497]             {
  [14:20:57.497]                 has_future <- base::requireNamespace("future", 
  [14:20:57.497]                   quietly = TRUE)
  [14:20:57.497]                 version <- if (has_future) 
  [14:20:57.497]                   utils::packageVersion("future")
  [14:20:57.497]                 else NULL
  [14:20:57.497]                 if (!has_future || version < "1.8.0") {
  [14:20:57.497]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.497]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.497]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.497]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.497]                       "release", "version")], collapse = " "), 
  [14:20:57.497]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.497]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.497]                     info)
  [14:20:57.497]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.497]                   if (!has_future) {
  [14:20:57.497]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.497]                       info)
  [14:20:57.497]                   }
  [14:20:57.497]                   else {
  [14:20:57.497]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.497]                       info, version)
  [14:20:57.497]                   }
  [14:20:57.497]                   base::stop(msg)
  [14:20:57.497]                 }
  [14:20:57.497]             }
  [14:20:57.497]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.497]         }
  [14:20:57.497]     }
  [14:20:57.497]     if (base::is.na(TRUE)) {
  [14:20:57.497]     }
  [14:20:57.497]     else {
  [14:20:57.497]         if (TRUE) {
  [14:20:57.497]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.497]                 open = "w")
  [14:20:57.497]         }
  [14:20:57.497]         else {
  [14:20:57.497]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.497]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.497]         }
  [14:20:57.497]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.497]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.497]             base::sink(type = "output", split = FALSE)
  [14:20:57.497]             base::close(...future.stdout)
  [14:20:57.497]         }, add = TRUE)
  [14:20:57.497]     }
  [14:20:57.497]     ...future.frame <- base::sys.nframe()
  [14:20:57.497]     ...future.conditions <- base::list()
  [14:20:57.497]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.497]     ...future.result <- base::tryCatch({
  [14:20:57.497]         base::withCallingHandlers({
  [14:20:57.497]             ...future.value <- base::withVisible(base::local({
  [14:20:57.497]                 4
  [14:20:57.497]             }))
  [14:20:57.497]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.497]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.497]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.497]                 version = "1.8")
  [14:20:57.497]         }, condition = base::local({
  [14:20:57.497]             c <- base::c
  [14:20:57.497]             inherits <- base::inherits
  [14:20:57.497]             invokeRestart <- base::invokeRestart
  [14:20:57.497]             length <- base::length
  [14:20:57.497]             list <- base::list
  [14:20:57.497]             seq.int <- base::seq.int
  [14:20:57.497]             signalCondition <- base::signalCondition
  [14:20:57.497]             sys.calls <- base::sys.calls
  [14:20:57.497]             Sys.time <- base::Sys.time
  [14:20:57.497]             `[[` <- base::`[[`
  [14:20:57.497]             `+` <- base::`+`
  [14:20:57.497]             `<<-` <- base::`<<-`
  [14:20:57.497]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.497]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.497]                   3L)]
  [14:20:57.497]             }
  [14:20:57.497]             function(cond) {
  [14:20:57.497]                 if (inherits(cond, "error")) {
  [14:20:57.497]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.497]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.497]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.497]                   signalCondition(cond)
  [14:20:57.497]                 }
  [14:20:57.497]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.497]                 ))) {
  [14:20:57.497]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.497]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.497]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.497]                   if (!signal) {
  [14:20:57.497]                     muffleCondition <- function (cond) 
  [14:20:57.497]                     {
  [14:20:57.497]                       inherits <- base::inherits
  [14:20:57.497]                       invokeRestart <- base::invokeRestart
  [14:20:57.497]                       muffled <- FALSE
  [14:20:57.497]                       if (inherits(cond, "message")) {
  [14:20:57.497]                         invokeRestart("muffleMessage")
  [14:20:57.497]                         muffled <- TRUE
  [14:20:57.497]                       }
  [14:20:57.497]                       else if (inherits(cond, "warning")) {
  [14:20:57.497]                         invokeRestart("muffleWarning")
  [14:20:57.497]                         muffled <- TRUE
  [14:20:57.497]                       }
  [14:20:57.497]                       else if (inherits(cond, "condition")) {
  [14:20:57.497]                         computeRestarts <- base::computeRestarts
  [14:20:57.497]                         grepl <- base::grepl
  [14:20:57.497]                         is.null <- base::is.null
  [14:20:57.497]                         restarts <- computeRestarts(cond)
  [14:20:57.497]                         for (restart in restarts) {
  [14:20:57.497]                           name <- restart$name
  [14:20:57.497]                           if (is.null(name)) 
  [14:20:57.497]                             next
  [14:20:57.497]                           if (!grepl("^muffle", name)) 
  [14:20:57.497]                             next
  [14:20:57.497]                           invokeRestart(restart)
  [14:20:57.497]                           muffled <- TRUE
  [14:20:57.497]                           break
  [14:20:57.497]                         }
  [14:20:57.497]                       }
  [14:20:57.497]                       invisible(muffled)
  [14:20:57.497]                     }
  [14:20:57.497]                     muffleCondition(cond)
  [14:20:57.497]                   }
  [14:20:57.497]                 }
  [14:20:57.497]             }
  [14:20:57.497]         }))
  [14:20:57.497]     }, error = function(ex) {
  [14:20:57.497]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.497]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.497]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.497]     }, finally = {
  [14:20:57.497]         {
  [14:20:57.497]             NULL
  [14:20:57.497]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.497]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.497]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.497]                 label = NULL, ...) 
  [14:20:57.497]             {
  [14:20:57.497]                 if (substitute) 
  [14:20:57.497]                   expr <- substitute(expr)
  [14:20:57.497]                 local <- as.logical(local)
  [14:20:57.497]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.497]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.497]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.497]                   label = label, ...)
  [14:20:57.497]                 if (!future$lazy) 
  [14:20:57.497]                   future <- run(future)
  [14:20:57.497]                 invisible(future)
  [14:20:57.497]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.497]         }
  [14:20:57.497]         base::options(...future.oldOptions)
  [14:20:57.497]     })
  [14:20:57.497]     Sys.time
  [14:20:57.497]     if (base::is.na(TRUE)) {
  [14:20:57.497]     }
  [14:20:57.497]     else {
  [14:20:57.497]         base::sink(type = "output", split = FALSE)
  [14:20:57.497]         if (TRUE) {
  [14:20:57.497]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.497]         }
  [14:20:57.497]         else {
  [14:20:57.497]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.497]         }
  [14:20:57.497]         base::close(...future.stdout)
  [14:20:57.497]         ...future.stdout <- NULL
  [14:20:57.497]     }
  [14:20:57.497]     ...future.result$conditions <- ...future.conditions
  [14:20:57.497]     ...future.result
  [14:20:57.497] }
  [14:20:57.503] plan(): Setting new future strategy stack:
  [14:20:57.504] List of future strategies:
  [14:20:57.504] 1. sequential:
  [14:20:57.504]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.504]    - tweaked: FALSE
  [14:20:57.504]    - call: NULL
  [14:20:57.505] plan(): nbrOfWorkers() = 1
  [14:20:57.506] plan(): Setting new future strategy stack:
  [14:20:57.506] List of future strategies:
  [14:20:57.506] 1. sequential:
  [14:20:57.506]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.506]    - tweaked: FALSE
  [14:20:57.506]    - call: plan(strategy)
  [14:20:57.507] plan(): nbrOfWorkers() = 1
  [14:20:57.508] SequentialFuture started (and completed)
  <environment: 0x5574f9f5c128> 
  <environment: 0x5574f8e317a8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:20:57.514] resolve() on environment ...
  [14:20:57.514]  recursive: 0
  [14:20:57.516]  elements: [4] 'a', 'b', 'c', 'd'
  [14:20:57.516] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.517] - nx: 4
  [14:20:57.517] - relay: TRUE
  [14:20:57.517] - stdout: TRUE
  [14:20:57.518] - signal: TRUE
  [14:20:57.518] - resignal: FALSE
  [14:20:57.518] - force: TRUE
  [14:20:57.518] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.519] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.519]  - until=2
  [14:20:57.519]  - relaying element #2
  [14:20:57.520] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.520] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.520] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.521]  length: 3 (resolved future 1)
  [14:20:57.521] Future #2
  [14:20:57.522] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:57.522] - nx: 4
  [14:20:57.522] - relay: TRUE
  [14:20:57.523] - stdout: TRUE
  [14:20:57.523] - signal: TRUE
  [14:20:57.523] - resignal: FALSE
  [14:20:57.523] - force: TRUE
  [14:20:57.524] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.524] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.524]  - until=2
  [14:20:57.525]  - relaying element #2
  [14:20:57.525] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.526] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.526] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:57.526]  length: 2 (resolved future 2)
  [14:20:57.527] Future #3
  [14:20:57.527] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:57.527] - nx: 4
  [14:20:57.528] - relay: TRUE
  [14:20:57.528] - stdout: TRUE
  [14:20:57.528] - signal: TRUE
  [14:20:57.529] - resignal: FALSE
  [14:20:57.529] - force: TRUE
  [14:20:57.529] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.530] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.530]  - until=3
  [14:20:57.530]  - relaying element #3
  [14:20:57.531] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.531] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.531] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:57.532]  length: 1 (resolved future 3)
  [14:20:57.532] Future #4
  [14:20:57.533] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:20:57.533] - nx: 4
  [14:20:57.533] - relay: TRUE
  [14:20:57.534] - stdout: TRUE
  [14:20:57.534] - signal: TRUE
  [14:20:57.534] - resignal: FALSE
  [14:20:57.534] - force: TRUE
  [14:20:57.535] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.535] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.535]  - until=4
  [14:20:57.536]  - relaying element #4
  [14:20:57.536] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.537] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.537] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:20:57.537]  length: 0 (resolved future 4)
  [14:20:57.538] Relaying remaining futures
  [14:20:57.538] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.538] - nx: 4
  [14:20:57.539] - relay: TRUE
  [14:20:57.539] - stdout: TRUE
  [14:20:57.539] - signal: TRUE
  [14:20:57.539] - resignal: FALSE
  [14:20:57.540] - force: TRUE
  [14:20:57.540] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.540] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:20:57.541] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.541] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.542] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.542] resolve() on environment ... DONE
  <environment: 0x5574f9f94f48> 
  Dimensions: c(2, 3)
  [14:20:57.543] getGlobalsAndPackages() ...
  [14:20:57.544] Searching for globals...
  [14:20:57.545] 
  [14:20:57.545] Searching for globals ... DONE
  [14:20:57.545] - globals: [0] <none>
  [14:20:57.550] getGlobalsAndPackages() ... DONE
  [14:20:57.568] Packages needed by the future expression (n = 0): <none>
  [14:20:57.569] Packages needed by future strategies (n = 0): <none>
  [14:20:57.574] {
  [14:20:57.574]     {
  [14:20:57.574]         ...future.startTime <- base::Sys.time()
  [14:20:57.574]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.574]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.574]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.574]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.574]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.574]         {
  [14:20:57.574]             {
  [14:20:57.574]                 has_future <- base::requireNamespace("future", 
  [14:20:57.574]                   quietly = TRUE)
  [14:20:57.574]                 version <- if (has_future) 
  [14:20:57.574]                   utils::packageVersion("future")
  [14:20:57.574]                 else NULL
  [14:20:57.574]                 if (!has_future || version < "1.8.0") {
  [14:20:57.574]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.574]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.574]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.574]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.574]                       "release", "version")], collapse = " "), 
  [14:20:57.574]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.574]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.574]                     info)
  [14:20:57.574]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.574]                   if (!has_future) {
  [14:20:57.574]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.574]                       info)
  [14:20:57.574]                   }
  [14:20:57.574]                   else {
  [14:20:57.574]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.574]                       info, version)
  [14:20:57.574]                   }
  [14:20:57.574]                   base::stop(msg)
  [14:20:57.574]                 }
  [14:20:57.574]             }
  [14:20:57.574]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.574]         }
  [14:20:57.574]     }
  [14:20:57.574]     if (base::is.na(TRUE)) {
  [14:20:57.574]     }
  [14:20:57.574]     else {
  [14:20:57.574]         if (TRUE) {
  [14:20:57.574]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.574]                 open = "w")
  [14:20:57.574]         }
  [14:20:57.574]         else {
  [14:20:57.574]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.574]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.574]         }
  [14:20:57.574]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.574]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.574]             base::sink(type = "output", split = FALSE)
  [14:20:57.574]             base::close(...future.stdout)
  [14:20:57.574]         }, add = TRUE)
  [14:20:57.574]     }
  [14:20:57.574]     ...future.frame <- base::sys.nframe()
  [14:20:57.574]     ...future.conditions <- base::list()
  [14:20:57.574]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.574]     ...future.result <- base::tryCatch({
  [14:20:57.574]         base::withCallingHandlers({
  [14:20:57.574]             ...future.value <- base::withVisible(base::local(2))
  [14:20:57.574]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.574]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.574]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.574]                 version = "1.8")
  [14:20:57.574]         }, condition = base::local({
  [14:20:57.574]             c <- base::c
  [14:20:57.574]             inherits <- base::inherits
  [14:20:57.574]             invokeRestart <- base::invokeRestart
  [14:20:57.574]             length <- base::length
  [14:20:57.574]             list <- base::list
  [14:20:57.574]             seq.int <- base::seq.int
  [14:20:57.574]             signalCondition <- base::signalCondition
  [14:20:57.574]             sys.calls <- base::sys.calls
  [14:20:57.574]             Sys.time <- base::Sys.time
  [14:20:57.574]             `[[` <- base::`[[`
  [14:20:57.574]             `+` <- base::`+`
  [14:20:57.574]             `<<-` <- base::`<<-`
  [14:20:57.574]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.574]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.574]                   3L)]
  [14:20:57.574]             }
  [14:20:57.574]             function(cond) {
  [14:20:57.574]                 if (inherits(cond, "error")) {
  [14:20:57.574]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.574]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.574]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.574]                   signalCondition(cond)
  [14:20:57.574]                 }
  [14:20:57.574]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.574]                 ))) {
  [14:20:57.574]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.574]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.574]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.574]                   if (!signal) {
  [14:20:57.574]                     muffleCondition <- function (cond) 
  [14:20:57.574]                     {
  [14:20:57.574]                       inherits <- base::inherits
  [14:20:57.574]                       invokeRestart <- base::invokeRestart
  [14:20:57.574]                       muffled <- FALSE
  [14:20:57.574]                       if (inherits(cond, "message")) {
  [14:20:57.574]                         invokeRestart("muffleMessage")
  [14:20:57.574]                         muffled <- TRUE
  [14:20:57.574]                       }
  [14:20:57.574]                       else if (inherits(cond, "warning")) {
  [14:20:57.574]                         invokeRestart("muffleWarning")
  [14:20:57.574]                         muffled <- TRUE
  [14:20:57.574]                       }
  [14:20:57.574]                       else if (inherits(cond, "condition")) {
  [14:20:57.574]                         computeRestarts <- base::computeRestarts
  [14:20:57.574]                         grepl <- base::grepl
  [14:20:57.574]                         is.null <- base::is.null
  [14:20:57.574]                         restarts <- computeRestarts(cond)
  [14:20:57.574]                         for (restart in restarts) {
  [14:20:57.574]                           name <- restart$name
  [14:20:57.574]                           if (is.null(name)) 
  [14:20:57.574]                             next
  [14:20:57.574]                           if (!grepl("^muffle", name)) 
  [14:20:57.574]                             next
  [14:20:57.574]                           invokeRestart(restart)
  [14:20:57.574]                           muffled <- TRUE
  [14:20:57.574]                           break
  [14:20:57.574]                         }
  [14:20:57.574]                       }
  [14:20:57.574]                       invisible(muffled)
  [14:20:57.574]                     }
  [14:20:57.574]                     muffleCondition(cond)
  [14:20:57.574]                   }
  [14:20:57.574]                 }
  [14:20:57.574]             }
  [14:20:57.574]         }))
  [14:20:57.574]     }, error = function(ex) {
  [14:20:57.574]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.574]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.574]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.574]     }, finally = {
  [14:20:57.574]         {
  [14:20:57.574]             NULL
  [14:20:57.574]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.574]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.574]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.574]                 label = NULL, ...) 
  [14:20:57.574]             {
  [14:20:57.574]                 if (substitute) 
  [14:20:57.574]                   expr <- substitute(expr)
  [14:20:57.574]                 local <- as.logical(local)
  [14:20:57.574]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.574]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.574]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.574]                   label = label, ...)
  [14:20:57.574]                 if (!future$lazy) 
  [14:20:57.574]                   future <- run(future)
  [14:20:57.574]                 invisible(future)
  [14:20:57.574]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.574]         }
  [14:20:57.574]         base::options(...future.oldOptions)
  [14:20:57.574]     })
  [14:20:57.574]     Sys.time
  [14:20:57.574]     if (base::is.na(TRUE)) {
  [14:20:57.574]     }
  [14:20:57.574]     else {
  [14:20:57.574]         base::sink(type = "output", split = FALSE)
  [14:20:57.574]         if (TRUE) {
  [14:20:57.574]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.574]         }
  [14:20:57.574]         else {
  [14:20:57.574]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.574]         }
  [14:20:57.574]         base::close(...future.stdout)
  [14:20:57.574]         ...future.stdout <- NULL
  [14:20:57.574]     }
  [14:20:57.574]     ...future.result$conditions <- ...future.conditions
  [14:20:57.574]     ...future.result
  [14:20:57.574] }
  [14:20:57.580] plan(): Setting new future strategy stack:
  [14:20:57.581] List of future strategies:
  [14:20:57.581] 1. sequential:
  [14:20:57.581]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.581]    - tweaked: FALSE
  [14:20:57.581]    - call: NULL
  [14:20:57.582] plan(): nbrOfWorkers() = 1
  [14:20:57.599] plan(): Setting new future strategy stack:
  [14:20:57.600] List of future strategies:
  [14:20:57.600] 1. sequential:
  [14:20:57.600]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.600]    - tweaked: FALSE
  [14:20:57.600]    - call: plan(strategy)
  [14:20:57.601] plan(): nbrOfWorkers() = 1
  [14:20:57.601] SequentialFuture started (and completed)
  [14:20:57.602] getGlobalsAndPackages() ...
  [14:20:57.602] Searching for globals...
  [14:20:57.603] 
  [14:20:57.603] Searching for globals ... DONE
  [14:20:57.604] - globals: [0] <none>
  [14:20:57.604] getGlobalsAndPackages() ... DONE
  [14:20:57.606] Packages needed by the future expression (n = 0): <none>
  [14:20:57.606] Packages needed by future strategies (n = 0): <none>
  [14:20:57.612] {
  [14:20:57.612]     {
  [14:20:57.612]         ...future.startTime <- base::Sys.time()
  [14:20:57.612]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.612]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.612]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.612]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.612]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.612]         {
  [14:20:57.612]             {
  [14:20:57.612]                 has_future <- base::requireNamespace("future", 
  [14:20:57.612]                   quietly = TRUE)
  [14:20:57.612]                 version <- if (has_future) 
  [14:20:57.612]                   utils::packageVersion("future")
  [14:20:57.612]                 else NULL
  [14:20:57.612]                 if (!has_future || version < "1.8.0") {
  [14:20:57.612]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.612]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.612]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.612]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.612]                       "release", "version")], collapse = " "), 
  [14:20:57.612]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.612]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.612]                     info)
  [14:20:57.612]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.612]                   if (!has_future) {
  [14:20:57.612]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.612]                       info)
  [14:20:57.612]                   }
  [14:20:57.612]                   else {
  [14:20:57.612]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.612]                       info, version)
  [14:20:57.612]                   }
  [14:20:57.612]                   base::stop(msg)
  [14:20:57.612]                 }
  [14:20:57.612]             }
  [14:20:57.612]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.612]         }
  [14:20:57.612]     }
  [14:20:57.612]     if (base::is.na(TRUE)) {
  [14:20:57.612]     }
  [14:20:57.612]     else {
  [14:20:57.612]         if (TRUE) {
  [14:20:57.612]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.612]                 open = "w")
  [14:20:57.612]         }
  [14:20:57.612]         else {
  [14:20:57.612]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.612]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.612]         }
  [14:20:57.612]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.612]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.612]             base::sink(type = "output", split = FALSE)
  [14:20:57.612]             base::close(...future.stdout)
  [14:20:57.612]         }, add = TRUE)
  [14:20:57.612]     }
  [14:20:57.612]     ...future.frame <- base::sys.nframe()
  [14:20:57.612]     ...future.conditions <- base::list()
  [14:20:57.612]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.612]     ...future.result <- base::tryCatch({
  [14:20:57.612]         base::withCallingHandlers({
  [14:20:57.612]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:57.612]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.612]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.612]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.612]                 version = "1.8")
  [14:20:57.612]         }, condition = base::local({
  [14:20:57.612]             c <- base::c
  [14:20:57.612]             inherits <- base::inherits
  [14:20:57.612]             invokeRestart <- base::invokeRestart
  [14:20:57.612]             length <- base::length
  [14:20:57.612]             list <- base::list
  [14:20:57.612]             seq.int <- base::seq.int
  [14:20:57.612]             signalCondition <- base::signalCondition
  [14:20:57.612]             sys.calls <- base::sys.calls
  [14:20:57.612]             Sys.time <- base::Sys.time
  [14:20:57.612]             `[[` <- base::`[[`
  [14:20:57.612]             `+` <- base::`+`
  [14:20:57.612]             `<<-` <- base::`<<-`
  [14:20:57.612]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.612]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.612]                   3L)]
  [14:20:57.612]             }
  [14:20:57.612]             function(cond) {
  [14:20:57.612]                 if (inherits(cond, "error")) {
  [14:20:57.612]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.612]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.612]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.612]                   signalCondition(cond)
  [14:20:57.612]                 }
  [14:20:57.612]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.612]                 ))) {
  [14:20:57.612]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.612]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.612]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.612]                   if (!signal) {
  [14:20:57.612]                     muffleCondition <- function (cond) 
  [14:20:57.612]                     {
  [14:20:57.612]                       inherits <- base::inherits
  [14:20:57.612]                       invokeRestart <- base::invokeRestart
  [14:20:57.612]                       muffled <- FALSE
  [14:20:57.612]                       if (inherits(cond, "message")) {
  [14:20:57.612]                         invokeRestart("muffleMessage")
  [14:20:57.612]                         muffled <- TRUE
  [14:20:57.612]                       }
  [14:20:57.612]                       else if (inherits(cond, "warning")) {
  [14:20:57.612]                         invokeRestart("muffleWarning")
  [14:20:57.612]                         muffled <- TRUE
  [14:20:57.612]                       }
  [14:20:57.612]                       else if (inherits(cond, "condition")) {
  [14:20:57.612]                         computeRestarts <- base::computeRestarts
  [14:20:57.612]                         grepl <- base::grepl
  [14:20:57.612]                         is.null <- base::is.null
  [14:20:57.612]                         restarts <- computeRestarts(cond)
  [14:20:57.612]                         for (restart in restarts) {
  [14:20:57.612]                           name <- restart$name
  [14:20:57.612]                           if (is.null(name)) 
  [14:20:57.612]                             next
  [14:20:57.612]                           if (!grepl("^muffle", name)) 
  [14:20:57.612]                             next
  [14:20:57.612]                           invokeRestart(restart)
  [14:20:57.612]                           muffled <- TRUE
  [14:20:57.612]                           break
  [14:20:57.612]                         }
  [14:20:57.612]                       }
  [14:20:57.612]                       invisible(muffled)
  [14:20:57.612]                     }
  [14:20:57.612]                     muffleCondition(cond)
  [14:20:57.612]                   }
  [14:20:57.612]                 }
  [14:20:57.612]             }
  [14:20:57.612]         }))
  [14:20:57.612]     }, error = function(ex) {
  [14:20:57.612]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.612]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.612]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.612]     }, finally = {
  [14:20:57.612]         {
  [14:20:57.612]             NULL
  [14:20:57.612]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.612]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.612]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.612]                 label = NULL, ...) 
  [14:20:57.612]             {
  [14:20:57.612]                 if (substitute) 
  [14:20:57.612]                   expr <- substitute(expr)
  [14:20:57.612]                 local <- as.logical(local)
  [14:20:57.612]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.612]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.612]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.612]                   label = label, ...)
  [14:20:57.612]                 if (!future$lazy) 
  [14:20:57.612]                   future <- run(future)
  [14:20:57.612]                 invisible(future)
  [14:20:57.612]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.612]         }
  [14:20:57.612]         base::options(...future.oldOptions)
  [14:20:57.612]     })
  [14:20:57.612]     Sys.time
  [14:20:57.612]     if (base::is.na(TRUE)) {
  [14:20:57.612]     }
  [14:20:57.612]     else {
  [14:20:57.612]         base::sink(type = "output", split = FALSE)
  [14:20:57.612]         if (TRUE) {
  [14:20:57.612]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.612]         }
  [14:20:57.612]         else {
  [14:20:57.612]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.612]         }
  [14:20:57.612]         base::close(...future.stdout)
  [14:20:57.612]         ...future.stdout <- NULL
  [14:20:57.612]     }
  [14:20:57.612]     ...future.result$conditions <- ...future.conditions
  [14:20:57.612]     ...future.result
  [14:20:57.612] }
  [14:20:57.634] plan(): Setting new future strategy stack:
  [14:20:57.634] List of future strategies:
  [14:20:57.634] 1. sequential:
  [14:20:57.634]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.634]    - tweaked: FALSE
  [14:20:57.634]    - call: NULL
  [14:20:57.635] plan(): nbrOfWorkers() = 1
  [14:20:57.636] plan(): Setting new future strategy stack:
  [14:20:57.637] List of future strategies:
  [14:20:57.637] 1. sequential:
  [14:20:57.637]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.637]    - tweaked: FALSE
  [14:20:57.637]    - call: plan(strategy)
  [14:20:57.638] plan(): nbrOfWorkers() = 1
  [14:20:57.638] SequentialFuture started (and completed)
  [14:20:57.639] getGlobalsAndPackages() ...
  [14:20:57.640] Searching for globals...
  [14:20:57.641] - globals found: [1] '{'
  [14:20:57.641] Searching for globals ... DONE
  [14:20:57.642] Resolving globals: FALSE
  [14:20:57.643] 
  [14:20:57.643] 
  [14:20:57.643] getGlobalsAndPackages() ... DONE
  [14:20:57.646] Packages needed by the future expression (n = 0): <none>
  [14:20:57.646] Packages needed by future strategies (n = 0): <none>
  [14:20:57.668] {
  [14:20:57.668]     {
  [14:20:57.668]         ...future.startTime <- base::Sys.time()
  [14:20:57.668]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.668]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.668]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.668]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.668]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.668]         {
  [14:20:57.668]             {
  [14:20:57.668]                 has_future <- base::requireNamespace("future", 
  [14:20:57.668]                   quietly = TRUE)
  [14:20:57.668]                 version <- if (has_future) 
  [14:20:57.668]                   utils::packageVersion("future")
  [14:20:57.668]                 else NULL
  [14:20:57.668]                 if (!has_future || version < "1.8.0") {
  [14:20:57.668]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.668]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.668]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.668]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.668]                       "release", "version")], collapse = " "), 
  [14:20:57.668]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.668]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.668]                     info)
  [14:20:57.668]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.668]                   if (!has_future) {
  [14:20:57.668]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.668]                       info)
  [14:20:57.668]                   }
  [14:20:57.668]                   else {
  [14:20:57.668]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.668]                       info, version)
  [14:20:57.668]                   }
  [14:20:57.668]                   base::stop(msg)
  [14:20:57.668]                 }
  [14:20:57.668]             }
  [14:20:57.668]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.668]         }
  [14:20:57.668]     }
  [14:20:57.668]     if (base::is.na(TRUE)) {
  [14:20:57.668]     }
  [14:20:57.668]     else {
  [14:20:57.668]         if (TRUE) {
  [14:20:57.668]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.668]                 open = "w")
  [14:20:57.668]         }
  [14:20:57.668]         else {
  [14:20:57.668]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.668]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.668]         }
  [14:20:57.668]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.668]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.668]             base::sink(type = "output", split = FALSE)
  [14:20:57.668]             base::close(...future.stdout)
  [14:20:57.668]         }, add = TRUE)
  [14:20:57.668]     }
  [14:20:57.668]     ...future.frame <- base::sys.nframe()
  [14:20:57.668]     ...future.conditions <- base::list()
  [14:20:57.668]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.668]     ...future.result <- base::tryCatch({
  [14:20:57.668]         base::withCallingHandlers({
  [14:20:57.668]             ...future.value <- base::withVisible(base::local({
  [14:20:57.668]                 4
  [14:20:57.668]             }))
  [14:20:57.668]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.668]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.668]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.668]                 version = "1.8")
  [14:20:57.668]         }, condition = base::local({
  [14:20:57.668]             c <- base::c
  [14:20:57.668]             inherits <- base::inherits
  [14:20:57.668]             invokeRestart <- base::invokeRestart
  [14:20:57.668]             length <- base::length
  [14:20:57.668]             list <- base::list
  [14:20:57.668]             seq.int <- base::seq.int
  [14:20:57.668]             signalCondition <- base::signalCondition
  [14:20:57.668]             sys.calls <- base::sys.calls
  [14:20:57.668]             Sys.time <- base::Sys.time
  [14:20:57.668]             `[[` <- base::`[[`
  [14:20:57.668]             `+` <- base::`+`
  [14:20:57.668]             `<<-` <- base::`<<-`
  [14:20:57.668]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.668]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.668]                   3L)]
  [14:20:57.668]             }
  [14:20:57.668]             function(cond) {
  [14:20:57.668]                 if (inherits(cond, "error")) {
  [14:20:57.668]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.668]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.668]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.668]                   signalCondition(cond)
  [14:20:57.668]                 }
  [14:20:57.668]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.668]                 ))) {
  [14:20:57.668]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.668]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.668]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.668]                   if (!signal) {
  [14:20:57.668]                     muffleCondition <- function (cond) 
  [14:20:57.668]                     {
  [14:20:57.668]                       inherits <- base::inherits
  [14:20:57.668]                       invokeRestart <- base::invokeRestart
  [14:20:57.668]                       muffled <- FALSE
  [14:20:57.668]                       if (inherits(cond, "message")) {
  [14:20:57.668]                         invokeRestart("muffleMessage")
  [14:20:57.668]                         muffled <- TRUE
  [14:20:57.668]                       }
  [14:20:57.668]                       else if (inherits(cond, "warning")) {
  [14:20:57.668]                         invokeRestart("muffleWarning")
  [14:20:57.668]                         muffled <- TRUE
  [14:20:57.668]                       }
  [14:20:57.668]                       else if (inherits(cond, "condition")) {
  [14:20:57.668]                         computeRestarts <- base::computeRestarts
  [14:20:57.668]                         grepl <- base::grepl
  [14:20:57.668]                         is.null <- base::is.null
  [14:20:57.668]                         restarts <- computeRestarts(cond)
  [14:20:57.668]                         for (restart in restarts) {
  [14:20:57.668]                           name <- restart$name
  [14:20:57.668]                           if (is.null(name)) 
  [14:20:57.668]                             next
  [14:20:57.668]                           if (!grepl("^muffle", name)) 
  [14:20:57.668]                             next
  [14:20:57.668]                           invokeRestart(restart)
  [14:20:57.668]                           muffled <- TRUE
  [14:20:57.668]                           break
  [14:20:57.668]                         }
  [14:20:57.668]                       }
  [14:20:57.668]                       invisible(muffled)
  [14:20:57.668]                     }
  [14:20:57.668]                     muffleCondition(cond)
  [14:20:57.668]                   }
  [14:20:57.668]                 }
  [14:20:57.668]             }
  [14:20:57.668]         }))
  [14:20:57.668]     }, error = function(ex) {
  [14:20:57.668]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.668]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.668]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.668]     }, finally = {
  [14:20:57.668]         {
  [14:20:57.668]             NULL
  [14:20:57.668]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.668]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.668]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.668]                 label = NULL, ...) 
  [14:20:57.668]             {
  [14:20:57.668]                 if (substitute) 
  [14:20:57.668]                   expr <- substitute(expr)
  [14:20:57.668]                 local <- as.logical(local)
  [14:20:57.668]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.668]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.668]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.668]                   label = label, ...)
  [14:20:57.668]                 if (!future$lazy) 
  [14:20:57.668]                   future <- run(future)
  [14:20:57.668]                 invisible(future)
  [14:20:57.668]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.668]         }
  [14:20:57.668]         base::options(...future.oldOptions)
  [14:20:57.668]     })
  [14:20:57.668]     Sys.time
  [14:20:57.668]     if (base::is.na(TRUE)) {
  [14:20:57.668]     }
  [14:20:57.668]     else {
  [14:20:57.668]         base::sink(type = "output", split = FALSE)
  [14:20:57.668]         if (TRUE) {
  [14:20:57.668]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.668]         }
  [14:20:57.668]         else {
  [14:20:57.668]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.668]         }
  [14:20:57.668]         base::close(...future.stdout)
  [14:20:57.668]         ...future.stdout <- NULL
  [14:20:57.668]     }
  [14:20:57.668]     ...future.result$conditions <- ...future.conditions
  [14:20:57.668]     ...future.result
  [14:20:57.668] }
  [14:20:57.674] plan(): Setting new future strategy stack:
  [14:20:57.674] List of future strategies:
  [14:20:57.674] 1. sequential:
  [14:20:57.674]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.674]    - tweaked: FALSE
  [14:20:57.674]    - call: NULL
  [14:20:57.675] plan(): nbrOfWorkers() = 1
  [14:20:57.677] plan(): Setting new future strategy stack:
  [14:20:57.677] List of future strategies:
  [14:20:57.677] 1. sequential:
  [14:20:57.677]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.677]    - tweaked: FALSE
  [14:20:57.677]    - call: plan(strategy)
  [14:20:57.678] plan(): nbrOfWorkers() = 1
  [14:20:57.695] SequentialFuture started (and completed)
  <environment: 0x5574fa6c9380> 
  <environment: 0x5574fa630a58> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:20:57.702] resolve() on environment ...
  [14:20:57.702]  recursive: 0
  [14:20:57.715]  elements: [4] 'a', 'b', 'c', 'd'
  [14:20:57.716] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.716] - nx: 4
  [14:20:57.716] - relay: TRUE
  [14:20:57.717] - stdout: TRUE
  [14:20:57.717] - signal: TRUE
  [14:20:57.717] - resignal: FALSE
  [14:20:57.718] - force: TRUE
  [14:20:57.718] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.718] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.719]  - until=2
  [14:20:57.719]  - relaying element #2
  [14:20:57.720] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.720] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.720] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.721]  length: 3 (resolved future 1)
  [14:20:57.721] Future #2
  [14:20:57.721] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:57.722] - nx: 4
  [14:20:57.722] - relay: TRUE
  [14:20:57.722] - stdout: TRUE
  [14:20:57.723] - signal: TRUE
  [14:20:57.723] - resignal: FALSE
  [14:20:57.723] - force: TRUE
  [14:20:57.723] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.724] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.724]  - until=2
  [14:20:57.724]  - relaying element #2
  [14:20:57.725] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.725] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.726] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:57.726]  length: 2 (resolved future 2)
  [14:20:57.726] Future #3
  [14:20:57.727] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:57.727] - nx: 4
  [14:20:57.727] - relay: TRUE
  [14:20:57.728] - stdout: TRUE
  [14:20:57.728] - signal: TRUE
  [14:20:57.728] - resignal: FALSE
  [14:20:57.729] - force: TRUE
  [14:20:57.729] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.729] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.730]  - until=3
  [14:20:57.730]  - relaying element #3
  [14:20:57.731] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.731] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.731] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:57.732]  length: 1 (resolved future 3)
  [14:20:57.732] Future #4
  [14:20:57.732] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:20:57.733] - nx: 4
  [14:20:57.733] - relay: TRUE
  [14:20:57.733] - stdout: TRUE
  [14:20:57.734] - signal: TRUE
  [14:20:57.734] - resignal: FALSE
  [14:20:57.734] - force: TRUE
  [14:20:57.735] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.735] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.735]  - until=4
  [14:20:57.736]  - relaying element #4
  [14:20:57.736] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.737] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.737] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:20:57.737]  length: 0 (resolved future 4)
  [14:20:57.738] Relaying remaining futures
  [14:20:57.738] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.738] - nx: 4
  [14:20:57.738] - relay: TRUE
  [14:20:57.739] - stdout: TRUE
  [14:20:57.739] - signal: TRUE
  [14:20:57.739] - resignal: FALSE
  [14:20:57.740] - force: TRUE
  [14:20:57.740] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.740] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:20:57.741] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.741] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.742] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.742] resolve() on environment ... DONE
  <environment: 0x5574fa733248> 
  Dimensions: c(2, 3, 1)
  [14:20:57.744] getGlobalsAndPackages() ...
  [14:20:57.744] Searching for globals...
  [14:20:57.745] 
  [14:20:57.745] Searching for globals ... DONE
  [14:20:57.745] - globals: [0] <none>
  [14:20:57.746] getGlobalsAndPackages() ... DONE
  [14:20:57.748] Packages needed by the future expression (n = 0): <none>
  [14:20:57.749] Packages needed by future strategies (n = 0): <none>
  [14:20:57.754] {
  [14:20:57.754]     {
  [14:20:57.754]         ...future.startTime <- base::Sys.time()
  [14:20:57.754]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.754]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.754]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.754]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.754]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.754]         {
  [14:20:57.754]             {
  [14:20:57.754]                 has_future <- base::requireNamespace("future", 
  [14:20:57.754]                   quietly = TRUE)
  [14:20:57.754]                 version <- if (has_future) 
  [14:20:57.754]                   utils::packageVersion("future")
  [14:20:57.754]                 else NULL
  [14:20:57.754]                 if (!has_future || version < "1.8.0") {
  [14:20:57.754]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.754]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.754]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.754]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.754]                       "release", "version")], collapse = " "), 
  [14:20:57.754]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.754]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.754]                     info)
  [14:20:57.754]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.754]                   if (!has_future) {
  [14:20:57.754]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.754]                       info)
  [14:20:57.754]                   }
  [14:20:57.754]                   else {
  [14:20:57.754]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.754]                       info, version)
  [14:20:57.754]                   }
  [14:20:57.754]                   base::stop(msg)
  [14:20:57.754]                 }
  [14:20:57.754]             }
  [14:20:57.754]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.754]         }
  [14:20:57.754]     }
  [14:20:57.754]     if (base::is.na(TRUE)) {
  [14:20:57.754]     }
  [14:20:57.754]     else {
  [14:20:57.754]         if (TRUE) {
  [14:20:57.754]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.754]                 open = "w")
  [14:20:57.754]         }
  [14:20:57.754]         else {
  [14:20:57.754]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.754]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.754]         }
  [14:20:57.754]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.754]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.754]             base::sink(type = "output", split = FALSE)
  [14:20:57.754]             base::close(...future.stdout)
  [14:20:57.754]         }, add = TRUE)
  [14:20:57.754]     }
  [14:20:57.754]     ...future.frame <- base::sys.nframe()
  [14:20:57.754]     ...future.conditions <- base::list()
  [14:20:57.754]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.754]     ...future.result <- base::tryCatch({
  [14:20:57.754]         base::withCallingHandlers({
  [14:20:57.754]             ...future.value <- base::withVisible(base::local(2))
  [14:20:57.754]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.754]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.754]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.754]                 version = "1.8")
  [14:20:57.754]         }, condition = base::local({
  [14:20:57.754]             c <- base::c
  [14:20:57.754]             inherits <- base::inherits
  [14:20:57.754]             invokeRestart <- base::invokeRestart
  [14:20:57.754]             length <- base::length
  [14:20:57.754]             list <- base::list
  [14:20:57.754]             seq.int <- base::seq.int
  [14:20:57.754]             signalCondition <- base::signalCondition
  [14:20:57.754]             sys.calls <- base::sys.calls
  [14:20:57.754]             Sys.time <- base::Sys.time
  [14:20:57.754]             `[[` <- base::`[[`
  [14:20:57.754]             `+` <- base::`+`
  [14:20:57.754]             `<<-` <- base::`<<-`
  [14:20:57.754]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.754]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.754]                   3L)]
  [14:20:57.754]             }
  [14:20:57.754]             function(cond) {
  [14:20:57.754]                 if (inherits(cond, "error")) {
  [14:20:57.754]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.754]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.754]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.754]                   signalCondition(cond)
  [14:20:57.754]                 }
  [14:20:57.754]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.754]                 ))) {
  [14:20:57.754]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.754]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.754]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.754]                   if (!signal) {
  [14:20:57.754]                     muffleCondition <- function (cond) 
  [14:20:57.754]                     {
  [14:20:57.754]                       inherits <- base::inherits
  [14:20:57.754]                       invokeRestart <- base::invokeRestart
  [14:20:57.754]                       muffled <- FALSE
  [14:20:57.754]                       if (inherits(cond, "message")) {
  [14:20:57.754]                         invokeRestart("muffleMessage")
  [14:20:57.754]                         muffled <- TRUE
  [14:20:57.754]                       }
  [14:20:57.754]                       else if (inherits(cond, "warning")) {
  [14:20:57.754]                         invokeRestart("muffleWarning")
  [14:20:57.754]                         muffled <- TRUE
  [14:20:57.754]                       }
  [14:20:57.754]                       else if (inherits(cond, "condition")) {
  [14:20:57.754]                         computeRestarts <- base::computeRestarts
  [14:20:57.754]                         grepl <- base::grepl
  [14:20:57.754]                         is.null <- base::is.null
  [14:20:57.754]                         restarts <- computeRestarts(cond)
  [14:20:57.754]                         for (restart in restarts) {
  [14:20:57.754]                           name <- restart$name
  [14:20:57.754]                           if (is.null(name)) 
  [14:20:57.754]                             next
  [14:20:57.754]                           if (!grepl("^muffle", name)) 
  [14:20:57.754]                             next
  [14:20:57.754]                           invokeRestart(restart)
  [14:20:57.754]                           muffled <- TRUE
  [14:20:57.754]                           break
  [14:20:57.754]                         }
  [14:20:57.754]                       }
  [14:20:57.754]                       invisible(muffled)
  [14:20:57.754]                     }
  [14:20:57.754]                     muffleCondition(cond)
  [14:20:57.754]                   }
  [14:20:57.754]                 }
  [14:20:57.754]             }
  [14:20:57.754]         }))
  [14:20:57.754]     }, error = function(ex) {
  [14:20:57.754]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.754]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.754]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.754]     }, finally = {
  [14:20:57.754]         {
  [14:20:57.754]             NULL
  [14:20:57.754]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.754]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.754]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.754]                 label = NULL, ...) 
  [14:20:57.754]             {
  [14:20:57.754]                 if (substitute) 
  [14:20:57.754]                   expr <- substitute(expr)
  [14:20:57.754]                 local <- as.logical(local)
  [14:20:57.754]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.754]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.754]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.754]                   label = label, ...)
  [14:20:57.754]                 if (!future$lazy) 
  [14:20:57.754]                   future <- run(future)
  [14:20:57.754]                 invisible(future)
  [14:20:57.754]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.754]         }
  [14:20:57.754]         base::options(...future.oldOptions)
  [14:20:57.754]     })
  [14:20:57.754]     Sys.time
  [14:20:57.754]     if (base::is.na(TRUE)) {
  [14:20:57.754]     }
  [14:20:57.754]     else {
  [14:20:57.754]         base::sink(type = "output", split = FALSE)
  [14:20:57.754]         if (TRUE) {
  [14:20:57.754]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.754]         }
  [14:20:57.754]         else {
  [14:20:57.754]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.754]         }
  [14:20:57.754]         base::close(...future.stdout)
  [14:20:57.754]         ...future.stdout <- NULL
  [14:20:57.754]     }
  [14:20:57.754]     ...future.result$conditions <- ...future.conditions
  [14:20:57.754]     ...future.result
  [14:20:57.754] }
  [14:20:57.760] plan(): Setting new future strategy stack:
  [14:20:57.760] List of future strategies:
  [14:20:57.760] 1. sequential:
  [14:20:57.760]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.760]    - tweaked: FALSE
  [14:20:57.760]    - call: NULL
  [14:20:57.761] plan(): nbrOfWorkers() = 1
  [14:20:57.762] plan(): Setting new future strategy stack:
  [14:20:57.763] List of future strategies:
  [14:20:57.763] 1. sequential:
  [14:20:57.763]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.763]    - tweaked: FALSE
  [14:20:57.763]    - call: plan(strategy)
  [14:20:57.764] plan(): nbrOfWorkers() = 1
  [14:20:57.765] SequentialFuture started (and completed)
  [14:20:57.765] getGlobalsAndPackages() ...
  [14:20:57.765] Searching for globals...
  [14:20:57.766] 
  [14:20:57.767] Searching for globals ... DONE
  [14:20:57.767] - globals: [0] <none>
  [14:20:57.767] getGlobalsAndPackages() ... DONE
  [14:20:57.769] Packages needed by the future expression (n = 0): <none>
  [14:20:57.770] Packages needed by future strategies (n = 0): <none>
  [14:20:57.775] {
  [14:20:57.775]     {
  [14:20:57.775]         ...future.startTime <- base::Sys.time()
  [14:20:57.775]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.775]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.775]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.775]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.775]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.775]         {
  [14:20:57.775]             {
  [14:20:57.775]                 has_future <- base::requireNamespace("future", 
  [14:20:57.775]                   quietly = TRUE)
  [14:20:57.775]                 version <- if (has_future) 
  [14:20:57.775]                   utils::packageVersion("future")
  [14:20:57.775]                 else NULL
  [14:20:57.775]                 if (!has_future || version < "1.8.0") {
  [14:20:57.775]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.775]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.775]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.775]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.775]                       "release", "version")], collapse = " "), 
  [14:20:57.775]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.775]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.775]                     info)
  [14:20:57.775]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.775]                   if (!has_future) {
  [14:20:57.775]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.775]                       info)
  [14:20:57.775]                   }
  [14:20:57.775]                   else {
  [14:20:57.775]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.775]                       info, version)
  [14:20:57.775]                   }
  [14:20:57.775]                   base::stop(msg)
  [14:20:57.775]                 }
  [14:20:57.775]             }
  [14:20:57.775]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.775]         }
  [14:20:57.775]     }
  [14:20:57.775]     if (base::is.na(TRUE)) {
  [14:20:57.775]     }
  [14:20:57.775]     else {
  [14:20:57.775]         if (TRUE) {
  [14:20:57.775]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.775]                 open = "w")
  [14:20:57.775]         }
  [14:20:57.775]         else {
  [14:20:57.775]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.775]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.775]         }
  [14:20:57.775]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.775]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.775]             base::sink(type = "output", split = FALSE)
  [14:20:57.775]             base::close(...future.stdout)
  [14:20:57.775]         }, add = TRUE)
  [14:20:57.775]     }
  [14:20:57.775]     ...future.frame <- base::sys.nframe()
  [14:20:57.775]     ...future.conditions <- base::list()
  [14:20:57.775]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.775]     ...future.result <- base::tryCatch({
  [14:20:57.775]         base::withCallingHandlers({
  [14:20:57.775]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:57.775]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.775]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.775]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.775]                 version = "1.8")
  [14:20:57.775]         }, condition = base::local({
  [14:20:57.775]             c <- base::c
  [14:20:57.775]             inherits <- base::inherits
  [14:20:57.775]             invokeRestart <- base::invokeRestart
  [14:20:57.775]             length <- base::length
  [14:20:57.775]             list <- base::list
  [14:20:57.775]             seq.int <- base::seq.int
  [14:20:57.775]             signalCondition <- base::signalCondition
  [14:20:57.775]             sys.calls <- base::sys.calls
  [14:20:57.775]             Sys.time <- base::Sys.time
  [14:20:57.775]             `[[` <- base::`[[`
  [14:20:57.775]             `+` <- base::`+`
  [14:20:57.775]             `<<-` <- base::`<<-`
  [14:20:57.775]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.775]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.775]                   3L)]
  [14:20:57.775]             }
  [14:20:57.775]             function(cond) {
  [14:20:57.775]                 if (inherits(cond, "error")) {
  [14:20:57.775]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.775]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.775]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.775]                   signalCondition(cond)
  [14:20:57.775]                 }
  [14:20:57.775]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.775]                 ))) {
  [14:20:57.775]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.775]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.775]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.775]                   if (!signal) {
  [14:20:57.775]                     muffleCondition <- function (cond) 
  [14:20:57.775]                     {
  [14:20:57.775]                       inherits <- base::inherits
  [14:20:57.775]                       invokeRestart <- base::invokeRestart
  [14:20:57.775]                       muffled <- FALSE
  [14:20:57.775]                       if (inherits(cond, "message")) {
  [14:20:57.775]                         invokeRestart("muffleMessage")
  [14:20:57.775]                         muffled <- TRUE
  [14:20:57.775]                       }
  [14:20:57.775]                       else if (inherits(cond, "warning")) {
  [14:20:57.775]                         invokeRestart("muffleWarning")
  [14:20:57.775]                         muffled <- TRUE
  [14:20:57.775]                       }
  [14:20:57.775]                       else if (inherits(cond, "condition")) {
  [14:20:57.775]                         computeRestarts <- base::computeRestarts
  [14:20:57.775]                         grepl <- base::grepl
  [14:20:57.775]                         is.null <- base::is.null
  [14:20:57.775]                         restarts <- computeRestarts(cond)
  [14:20:57.775]                         for (restart in restarts) {
  [14:20:57.775]                           name <- restart$name
  [14:20:57.775]                           if (is.null(name)) 
  [14:20:57.775]                             next
  [14:20:57.775]                           if (!grepl("^muffle", name)) 
  [14:20:57.775]                             next
  [14:20:57.775]                           invokeRestart(restart)
  [14:20:57.775]                           muffled <- TRUE
  [14:20:57.775]                           break
  [14:20:57.775]                         }
  [14:20:57.775]                       }
  [14:20:57.775]                       invisible(muffled)
  [14:20:57.775]                     }
  [14:20:57.775]                     muffleCondition(cond)
  [14:20:57.775]                   }
  [14:20:57.775]                 }
  [14:20:57.775]             }
  [14:20:57.775]         }))
  [14:20:57.775]     }, error = function(ex) {
  [14:20:57.775]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.775]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.775]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.775]     }, finally = {
  [14:20:57.775]         {
  [14:20:57.775]             NULL
  [14:20:57.775]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.775]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.775]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.775]                 label = NULL, ...) 
  [14:20:57.775]             {
  [14:20:57.775]                 if (substitute) 
  [14:20:57.775]                   expr <- substitute(expr)
  [14:20:57.775]                 local <- as.logical(local)
  [14:20:57.775]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.775]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.775]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.775]                   label = label, ...)
  [14:20:57.775]                 if (!future$lazy) 
  [14:20:57.775]                   future <- run(future)
  [14:20:57.775]                 invisible(future)
  [14:20:57.775]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.775]         }
  [14:20:57.775]         base::options(...future.oldOptions)
  [14:20:57.775]     })
  [14:20:57.775]     Sys.time
  [14:20:57.775]     if (base::is.na(TRUE)) {
  [14:20:57.775]     }
  [14:20:57.775]     else {
  [14:20:57.775]         base::sink(type = "output", split = FALSE)
  [14:20:57.775]         if (TRUE) {
  [14:20:57.775]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.775]         }
  [14:20:57.775]         else {
  [14:20:57.775]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.775]         }
  [14:20:57.775]         base::close(...future.stdout)
  [14:20:57.775]         ...future.stdout <- NULL
  [14:20:57.775]     }
  [14:20:57.775]     ...future.result$conditions <- ...future.conditions
  [14:20:57.775]     ...future.result
  [14:20:57.775] }
  [14:20:57.781] plan(): Setting new future strategy stack:
  [14:20:57.781] List of future strategies:
  [14:20:57.781] 1. sequential:
  [14:20:57.781]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.781]    - tweaked: FALSE
  [14:20:57.781]    - call: NULL
  [14:20:57.782] plan(): nbrOfWorkers() = 1
  [14:20:57.784] plan(): Setting new future strategy stack:
  [14:20:57.784] List of future strategies:
  [14:20:57.784] 1. sequential:
  [14:20:57.784]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.784]    - tweaked: FALSE
  [14:20:57.784]    - call: plan(strategy)
  [14:20:57.789] plan(): nbrOfWorkers() = 1
  [14:20:57.790] SequentialFuture started (and completed)
  [14:20:57.791] getGlobalsAndPackages() ...
  [14:20:57.791] Searching for globals...
  [14:20:57.793] - globals found: [1] '{'
  [14:20:57.793] Searching for globals ... DONE
  [14:20:57.793] Resolving globals: FALSE
  [14:20:57.794] 
  [14:20:57.795] 
  [14:20:57.795] getGlobalsAndPackages() ... DONE
  [14:20:57.797] Packages needed by the future expression (n = 0): <none>
  [14:20:57.798] Packages needed by future strategies (n = 0): <none>
  [14:20:57.803] {
  [14:20:57.803]     {
  [14:20:57.803]         ...future.startTime <- base::Sys.time()
  [14:20:57.803]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.803]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.803]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.803]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.803]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.803]         {
  [14:20:57.803]             {
  [14:20:57.803]                 has_future <- base::requireNamespace("future", 
  [14:20:57.803]                   quietly = TRUE)
  [14:20:57.803]                 version <- if (has_future) 
  [14:20:57.803]                   utils::packageVersion("future")
  [14:20:57.803]                 else NULL
  [14:20:57.803]                 if (!has_future || version < "1.8.0") {
  [14:20:57.803]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.803]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.803]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.803]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.803]                       "release", "version")], collapse = " "), 
  [14:20:57.803]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.803]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.803]                     info)
  [14:20:57.803]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.803]                   if (!has_future) {
  [14:20:57.803]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.803]                       info)
  [14:20:57.803]                   }
  [14:20:57.803]                   else {
  [14:20:57.803]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.803]                       info, version)
  [14:20:57.803]                   }
  [14:20:57.803]                   base::stop(msg)
  [14:20:57.803]                 }
  [14:20:57.803]             }
  [14:20:57.803]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.803]         }
  [14:20:57.803]     }
  [14:20:57.803]     if (base::is.na(TRUE)) {
  [14:20:57.803]     }
  [14:20:57.803]     else {
  [14:20:57.803]         if (TRUE) {
  [14:20:57.803]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.803]                 open = "w")
  [14:20:57.803]         }
  [14:20:57.803]         else {
  [14:20:57.803]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.803]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.803]         }
  [14:20:57.803]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.803]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.803]             base::sink(type = "output", split = FALSE)
  [14:20:57.803]             base::close(...future.stdout)
  [14:20:57.803]         }, add = TRUE)
  [14:20:57.803]     }
  [14:20:57.803]     ...future.frame <- base::sys.nframe()
  [14:20:57.803]     ...future.conditions <- base::list()
  [14:20:57.803]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.803]     ...future.result <- base::tryCatch({
  [14:20:57.803]         base::withCallingHandlers({
  [14:20:57.803]             ...future.value <- base::withVisible(base::local({
  [14:20:57.803]                 4
  [14:20:57.803]             }))
  [14:20:57.803]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.803]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.803]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.803]                 version = "1.8")
  [14:20:57.803]         }, condition = base::local({
  [14:20:57.803]             c <- base::c
  [14:20:57.803]             inherits <- base::inherits
  [14:20:57.803]             invokeRestart <- base::invokeRestart
  [14:20:57.803]             length <- base::length
  [14:20:57.803]             list <- base::list
  [14:20:57.803]             seq.int <- base::seq.int
  [14:20:57.803]             signalCondition <- base::signalCondition
  [14:20:57.803]             sys.calls <- base::sys.calls
  [14:20:57.803]             Sys.time <- base::Sys.time
  [14:20:57.803]             `[[` <- base::`[[`
  [14:20:57.803]             `+` <- base::`+`
  [14:20:57.803]             `<<-` <- base::`<<-`
  [14:20:57.803]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.803]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.803]                   3L)]
  [14:20:57.803]             }
  [14:20:57.803]             function(cond) {
  [14:20:57.803]                 if (inherits(cond, "error")) {
  [14:20:57.803]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.803]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.803]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.803]                   signalCondition(cond)
  [14:20:57.803]                 }
  [14:20:57.803]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.803]                 ))) {
  [14:20:57.803]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.803]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.803]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.803]                   if (!signal) {
  [14:20:57.803]                     muffleCondition <- function (cond) 
  [14:20:57.803]                     {
  [14:20:57.803]                       inherits <- base::inherits
  [14:20:57.803]                       invokeRestart <- base::invokeRestart
  [14:20:57.803]                       muffled <- FALSE
  [14:20:57.803]                       if (inherits(cond, "message")) {
  [14:20:57.803]                         invokeRestart("muffleMessage")
  [14:20:57.803]                         muffled <- TRUE
  [14:20:57.803]                       }
  [14:20:57.803]                       else if (inherits(cond, "warning")) {
  [14:20:57.803]                         invokeRestart("muffleWarning")
  [14:20:57.803]                         muffled <- TRUE
  [14:20:57.803]                       }
  [14:20:57.803]                       else if (inherits(cond, "condition")) {
  [14:20:57.803]                         computeRestarts <- base::computeRestarts
  [14:20:57.803]                         grepl <- base::grepl
  [14:20:57.803]                         is.null <- base::is.null
  [14:20:57.803]                         restarts <- computeRestarts(cond)
  [14:20:57.803]                         for (restart in restarts) {
  [14:20:57.803]                           name <- restart$name
  [14:20:57.803]                           if (is.null(name)) 
  [14:20:57.803]                             next
  [14:20:57.803]                           if (!grepl("^muffle", name)) 
  [14:20:57.803]                             next
  [14:20:57.803]                           invokeRestart(restart)
  [14:20:57.803]                           muffled <- TRUE
  [14:20:57.803]                           break
  [14:20:57.803]                         }
  [14:20:57.803]                       }
  [14:20:57.803]                       invisible(muffled)
  [14:20:57.803]                     }
  [14:20:57.803]                     muffleCondition(cond)
  [14:20:57.803]                   }
  [14:20:57.803]                 }
  [14:20:57.803]             }
  [14:20:57.803]         }))
  [14:20:57.803]     }, error = function(ex) {
  [14:20:57.803]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.803]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.803]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.803]     }, finally = {
  [14:20:57.803]         {
  [14:20:57.803]             NULL
  [14:20:57.803]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.803]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.803]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.803]                 label = NULL, ...) 
  [14:20:57.803]             {
  [14:20:57.803]                 if (substitute) 
  [14:20:57.803]                   expr <- substitute(expr)
  [14:20:57.803]                 local <- as.logical(local)
  [14:20:57.803]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.803]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.803]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.803]                   label = label, ...)
  [14:20:57.803]                 if (!future$lazy) 
  [14:20:57.803]                   future <- run(future)
  [14:20:57.803]                 invisible(future)
  [14:20:57.803]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.803]         }
  [14:20:57.803]         base::options(...future.oldOptions)
  [14:20:57.803]     })
  [14:20:57.803]     Sys.time
  [14:20:57.803]     if (base::is.na(TRUE)) {
  [14:20:57.803]     }
  [14:20:57.803]     else {
  [14:20:57.803]         base::sink(type = "output", split = FALSE)
  [14:20:57.803]         if (TRUE) {
  [14:20:57.803]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.803]         }
  [14:20:57.803]         else {
  [14:20:57.803]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.803]         }
  [14:20:57.803]         base::close(...future.stdout)
  [14:20:57.803]         ...future.stdout <- NULL
  [14:20:57.803]     }
  [14:20:57.803]     ...future.result$conditions <- ...future.conditions
  [14:20:57.803]     ...future.result
  [14:20:57.803] }
  [14:20:57.809] plan(): Setting new future strategy stack:
  [14:20:57.810] List of future strategies:
  [14:20:57.810] 1. sequential:
  [14:20:57.810]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.810]    - tweaked: FALSE
  [14:20:57.810]    - call: NULL
  [14:20:57.811] plan(): nbrOfWorkers() = 1
  [14:20:57.812] plan(): Setting new future strategy stack:
  [14:20:57.813] List of future strategies:
  [14:20:57.813] 1. sequential:
  [14:20:57.813]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.813]    - tweaked: FALSE
  [14:20:57.813]    - call: plan(strategy)
  [14:20:57.814] plan(): nbrOfWorkers() = 1
  [14:20:57.814] SequentialFuture started (and completed)
  <environment: 0x5574f918dcf8> 
  <environment: 0x5574f8c4f6c8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:20:57.820] resolve() on environment ...
  [14:20:57.821]  recursive: 0
  [14:20:57.822]  elements: [4] 'a', 'b', 'c', 'd'
  [14:20:57.822] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.823] - nx: 4
  [14:20:57.823] - relay: TRUE
  [14:20:57.823] - stdout: TRUE
  [14:20:57.824] - signal: TRUE
  [14:20:57.824] - resignal: FALSE
  [14:20:57.824] - force: TRUE
  [14:20:57.825] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.825] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.825]  - until=2
  [14:20:57.826]  - relaying element #2
  [14:20:57.826] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.826] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.827] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.827]  length: 3 (resolved future 1)
  [14:20:57.827] Future #2
  [14:20:57.828] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:57.828] - nx: 4
  [14:20:57.828] - relay: TRUE
  [14:20:57.829] - stdout: TRUE
  [14:20:57.829] - signal: TRUE
  [14:20:57.829] - resignal: FALSE
  [14:20:57.829] - force: TRUE
  [14:20:57.830] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.830] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.830]  - until=2
  [14:20:57.831]  - relaying element #2
  [14:20:57.831] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.832] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.832] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:57.832]  length: 2 (resolved future 2)
  [14:20:57.833] Future #3
  [14:20:57.833] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:57.833] - nx: 4
  [14:20:57.834] - relay: TRUE
  [14:20:57.834] - stdout: TRUE
  [14:20:57.834] - signal: TRUE
  [14:20:57.835] - resignal: FALSE
  [14:20:57.835] - force: TRUE
  [14:20:57.835] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.835] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.836]  - until=3
  [14:20:57.836]  - relaying element #3
  [14:20:57.837] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.837] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.837] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:57.838]  length: 1 (resolved future 3)
  [14:20:57.838] Future #4
  [14:20:57.838] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:20:57.839] - nx: 4
  [14:20:57.839] - relay: TRUE
  [14:20:57.839] - stdout: TRUE
  [14:20:57.840] - signal: TRUE
  [14:20:57.840] - resignal: FALSE
  [14:20:57.840] - force: TRUE
  [14:20:57.841] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.841] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.841]  - until=4
  [14:20:57.842]  - relaying element #4
  [14:20:57.842] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.843] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.843] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:20:57.843]  length: 0 (resolved future 4)
  [14:20:57.844] Relaying remaining futures
  [14:20:57.844] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.844] - nx: 4
  [14:20:57.844] - relay: TRUE
  [14:20:57.845] - stdout: TRUE
  [14:20:57.845] - signal: TRUE
  [14:20:57.845] - resignal: FALSE
  [14:20:57.846] - force: TRUE
  [14:20:57.846] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.846] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:20:57.847] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.847] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.847] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.848] resolve() on environment ... DONE
  <environment: 0x5574f8ef9c80> 
  Dimensions: c(2, 1, 3, 1)
  [14:20:57.849] getGlobalsAndPackages() ...
  [14:20:57.850] Searching for globals...
  [14:20:57.851] 
  [14:20:57.851] Searching for globals ... DONE
  [14:20:57.851] - globals: [0] <none>
  [14:20:57.852] getGlobalsAndPackages() ... DONE
  [14:20:57.854] Packages needed by the future expression (n = 0): <none>
  [14:20:57.854] Packages needed by future strategies (n = 0): <none>
  [14:20:57.865] {
  [14:20:57.865]     {
  [14:20:57.865]         ...future.startTime <- base::Sys.time()
  [14:20:57.865]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.865]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.865]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.865]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.865]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.865]         {
  [14:20:57.865]             {
  [14:20:57.865]                 has_future <- base::requireNamespace("future", 
  [14:20:57.865]                   quietly = TRUE)
  [14:20:57.865]                 version <- if (has_future) 
  [14:20:57.865]                   utils::packageVersion("future")
  [14:20:57.865]                 else NULL
  [14:20:57.865]                 if (!has_future || version < "1.8.0") {
  [14:20:57.865]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.865]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.865]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.865]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.865]                       "release", "version")], collapse = " "), 
  [14:20:57.865]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.865]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.865]                     info)
  [14:20:57.865]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.865]                   if (!has_future) {
  [14:20:57.865]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.865]                       info)
  [14:20:57.865]                   }
  [14:20:57.865]                   else {
  [14:20:57.865]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.865]                       info, version)
  [14:20:57.865]                   }
  [14:20:57.865]                   base::stop(msg)
  [14:20:57.865]                 }
  [14:20:57.865]             }
  [14:20:57.865]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.865]         }
  [14:20:57.865]     }
  [14:20:57.865]     if (base::is.na(TRUE)) {
  [14:20:57.865]     }
  [14:20:57.865]     else {
  [14:20:57.865]         if (TRUE) {
  [14:20:57.865]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.865]                 open = "w")
  [14:20:57.865]         }
  [14:20:57.865]         else {
  [14:20:57.865]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.865]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.865]         }
  [14:20:57.865]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.865]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.865]             base::sink(type = "output", split = FALSE)
  [14:20:57.865]             base::close(...future.stdout)
  [14:20:57.865]         }, add = TRUE)
  [14:20:57.865]     }
  [14:20:57.865]     ...future.frame <- base::sys.nframe()
  [14:20:57.865]     ...future.conditions <- base::list()
  [14:20:57.865]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.865]     ...future.result <- base::tryCatch({
  [14:20:57.865]         base::withCallingHandlers({
  [14:20:57.865]             ...future.value <- base::withVisible(base::local(2))
  [14:20:57.865]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.865]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.865]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.865]                 version = "1.8")
  [14:20:57.865]         }, condition = base::local({
  [14:20:57.865]             c <- base::c
  [14:20:57.865]             inherits <- base::inherits
  [14:20:57.865]             invokeRestart <- base::invokeRestart
  [14:20:57.865]             length <- base::length
  [14:20:57.865]             list <- base::list
  [14:20:57.865]             seq.int <- base::seq.int
  [14:20:57.865]             signalCondition <- base::signalCondition
  [14:20:57.865]             sys.calls <- base::sys.calls
  [14:20:57.865]             Sys.time <- base::Sys.time
  [14:20:57.865]             `[[` <- base::`[[`
  [14:20:57.865]             `+` <- base::`+`
  [14:20:57.865]             `<<-` <- base::`<<-`
  [14:20:57.865]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.865]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.865]                   3L)]
  [14:20:57.865]             }
  [14:20:57.865]             function(cond) {
  [14:20:57.865]                 if (inherits(cond, "error")) {
  [14:20:57.865]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.865]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.865]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.865]                   signalCondition(cond)
  [14:20:57.865]                 }
  [14:20:57.865]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.865]                 ))) {
  [14:20:57.865]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.865]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.865]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.865]                   if (!signal) {
  [14:20:57.865]                     muffleCondition <- function (cond) 
  [14:20:57.865]                     {
  [14:20:57.865]                       inherits <- base::inherits
  [14:20:57.865]                       invokeRestart <- base::invokeRestart
  [14:20:57.865]                       muffled <- FALSE
  [14:20:57.865]                       if (inherits(cond, "message")) {
  [14:20:57.865]                         invokeRestart("muffleMessage")
  [14:20:57.865]                         muffled <- TRUE
  [14:20:57.865]                       }
  [14:20:57.865]                       else if (inherits(cond, "warning")) {
  [14:20:57.865]                         invokeRestart("muffleWarning")
  [14:20:57.865]                         muffled <- TRUE
  [14:20:57.865]                       }
  [14:20:57.865]                       else if (inherits(cond, "condition")) {
  [14:20:57.865]                         computeRestarts <- base::computeRestarts
  [14:20:57.865]                         grepl <- base::grepl
  [14:20:57.865]                         is.null <- base::is.null
  [14:20:57.865]                         restarts <- computeRestarts(cond)
  [14:20:57.865]                         for (restart in restarts) {
  [14:20:57.865]                           name <- restart$name
  [14:20:57.865]                           if (is.null(name)) 
  [14:20:57.865]                             next
  [14:20:57.865]                           if (!grepl("^muffle", name)) 
  [14:20:57.865]                             next
  [14:20:57.865]                           invokeRestart(restart)
  [14:20:57.865]                           muffled <- TRUE
  [14:20:57.865]                           break
  [14:20:57.865]                         }
  [14:20:57.865]                       }
  [14:20:57.865]                       invisible(muffled)
  [14:20:57.865]                     }
  [14:20:57.865]                     muffleCondition(cond)
  [14:20:57.865]                   }
  [14:20:57.865]                 }
  [14:20:57.865]             }
  [14:20:57.865]         }))
  [14:20:57.865]     }, error = function(ex) {
  [14:20:57.865]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.865]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.865]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.865]     }, finally = {
  [14:20:57.865]         {
  [14:20:57.865]             NULL
  [14:20:57.865]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.865]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.865]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.865]                 label = NULL, ...) 
  [14:20:57.865]             {
  [14:20:57.865]                 if (substitute) 
  [14:20:57.865]                   expr <- substitute(expr)
  [14:20:57.865]                 local <- as.logical(local)
  [14:20:57.865]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.865]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.865]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.865]                   label = label, ...)
  [14:20:57.865]                 if (!future$lazy) 
  [14:20:57.865]                   future <- run(future)
  [14:20:57.865]                 invisible(future)
  [14:20:57.865]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.865]         }
  [14:20:57.865]         base::options(...future.oldOptions)
  [14:20:57.865]     })
  [14:20:57.865]     Sys.time
  [14:20:57.865]     if (base::is.na(TRUE)) {
  [14:20:57.865]     }
  [14:20:57.865]     else {
  [14:20:57.865]         base::sink(type = "output", split = FALSE)
  [14:20:57.865]         if (TRUE) {
  [14:20:57.865]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.865]         }
  [14:20:57.865]         else {
  [14:20:57.865]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.865]         }
  [14:20:57.865]         base::close(...future.stdout)
  [14:20:57.865]         ...future.stdout <- NULL
  [14:20:57.865]     }
  [14:20:57.865]     ...future.result$conditions <- ...future.conditions
  [14:20:57.865]     ...future.result
  [14:20:57.865] }
  [14:20:57.870] plan(): Setting new future strategy stack:
  [14:20:57.871] List of future strategies:
  [14:20:57.871] 1. sequential:
  [14:20:57.871]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.871]    - tweaked: FALSE
  [14:20:57.871]    - call: NULL
  [14:20:57.872] plan(): nbrOfWorkers() = 1
  [14:20:57.873] plan(): Setting new future strategy stack:
  [14:20:57.873] List of future strategies:
  [14:20:57.873] 1. sequential:
  [14:20:57.873]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.873]    - tweaked: FALSE
  [14:20:57.873]    - call: plan(strategy)
  [14:20:57.874] plan(): nbrOfWorkers() = 1
  [14:20:57.875] SequentialFuture started (and completed)
  [14:20:57.875] getGlobalsAndPackages() ...
  [14:20:57.876] Searching for globals...
  [14:20:57.877] 
  [14:20:57.877] Searching for globals ... DONE
  [14:20:57.877] - globals: [0] <none>
  [14:20:57.878] getGlobalsAndPackages() ... DONE
  [14:20:57.879] Packages needed by the future expression (n = 0): <none>
  [14:20:57.880] Packages needed by future strategies (n = 0): <none>
  [14:20:57.885] {
  [14:20:57.885]     {
  [14:20:57.885]         ...future.startTime <- base::Sys.time()
  [14:20:57.885]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.885]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.885]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.885]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.885]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.885]         {
  [14:20:57.885]             {
  [14:20:57.885]                 has_future <- base::requireNamespace("future", 
  [14:20:57.885]                   quietly = TRUE)
  [14:20:57.885]                 version <- if (has_future) 
  [14:20:57.885]                   utils::packageVersion("future")
  [14:20:57.885]                 else NULL
  [14:20:57.885]                 if (!has_future || version < "1.8.0") {
  [14:20:57.885]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.885]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.885]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.885]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.885]                       "release", "version")], collapse = " "), 
  [14:20:57.885]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.885]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.885]                     info)
  [14:20:57.885]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.885]                   if (!has_future) {
  [14:20:57.885]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.885]                       info)
  [14:20:57.885]                   }
  [14:20:57.885]                   else {
  [14:20:57.885]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.885]                       info, version)
  [14:20:57.885]                   }
  [14:20:57.885]                   base::stop(msg)
  [14:20:57.885]                 }
  [14:20:57.885]             }
  [14:20:57.885]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.885]         }
  [14:20:57.885]     }
  [14:20:57.885]     if (base::is.na(TRUE)) {
  [14:20:57.885]     }
  [14:20:57.885]     else {
  [14:20:57.885]         if (TRUE) {
  [14:20:57.885]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.885]                 open = "w")
  [14:20:57.885]         }
  [14:20:57.885]         else {
  [14:20:57.885]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.885]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.885]         }
  [14:20:57.885]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.885]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.885]             base::sink(type = "output", split = FALSE)
  [14:20:57.885]             base::close(...future.stdout)
  [14:20:57.885]         }, add = TRUE)
  [14:20:57.885]     }
  [14:20:57.885]     ...future.frame <- base::sys.nframe()
  [14:20:57.885]     ...future.conditions <- base::list()
  [14:20:57.885]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.885]     ...future.result <- base::tryCatch({
  [14:20:57.885]         base::withCallingHandlers({
  [14:20:57.885]             ...future.value <- base::withVisible(base::local(NULL))
  [14:20:57.885]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.885]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.885]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.885]                 version = "1.8")
  [14:20:57.885]         }, condition = base::local({
  [14:20:57.885]             c <- base::c
  [14:20:57.885]             inherits <- base::inherits
  [14:20:57.885]             invokeRestart <- base::invokeRestart
  [14:20:57.885]             length <- base::length
  [14:20:57.885]             list <- base::list
  [14:20:57.885]             seq.int <- base::seq.int
  [14:20:57.885]             signalCondition <- base::signalCondition
  [14:20:57.885]             sys.calls <- base::sys.calls
  [14:20:57.885]             Sys.time <- base::Sys.time
  [14:20:57.885]             `[[` <- base::`[[`
  [14:20:57.885]             `+` <- base::`+`
  [14:20:57.885]             `<<-` <- base::`<<-`
  [14:20:57.885]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.885]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.885]                   3L)]
  [14:20:57.885]             }
  [14:20:57.885]             function(cond) {
  [14:20:57.885]                 if (inherits(cond, "error")) {
  [14:20:57.885]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.885]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.885]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.885]                   signalCondition(cond)
  [14:20:57.885]                 }
  [14:20:57.885]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.885]                 ))) {
  [14:20:57.885]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.885]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.885]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.885]                   if (!signal) {
  [14:20:57.885]                     muffleCondition <- function (cond) 
  [14:20:57.885]                     {
  [14:20:57.885]                       inherits <- base::inherits
  [14:20:57.885]                       invokeRestart <- base::invokeRestart
  [14:20:57.885]                       muffled <- FALSE
  [14:20:57.885]                       if (inherits(cond, "message")) {
  [14:20:57.885]                         invokeRestart("muffleMessage")
  [14:20:57.885]                         muffled <- TRUE
  [14:20:57.885]                       }
  [14:20:57.885]                       else if (inherits(cond, "warning")) {
  [14:20:57.885]                         invokeRestart("muffleWarning")
  [14:20:57.885]                         muffled <- TRUE
  [14:20:57.885]                       }
  [14:20:57.885]                       else if (inherits(cond, "condition")) {
  [14:20:57.885]                         computeRestarts <- base::computeRestarts
  [14:20:57.885]                         grepl <- base::grepl
  [14:20:57.885]                         is.null <- base::is.null
  [14:20:57.885]                         restarts <- computeRestarts(cond)
  [14:20:57.885]                         for (restart in restarts) {
  [14:20:57.885]                           name <- restart$name
  [14:20:57.885]                           if (is.null(name)) 
  [14:20:57.885]                             next
  [14:20:57.885]                           if (!grepl("^muffle", name)) 
  [14:20:57.885]                             next
  [14:20:57.885]                           invokeRestart(restart)
  [14:20:57.885]                           muffled <- TRUE
  [14:20:57.885]                           break
  [14:20:57.885]                         }
  [14:20:57.885]                       }
  [14:20:57.885]                       invisible(muffled)
  [14:20:57.885]                     }
  [14:20:57.885]                     muffleCondition(cond)
  [14:20:57.885]                   }
  [14:20:57.885]                 }
  [14:20:57.885]             }
  [14:20:57.885]         }))
  [14:20:57.885]     }, error = function(ex) {
  [14:20:57.885]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.885]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.885]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.885]     }, finally = {
  [14:20:57.885]         {
  [14:20:57.885]             NULL
  [14:20:57.885]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.885]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.885]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.885]                 label = NULL, ...) 
  [14:20:57.885]             {
  [14:20:57.885]                 if (substitute) 
  [14:20:57.885]                   expr <- substitute(expr)
  [14:20:57.885]                 local <- as.logical(local)
  [14:20:57.885]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.885]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.885]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.885]                   label = label, ...)
  [14:20:57.885]                 if (!future$lazy) 
  [14:20:57.885]                   future <- run(future)
  [14:20:57.885]                 invisible(future)
  [14:20:57.885]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.885]         }
  [14:20:57.885]         base::options(...future.oldOptions)
  [14:20:57.885]     })
  [14:20:57.885]     Sys.time
  [14:20:57.885]     if (base::is.na(TRUE)) {
  [14:20:57.885]     }
  [14:20:57.885]     else {
  [14:20:57.885]         base::sink(type = "output", split = FALSE)
  [14:20:57.885]         if (TRUE) {
  [14:20:57.885]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.885]         }
  [14:20:57.885]         else {
  [14:20:57.885]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.885]         }
  [14:20:57.885]         base::close(...future.stdout)
  [14:20:57.885]         ...future.stdout <- NULL
  [14:20:57.885]     }
  [14:20:57.885]     ...future.result$conditions <- ...future.conditions
  [14:20:57.885]     ...future.result
  [14:20:57.885] }
  [14:20:57.891] plan(): Setting new future strategy stack:
  [14:20:57.891] List of future strategies:
  [14:20:57.891] 1. sequential:
  [14:20:57.891]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.891]    - tweaked: FALSE
  [14:20:57.891]    - call: NULL
  [14:20:57.892] plan(): nbrOfWorkers() = 1
  [14:20:57.893] plan(): Setting new future strategy stack:
  [14:20:57.894] List of future strategies:
  [14:20:57.894] 1. sequential:
  [14:20:57.894]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.894]    - tweaked: FALSE
  [14:20:57.894]    - call: plan(strategy)
  [14:20:57.895] plan(): nbrOfWorkers() = 1
  [14:20:57.895] SequentialFuture started (and completed)
  [14:20:57.896] getGlobalsAndPackages() ...
  [14:20:57.897] Searching for globals...
  [14:20:57.898] - globals found: [1] '{'
  [14:20:57.899] Searching for globals ... DONE
  [14:20:57.899] Resolving globals: FALSE
  [14:20:57.900] 
  [14:20:57.900] 
  [14:20:57.900] getGlobalsAndPackages() ... DONE
  [14:20:57.902] Packages needed by the future expression (n = 0): <none>
  [14:20:57.903] Packages needed by future strategies (n = 0): <none>
  [14:20:57.908] {
  [14:20:57.908]     {
  [14:20:57.908]         ...future.startTime <- base::Sys.time()
  [14:20:57.908]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:20:57.908]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:20:57.908]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:20:57.908]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:20:57.908]             future.resolve.recursive = NULL, width = 80L)
  [14:20:57.908]         {
  [14:20:57.908]             {
  [14:20:57.908]                 has_future <- base::requireNamespace("future", 
  [14:20:57.908]                   quietly = TRUE)
  [14:20:57.908]                 version <- if (has_future) 
  [14:20:57.908]                   utils::packageVersion("future")
  [14:20:57.908]                 else NULL
  [14:20:57.908]                 if (!has_future || version < "1.8.0") {
  [14:20:57.908]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:20:57.908]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:20:57.908]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:20:57.908]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:20:57.908]                       "release", "version")], collapse = " "), 
  [14:20:57.908]                     hostname = base::Sys.info()[["nodename"]])
  [14:20:57.908]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:20:57.908]                     info)
  [14:20:57.908]                   info <- base::paste(info, collapse = "; ")
  [14:20:57.908]                   if (!has_future) {
  [14:20:57.908]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:20:57.908]                       info)
  [14:20:57.908]                   }
  [14:20:57.908]                   else {
  [14:20:57.908]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:20:57.908]                       info, version)
  [14:20:57.908]                   }
  [14:20:57.908]                   base::stop(msg)
  [14:20:57.908]                 }
  [14:20:57.908]             }
  [14:20:57.908]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:20:57.908]         }
  [14:20:57.908]     }
  [14:20:57.908]     if (base::is.na(TRUE)) {
  [14:20:57.908]     }
  [14:20:57.908]     else {
  [14:20:57.908]         if (TRUE) {
  [14:20:57.908]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:20:57.908]                 open = "w")
  [14:20:57.908]         }
  [14:20:57.908]         else {
  [14:20:57.908]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:20:57.908]                 windows = "NUL", "/dev/null"), open = "w")
  [14:20:57.908]         }
  [14:20:57.908]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:20:57.908]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:20:57.908]             base::sink(type = "output", split = FALSE)
  [14:20:57.908]             base::close(...future.stdout)
  [14:20:57.908]         }, add = TRUE)
  [14:20:57.908]     }
  [14:20:57.908]     ...future.frame <- base::sys.nframe()
  [14:20:57.908]     ...future.conditions <- base::list()
  [14:20:57.908]     ...future.rng <- base::globalenv()$.Random.seed
  [14:20:57.908]     ...future.result <- base::tryCatch({
  [14:20:57.908]         base::withCallingHandlers({
  [14:20:57.908]             ...future.value <- base::withVisible(base::local({
  [14:20:57.908]                 4
  [14:20:57.908]             }))
  [14:20:57.908]             future::FutureResult(value = ...future.value$value, 
  [14:20:57.908]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.908]                   ...future.rng), started = ...future.startTime, 
  [14:20:57.908]                 version = "1.8")
  [14:20:57.908]         }, condition = base::local({
  [14:20:57.908]             c <- base::c
  [14:20:57.908]             inherits <- base::inherits
  [14:20:57.908]             invokeRestart <- base::invokeRestart
  [14:20:57.908]             length <- base::length
  [14:20:57.908]             list <- base::list
  [14:20:57.908]             seq.int <- base::seq.int
  [14:20:57.908]             signalCondition <- base::signalCondition
  [14:20:57.908]             sys.calls <- base::sys.calls
  [14:20:57.908]             Sys.time <- base::Sys.time
  [14:20:57.908]             `[[` <- base::`[[`
  [14:20:57.908]             `+` <- base::`+`
  [14:20:57.908]             `<<-` <- base::`<<-`
  [14:20:57.908]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:20:57.908]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:20:57.908]                   3L)]
  [14:20:57.908]             }
  [14:20:57.908]             function(cond) {
  [14:20:57.908]                 if (inherits(cond, "error")) {
  [14:20:57.908]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.908]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:20:57.908]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:20:57.908]                   signalCondition(cond)
  [14:20:57.908]                 }
  [14:20:57.908]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:20:57.908]                 ))) {
  [14:20:57.908]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:20:57.908]                   ...future.conditions[[length(...future.conditions) + 
  [14:20:57.908]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:20:57.908]                   if (!signal) {
  [14:20:57.908]                     muffleCondition <- function (cond) 
  [14:20:57.908]                     {
  [14:20:57.908]                       inherits <- base::inherits
  [14:20:57.908]                       invokeRestart <- base::invokeRestart
  [14:20:57.908]                       muffled <- FALSE
  [14:20:57.908]                       if (inherits(cond, "message")) {
  [14:20:57.908]                         invokeRestart("muffleMessage")
  [14:20:57.908]                         muffled <- TRUE
  [14:20:57.908]                       }
  [14:20:57.908]                       else if (inherits(cond, "warning")) {
  [14:20:57.908]                         invokeRestart("muffleWarning")
  [14:20:57.908]                         muffled <- TRUE
  [14:20:57.908]                       }
  [14:20:57.908]                       else if (inherits(cond, "condition")) {
  [14:20:57.908]                         computeRestarts <- base::computeRestarts
  [14:20:57.908]                         grepl <- base::grepl
  [14:20:57.908]                         is.null <- base::is.null
  [14:20:57.908]                         restarts <- computeRestarts(cond)
  [14:20:57.908]                         for (restart in restarts) {
  [14:20:57.908]                           name <- restart$name
  [14:20:57.908]                           if (is.null(name)) 
  [14:20:57.908]                             next
  [14:20:57.908]                           if (!grepl("^muffle", name)) 
  [14:20:57.908]                             next
  [14:20:57.908]                           invokeRestart(restart)
  [14:20:57.908]                           muffled <- TRUE
  [14:20:57.908]                           break
  [14:20:57.908]                         }
  [14:20:57.908]                       }
  [14:20:57.908]                       invisible(muffled)
  [14:20:57.908]                     }
  [14:20:57.908]                     muffleCondition(cond)
  [14:20:57.908]                   }
  [14:20:57.908]                 }
  [14:20:57.908]             }
  [14:20:57.908]         }))
  [14:20:57.908]     }, error = function(ex) {
  [14:20:57.908]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:20:57.908]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:20:57.908]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:20:57.908]     }, finally = {
  [14:20:57.908]         {
  [14:20:57.908]             NULL
  [14:20:57.908]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:20:57.908]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:20:57.908]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:20:57.908]                 label = NULL, ...) 
  [14:20:57.908]             {
  [14:20:57.908]                 if (substitute) 
  [14:20:57.908]                   expr <- substitute(expr)
  [14:20:57.908]                 local <- as.logical(local)
  [14:20:57.908]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:20:57.908]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:20:57.908]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:20:57.908]                   label = label, ...)
  [14:20:57.908]                 if (!future$lazy) 
  [14:20:57.908]                   future <- run(future)
  [14:20:57.908]                 invisible(future)
  [14:20:57.908]             }), .cleanup = FALSE, .init = FALSE)
  [14:20:57.908]         }
  [14:20:57.908]         base::options(...future.oldOptions)
  [14:20:57.908]     })
  [14:20:57.908]     Sys.time
  [14:20:57.908]     if (base::is.na(TRUE)) {
  [14:20:57.908]     }
  [14:20:57.908]     else {
  [14:20:57.908]         base::sink(type = "output", split = FALSE)
  [14:20:57.908]         if (TRUE) {
  [14:20:57.908]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:20:57.908]         }
  [14:20:57.908]         else {
  [14:20:57.908]             ...future.result["stdout"] <- base::list(NULL)
  [14:20:57.908]         }
  [14:20:57.908]         base::close(...future.stdout)
  [14:20:57.908]         ...future.stdout <- NULL
  [14:20:57.908]     }
  [14:20:57.908]     ...future.result$conditions <- ...future.conditions
  [14:20:57.908]     ...future.result
  [14:20:57.908] }
  [14:20:57.914] plan(): Setting new future strategy stack:
  [14:20:57.914] List of future strategies:
  [14:20:57.914] 1. sequential:
  [14:20:57.914]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.914]    - tweaked: FALSE
  [14:20:57.914]    - call: NULL
  [14:20:57.915] plan(): nbrOfWorkers() = 1
  [14:20:57.917] plan(): Setting new future strategy stack:
  [14:20:57.917] List of future strategies:
  [14:20:57.917] 1. sequential:
  [14:20:57.917]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:20:57.917]    - tweaked: FALSE
  [14:20:57.917]    - call: plan(strategy)
  [14:20:57.918] plan(): nbrOfWorkers() = 1
  [14:20:57.919] SequentialFuture started (and completed)
  <environment: 0x5574fa5bae98> 
  <environment: 0x5574fa5659f8> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:20:57.925] resolve() on environment ...
  [14:20:57.925]  recursive: 0
  [14:20:57.927]  elements: [4] 'a', 'b', 'c', 'd'
  [14:20:57.927] signalConditionsASAP(numeric, pos=1) ...
  [14:20:57.928] - nx: 4
  [14:20:57.928] - relay: TRUE
  [14:20:57.928] - stdout: TRUE
  [14:20:57.933] - signal: TRUE
  [14:20:57.934] - resignal: FALSE
  [14:20:57.934] - force: TRUE
  [14:20:57.935] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.935] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.935]  - until=2
  [14:20:57.936]  - relaying element #2
  [14:20:57.936] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.936] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.937] signalConditionsASAP(NULL, pos=1) ... done
  [14:20:57.937]  length: 3 (resolved future 1)
  [14:20:57.938] Future #2
  [14:20:57.938] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:20:57.938] - nx: 4
  [14:20:57.939] - relay: TRUE
  [14:20:57.939] - stdout: TRUE
  [14:20:57.939] - signal: TRUE
  [14:20:57.940] - resignal: FALSE
  [14:20:57.940] - force: TRUE
  [14:20:57.940] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:20:57.941] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:20:57.941]  - until=2
  [14:20:57.941]  - relaying element #2
  [14:20:57.942] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.942] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.942] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:20:57.943]  length: 2 (resolved future 2)
  [14:20:57.943] Future #3
  [14:20:57.944] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:20:57.944] - nx: 4
  [14:20:57.944] - relay: TRUE
  [14:20:57.944] - stdout: TRUE
  [14:20:57.945] - signal: TRUE
  [14:20:57.945] - resignal: FALSE
  [14:20:57.945] - force: TRUE
  [14:20:57.945] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:20:57.946] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:20:57.946]  - until=3
  [14:20:57.946]  - relaying element #3
  [14:20:57.947] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.947] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.947] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:20:57.948]  length: 1 (resolved future 3)
  [14:20:57.948] Future #4
  [14:20:57.949] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:20:57.949] - nx: 4
  [14:20:57.949] - relay: TRUE
  [14:20:57.949] - stdout: TRUE
  [14:20:57.950] - signal: TRUE
  [14:20:57.950] - resignal: FALSE
  [14:20:57.950] - force: TRUE
  [14:20:57.951] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:20:57.951] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:20:57.951]  - until=4
  [14:20:57.952]  - relaying element #4
  [14:20:57.952] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.952] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.953] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:20:57.953]  length: 0 (resolved future 4)
  [14:20:57.953] Relaying remaining futures
  [14:20:57.954] signalConditionsASAP(NULL, pos=0) ...
  [14:20:57.954] - nx: 4
  [14:20:57.954] - relay: TRUE
  [14:20:57.954] - stdout: TRUE
  [14:20:57.955] - signal: TRUE
  [14:20:57.955] - resignal: FALSE
  [14:20:57.955] - force: TRUE
  [14:20:57.956] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.956] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:20:57.957] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:20:57.957] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:20:57.957] signalConditionsASAP(NULL, pos=0) ... done
  [14:20:57.958] resolve() on environment ... DONE
  <environment: 0x5574fa658170> 
  Type of future: cluster
  [14:20:57.959] plan(): Setting new future strategy stack:
  [14:20:57.960] List of future strategies:
  [14:20:57.960] 1. cluster:
  [14:20:57.960]    - 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, ...)
  [14:20:57.960]    - tweaked: FALSE
  [14:20:57.960]    - call: plan(strategy)
  [14:20:57.961] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [14:20:57.961] cluster:
  [14:20:57.961] - 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, ...)
  [14:20:57.961] - tweaked: FALSE
  [14:20:57.961] - call: plan(strategy)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 27404
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpjYgzDn/future.parent=29608.73a857b3e13f.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpjYgzDn/future.parent=29608.73a857b3e13f.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futures.R:gimli:hornik:29608' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpjYgzDn/future.parent=29608.73a857b3e13f.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=27404 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
  [14:21:06.085] getGlobalsAndPackages() ...
  [14:21:06.086] Not searching for globals
  [14:21:06.086] - globals: [0] <none>
  [14:21:06.086] getGlobalsAndPackages() ... DONE
  [14:21:06.090] Packages needed by the future expression (n = 0): <none>
  [14:21:06.091] Packages needed by future strategies (n = 0): <none>
  [14:21:06.112] {
  [14:21:06.112]     {
  [14:21:06.112]         ...future.startTime <- base::Sys.time()
  [14:21:06.112]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.112]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.112]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.112]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.112]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.112]         {
  [14:21:06.112]             {
  [14:21:06.112]                 has_future <- base::requireNamespace("future", 
  [14:21:06.112]                   quietly = TRUE)
  [14:21:06.112]                 version <- if (has_future) 
  [14:21:06.112]                   utils::packageVersion("future")
  [14:21:06.112]                 else NULL
  [14:21:06.112]                 if (!has_future || version < "1.8.0") {
  [14:21:06.112]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.112]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.112]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.112]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.112]                       "release", "version")], collapse = " "), 
  [14:21:06.112]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.112]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.112]                     info)
  [14:21:06.112]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.112]                   if (!has_future) {
  [14:21:06.112]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.112]                       info)
  [14:21:06.112]                   }
  [14:21:06.112]                   else {
  [14:21:06.112]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.112]                       info, version)
  [14:21:06.112]                   }
  [14:21:06.112]                   base::stop(msg)
  [14:21:06.112]                 }
  [14:21:06.112]             }
  [14:21:06.112]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.112]         }
  [14:21:06.112]     }
  [14:21:06.112]     if (base::is.na(TRUE)) {
  [14:21:06.112]     }
  [14:21:06.112]     else {
  [14:21:06.112]         if (TRUE) {
  [14:21:06.112]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.112]                 open = "w")
  [14:21:06.112]         }
  [14:21:06.112]         else {
  [14:21:06.112]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.112]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.112]         }
  [14:21:06.112]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.112]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.112]             base::sink(type = "output", split = FALSE)
  [14:21:06.112]             base::close(...future.stdout)
  [14:21:06.112]         }, add = TRUE)
  [14:21:06.112]     }
  [14:21:06.112]     ...future.frame <- base::sys.nframe()
  [14:21:06.112]     ...future.conditions <- base::list()
  [14:21:06.112]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.112]     ...future.result <- base::tryCatch({
  [14:21:06.112]         base::withCallingHandlers({
  [14:21:06.112]             ...future.value <- base::withVisible(base::local({
  [14:21:06.112]                 ...future.sendCondition <- local({
  [14:21:06.112]                   sendCondition <- NULL
  [14:21:06.112]                   function(frame = 1L) {
  [14:21:06.112]                     if (is.function(sendCondition)) 
  [14:21:06.112]                       return(sendCondition)
  [14:21:06.112]                     ns <- getNamespace("parallel")
  [14:21:06.112]                     if (exists("sendData", mode = "function", 
  [14:21:06.112]                       envir = ns)) {
  [14:21:06.112]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.112]                         envir = ns)
  [14:21:06.112]                       envir <- sys.frame(frame)
  [14:21:06.112]                       master <- NULL
  [14:21:06.112]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.112]                         !identical(envir, emptyenv())) {
  [14:21:06.112]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.112]                           inherits = FALSE)) {
  [14:21:06.112]                           master <- get("master", mode = "list", 
  [14:21:06.112]                             envir = envir, inherits = FALSE)
  [14:21:06.112]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.112]                             sendCondition <<- function(cond) {
  [14:21:06.112]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.112]                                 success = TRUE)
  [14:21:06.112]                               parallel_sendData(master, data)
  [14:21:06.112]                             }
  [14:21:06.112]                             return(sendCondition)
  [14:21:06.112]                           }
  [14:21:06.112]                         }
  [14:21:06.112]                         frame <- frame + 1L
  [14:21:06.112]                         envir <- sys.frame(frame)
  [14:21:06.112]                       }
  [14:21:06.112]                     }
  [14:21:06.112]                     sendCondition <<- function(cond) NULL
  [14:21:06.112]                   }
  [14:21:06.112]                 })
  [14:21:06.112]                 withCallingHandlers({
  [14:21:06.112]                   NA
  [14:21:06.112]                 }, immediateCondition = function(cond) {
  [14:21:06.112]                   sendCondition <- ...future.sendCondition()
  [14:21:06.112]                   sendCondition(cond)
  [14:21:06.112]                   muffleCondition <- function (cond) 
  [14:21:06.112]                   {
  [14:21:06.112]                     inherits <- base::inherits
  [14:21:06.112]                     invokeRestart <- base::invokeRestart
  [14:21:06.112]                     muffled <- FALSE
  [14:21:06.112]                     if (inherits(cond, "message")) {
  [14:21:06.112]                       invokeRestart("muffleMessage")
  [14:21:06.112]                       muffled <- TRUE
  [14:21:06.112]                     }
  [14:21:06.112]                     else if (inherits(cond, "warning")) {
  [14:21:06.112]                       invokeRestart("muffleWarning")
  [14:21:06.112]                       muffled <- TRUE
  [14:21:06.112]                     }
  [14:21:06.112]                     else if (inherits(cond, "condition")) {
  [14:21:06.112]                       computeRestarts <- base::computeRestarts
  [14:21:06.112]                       grepl <- base::grepl
  [14:21:06.112]                       is.null <- base::is.null
  [14:21:06.112]                       restarts <- computeRestarts(cond)
  [14:21:06.112]                       for (restart in restarts) {
  [14:21:06.112]                         name <- restart$name
  [14:21:06.112]                         if (is.null(name)) 
  [14:21:06.112]                           next
  [14:21:06.112]                         if (!grepl("^muffle", name)) 
  [14:21:06.112]                           next
  [14:21:06.112]                         invokeRestart(restart)
  [14:21:06.112]                         muffled <- TRUE
  [14:21:06.112]                         break
  [14:21:06.112]                       }
  [14:21:06.112]                     }
  [14:21:06.112]                     invisible(muffled)
  [14:21:06.112]                   }
  [14:21:06.112]                   muffleCondition(cond)
  [14:21:06.112]                 })
  [14:21:06.112]             }))
  [14:21:06.112]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.112]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.112]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.112]                 version = "1.8")
  [14:21:06.112]         }, condition = base::local({
  [14:21:06.112]             c <- base::c
  [14:21:06.112]             inherits <- base::inherits
  [14:21:06.112]             invokeRestart <- base::invokeRestart
  [14:21:06.112]             length <- base::length
  [14:21:06.112]             list <- base::list
  [14:21:06.112]             seq.int <- base::seq.int
  [14:21:06.112]             signalCondition <- base::signalCondition
  [14:21:06.112]             sys.calls <- base::sys.calls
  [14:21:06.112]             Sys.time <- base::Sys.time
  [14:21:06.112]             `[[` <- base::`[[`
  [14:21:06.112]             `+` <- base::`+`
  [14:21:06.112]             `<<-` <- base::`<<-`
  [14:21:06.112]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.112]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.112]                   3L)]
  [14:21:06.112]             }
  [14:21:06.112]             function(cond) {
  [14:21:06.112]                 if (inherits(cond, "error")) {
  [14:21:06.112]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.112]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.112]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.112]                   signalCondition(cond)
  [14:21:06.112]                 }
  [14:21:06.112]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.112]                 ))) {
  [14:21:06.112]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.112]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.112]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.112]                   if (!signal) {
  [14:21:06.112]                     muffleCondition <- function (cond) 
  [14:21:06.112]                     {
  [14:21:06.112]                       inherits <- base::inherits
  [14:21:06.112]                       invokeRestart <- base::invokeRestart
  [14:21:06.112]                       muffled <- FALSE
  [14:21:06.112]                       if (inherits(cond, "message")) {
  [14:21:06.112]                         invokeRestart("muffleMessage")
  [14:21:06.112]                         muffled <- TRUE
  [14:21:06.112]                       }
  [14:21:06.112]                       else if (inherits(cond, "warning")) {
  [14:21:06.112]                         invokeRestart("muffleWarning")
  [14:21:06.112]                         muffled <- TRUE
  [14:21:06.112]                       }
  [14:21:06.112]                       else if (inherits(cond, "condition")) {
  [14:21:06.112]                         computeRestarts <- base::computeRestarts
  [14:21:06.112]                         grepl <- base::grepl
  [14:21:06.112]                         is.null <- base::is.null
  [14:21:06.112]                         restarts <- computeRestarts(cond)
  [14:21:06.112]                         for (restart in restarts) {
  [14:21:06.112]                           name <- restart$name
  [14:21:06.112]                           if (is.null(name)) 
  [14:21:06.112]                             next
  [14:21:06.112]                           if (!grepl("^muffle", name)) 
  [14:21:06.112]                             next
  [14:21:06.112]                           invokeRestart(restart)
  [14:21:06.112]                           muffled <- TRUE
  [14:21:06.112]                           break
  [14:21:06.112]                         }
  [14:21:06.112]                       }
  [14:21:06.112]                       invisible(muffled)
  [14:21:06.112]                     }
  [14:21:06.112]                     muffleCondition(cond)
  [14:21:06.112]                   }
  [14:21:06.112]                 }
  [14:21:06.112]             }
  [14:21:06.112]         }))
  [14:21:06.112]     }, error = function(ex) {
  [14:21:06.112]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.112]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.112]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.112]     }, finally = {
  [14:21:06.112]         {
  [14:21:06.112]             NULL
  [14:21:06.112]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.112]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.112]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.112]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.112]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.112]                 ...) 
  [14:21:06.112]             {
  [14:21:06.112]                 if (substitute) 
  [14:21:06.112]                   expr <- substitute(expr)
  [14:21:06.112]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.112]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.112]                   globals = globals, persistent = persistent, 
  [14:21:06.112]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.112]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.112]                   label = label, ...)
  [14:21:06.112]                 if (!future$lazy) 
  [14:21:06.112]                   future <- run(future)
  [14:21:06.112]                 invisible(future)
  [14:21:06.112]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.112]         }
  [14:21:06.112]         base::options(...future.oldOptions)
  [14:21:06.112]     })
  [14:21:06.112]     Sys.time
  [14:21:06.112]     if (base::is.na(TRUE)) {
  [14:21:06.112]     }
  [14:21:06.112]     else {
  [14:21:06.112]         base::sink(type = "output", split = FALSE)
  [14:21:06.112]         if (TRUE) {
  [14:21:06.112]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.112]         }
  [14:21:06.112]         else {
  [14:21:06.112]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.112]         }
  [14:21:06.112]         base::close(...future.stdout)
  [14:21:06.112]         ...future.stdout <- NULL
  [14:21:06.112]     }
  [14:21:06.112]     ...future.result$conditions <- ...future.conditions
  [14:21:06.112]     ...future.result
  [14:21:06.112] }
  [14:21:06.120] ClusterFuture started
  [14:21:06.120] result() for ClusterFuture ...
  [14:21:06.120] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.121] - Validating connection of ClusterFuture
  [14:21:06.327] - received message: FutureResult
  [14:21:06.328] - Received FutureResult
  [14:21:06.328] - Erased future from FutureRegistry
  [14:21:06.329] result() for ClusterFuture ...
  [14:21:06.329] - result already collected: FutureResult
  [14:21:06.329] result() for ClusterFuture ... done
  [14:21:06.330] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:06.330] result() for ClusterFuture ... done
  [14:21:06.331] result() for ClusterFuture ...
  [14:21:06.331] - result already collected: FutureResult
  [14:21:06.331] result() for ClusterFuture ... done
  [14:21:06.332] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [14:21:06.333] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [14:21:06.339] getGlobalsAndPackages() ...
  [14:21:06.339] Searching for globals...
  [14:21:06.340] 
  [14:21:06.340] Searching for globals ... DONE
  [14:21:06.341] - globals: [0] <none>
  [14:21:06.341] getGlobalsAndPackages() ... DONE
  [14:21:06.366] Packages needed by the future expression (n = 0): <none>
  [14:21:06.367] Packages needed by future strategies (n = 0): <none>
  [14:21:06.372] {
  [14:21:06.372]     {
  [14:21:06.372]         ...future.startTime <- base::Sys.time()
  [14:21:06.372]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.372]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.372]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.372]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.372]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.372]         {
  [14:21:06.372]             {
  [14:21:06.372]                 has_future <- base::requireNamespace("future", 
  [14:21:06.372]                   quietly = TRUE)
  [14:21:06.372]                 version <- if (has_future) 
  [14:21:06.372]                   utils::packageVersion("future")
  [14:21:06.372]                 else NULL
  [14:21:06.372]                 if (!has_future || version < "1.8.0") {
  [14:21:06.372]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.372]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.372]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.372]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.372]                       "release", "version")], collapse = " "), 
  [14:21:06.372]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.372]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.372]                     info)
  [14:21:06.372]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.372]                   if (!has_future) {
  [14:21:06.372]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.372]                       info)
  [14:21:06.372]                   }
  [14:21:06.372]                   else {
  [14:21:06.372]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.372]                       info, version)
  [14:21:06.372]                   }
  [14:21:06.372]                   base::stop(msg)
  [14:21:06.372]                 }
  [14:21:06.372]             }
  [14:21:06.372]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.372]         }
  [14:21:06.372]     }
  [14:21:06.372]     if (base::is.na(TRUE)) {
  [14:21:06.372]     }
  [14:21:06.372]     else {
  [14:21:06.372]         if (TRUE) {
  [14:21:06.372]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.372]                 open = "w")
  [14:21:06.372]         }
  [14:21:06.372]         else {
  [14:21:06.372]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.372]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.372]         }
  [14:21:06.372]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.372]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.372]             base::sink(type = "output", split = FALSE)
  [14:21:06.372]             base::close(...future.stdout)
  [14:21:06.372]         }, add = TRUE)
  [14:21:06.372]     }
  [14:21:06.372]     ...future.frame <- base::sys.nframe()
  [14:21:06.372]     ...future.conditions <- base::list()
  [14:21:06.372]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.372]     ...future.result <- base::tryCatch({
  [14:21:06.372]         base::withCallingHandlers({
  [14:21:06.372]             ...future.value <- base::withVisible(base::local({
  [14:21:06.372]                 ...future.sendCondition <- local({
  [14:21:06.372]                   sendCondition <- NULL
  [14:21:06.372]                   function(frame = 1L) {
  [14:21:06.372]                     if (is.function(sendCondition)) 
  [14:21:06.372]                       return(sendCondition)
  [14:21:06.372]                     ns <- getNamespace("parallel")
  [14:21:06.372]                     if (exists("sendData", mode = "function", 
  [14:21:06.372]                       envir = ns)) {
  [14:21:06.372]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.372]                         envir = ns)
  [14:21:06.372]                       envir <- sys.frame(frame)
  [14:21:06.372]                       master <- NULL
  [14:21:06.372]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.372]                         !identical(envir, emptyenv())) {
  [14:21:06.372]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.372]                           inherits = FALSE)) {
  [14:21:06.372]                           master <- get("master", mode = "list", 
  [14:21:06.372]                             envir = envir, inherits = FALSE)
  [14:21:06.372]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.372]                             sendCondition <<- function(cond) {
  [14:21:06.372]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.372]                                 success = TRUE)
  [14:21:06.372]                               parallel_sendData(master, data)
  [14:21:06.372]                             }
  [14:21:06.372]                             return(sendCondition)
  [14:21:06.372]                           }
  [14:21:06.372]                         }
  [14:21:06.372]                         frame <- frame + 1L
  [14:21:06.372]                         envir <- sys.frame(frame)
  [14:21:06.372]                       }
  [14:21:06.372]                     }
  [14:21:06.372]                     sendCondition <<- function(cond) NULL
  [14:21:06.372]                   }
  [14:21:06.372]                 })
  [14:21:06.372]                 withCallingHandlers({
  [14:21:06.372]                   2
  [14:21:06.372]                 }, immediateCondition = function(cond) {
  [14:21:06.372]                   sendCondition <- ...future.sendCondition()
  [14:21:06.372]                   sendCondition(cond)
  [14:21:06.372]                   muffleCondition <- function (cond) 
  [14:21:06.372]                   {
  [14:21:06.372]                     inherits <- base::inherits
  [14:21:06.372]                     invokeRestart <- base::invokeRestart
  [14:21:06.372]                     muffled <- FALSE
  [14:21:06.372]                     if (inherits(cond, "message")) {
  [14:21:06.372]                       invokeRestart("muffleMessage")
  [14:21:06.372]                       muffled <- TRUE
  [14:21:06.372]                     }
  [14:21:06.372]                     else if (inherits(cond, "warning")) {
  [14:21:06.372]                       invokeRestart("muffleWarning")
  [14:21:06.372]                       muffled <- TRUE
  [14:21:06.372]                     }
  [14:21:06.372]                     else if (inherits(cond, "condition")) {
  [14:21:06.372]                       computeRestarts <- base::computeRestarts
  [14:21:06.372]                       grepl <- base::grepl
  [14:21:06.372]                       is.null <- base::is.null
  [14:21:06.372]                       restarts <- computeRestarts(cond)
  [14:21:06.372]                       for (restart in restarts) {
  [14:21:06.372]                         name <- restart$name
  [14:21:06.372]                         if (is.null(name)) 
  [14:21:06.372]                           next
  [14:21:06.372]                         if (!grepl("^muffle", name)) 
  [14:21:06.372]                           next
  [14:21:06.372]                         invokeRestart(restart)
  [14:21:06.372]                         muffled <- TRUE
  [14:21:06.372]                         break
  [14:21:06.372]                       }
  [14:21:06.372]                     }
  [14:21:06.372]                     invisible(muffled)
  [14:21:06.372]                   }
  [14:21:06.372]                   muffleCondition(cond)
  [14:21:06.372]                 })
  [14:21:06.372]             }))
  [14:21:06.372]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.372]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.372]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.372]                 version = "1.8")
  [14:21:06.372]         }, condition = base::local({
  [14:21:06.372]             c <- base::c
  [14:21:06.372]             inherits <- base::inherits
  [14:21:06.372]             invokeRestart <- base::invokeRestart
  [14:21:06.372]             length <- base::length
  [14:21:06.372]             list <- base::list
  [14:21:06.372]             seq.int <- base::seq.int
  [14:21:06.372]             signalCondition <- base::signalCondition
  [14:21:06.372]             sys.calls <- base::sys.calls
  [14:21:06.372]             Sys.time <- base::Sys.time
  [14:21:06.372]             `[[` <- base::`[[`
  [14:21:06.372]             `+` <- base::`+`
  [14:21:06.372]             `<<-` <- base::`<<-`
  [14:21:06.372]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.372]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.372]                   3L)]
  [14:21:06.372]             }
  [14:21:06.372]             function(cond) {
  [14:21:06.372]                 if (inherits(cond, "error")) {
  [14:21:06.372]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.372]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.372]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.372]                   signalCondition(cond)
  [14:21:06.372]                 }
  [14:21:06.372]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.372]                 ))) {
  [14:21:06.372]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.372]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.372]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.372]                   if (!signal) {
  [14:21:06.372]                     muffleCondition <- function (cond) 
  [14:21:06.372]                     {
  [14:21:06.372]                       inherits <- base::inherits
  [14:21:06.372]                       invokeRestart <- base::invokeRestart
  [14:21:06.372]                       muffled <- FALSE
  [14:21:06.372]                       if (inherits(cond, "message")) {
  [14:21:06.372]                         invokeRestart("muffleMessage")
  [14:21:06.372]                         muffled <- TRUE
  [14:21:06.372]                       }
  [14:21:06.372]                       else if (inherits(cond, "warning")) {
  [14:21:06.372]                         invokeRestart("muffleWarning")
  [14:21:06.372]                         muffled <- TRUE
  [14:21:06.372]                       }
  [14:21:06.372]                       else if (inherits(cond, "condition")) {
  [14:21:06.372]                         computeRestarts <- base::computeRestarts
  [14:21:06.372]                         grepl <- base::grepl
  [14:21:06.372]                         is.null <- base::is.null
  [14:21:06.372]                         restarts <- computeRestarts(cond)
  [14:21:06.372]                         for (restart in restarts) {
  [14:21:06.372]                           name <- restart$name
  [14:21:06.372]                           if (is.null(name)) 
  [14:21:06.372]                             next
  [14:21:06.372]                           if (!grepl("^muffle", name)) 
  [14:21:06.372]                             next
  [14:21:06.372]                           invokeRestart(restart)
  [14:21:06.372]                           muffled <- TRUE
  [14:21:06.372]                           break
  [14:21:06.372]                         }
  [14:21:06.372]                       }
  [14:21:06.372]                       invisible(muffled)
  [14:21:06.372]                     }
  [14:21:06.372]                     muffleCondition(cond)
  [14:21:06.372]                   }
  [14:21:06.372]                 }
  [14:21:06.372]             }
  [14:21:06.372]         }))
  [14:21:06.372]     }, error = function(ex) {
  [14:21:06.372]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.372]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.372]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.372]     }, finally = {
  [14:21:06.372]         {
  [14:21:06.372]             NULL
  [14:21:06.372]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.372]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.372]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.372]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.372]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.372]                 ...) 
  [14:21:06.372]             {
  [14:21:06.372]                 if (substitute) 
  [14:21:06.372]                   expr <- substitute(expr)
  [14:21:06.372]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.372]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.372]                   globals = globals, persistent = persistent, 
  [14:21:06.372]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.372]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.372]                   label = label, ...)
  [14:21:06.372]                 if (!future$lazy) 
  [14:21:06.372]                   future <- run(future)
  [14:21:06.372]                 invisible(future)
  [14:21:06.372]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.372]         }
  [14:21:06.372]         base::options(...future.oldOptions)
  [14:21:06.372]     })
  [14:21:06.372]     Sys.time
  [14:21:06.372]     if (base::is.na(TRUE)) {
  [14:21:06.372]     }
  [14:21:06.372]     else {
  [14:21:06.372]         base::sink(type = "output", split = FALSE)
  [14:21:06.372]         if (TRUE) {
  [14:21:06.372]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.372]         }
  [14:21:06.372]         else {
  [14:21:06.372]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.372]         }
  [14:21:06.372]         base::close(...future.stdout)
  [14:21:06.372]         ...future.stdout <- NULL
  [14:21:06.372]     }
  [14:21:06.372]     ...future.result$conditions <- ...future.conditions
  [14:21:06.372]     ...future.result
  [14:21:06.372] }
  [14:21:06.403] ClusterFuture started
  [14:21:06.409] getGlobalsAndPackages() ...
  [14:21:06.409] Searching for globals...
  [14:21:06.410] 
  [14:21:06.410] Searching for globals ... DONE
  [14:21:06.411] - globals: [0] <none>
  [14:21:06.411] getGlobalsAndPackages() ... DONE
  [14:21:06.415] Packages needed by the future expression (n = 0): <none>
  [14:21:06.416] Packages needed by future strategies (n = 0): <none>
  [14:21:06.425] {
  [14:21:06.425]     {
  [14:21:06.425]         ...future.startTime <- base::Sys.time()
  [14:21:06.425]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.425]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.425]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.425]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.425]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.425]         {
  [14:21:06.425]             {
  [14:21:06.425]                 has_future <- base::requireNamespace("future", 
  [14:21:06.425]                   quietly = TRUE)
  [14:21:06.425]                 version <- if (has_future) 
  [14:21:06.425]                   utils::packageVersion("future")
  [14:21:06.425]                 else NULL
  [14:21:06.425]                 if (!has_future || version < "1.8.0") {
  [14:21:06.425]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.425]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.425]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.425]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.425]                       "release", "version")], collapse = " "), 
  [14:21:06.425]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.425]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.425]                     info)
  [14:21:06.425]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.425]                   if (!has_future) {
  [14:21:06.425]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.425]                       info)
  [14:21:06.425]                   }
  [14:21:06.425]                   else {
  [14:21:06.425]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.425]                       info, version)
  [14:21:06.425]                   }
  [14:21:06.425]                   base::stop(msg)
  [14:21:06.425]                 }
  [14:21:06.425]             }
  [14:21:06.425]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.425]         }
  [14:21:06.425]     }
  [14:21:06.425]     if (base::is.na(TRUE)) {
  [14:21:06.425]     }
  [14:21:06.425]     else {
  [14:21:06.425]         if (TRUE) {
  [14:21:06.425]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.425]                 open = "w")
  [14:21:06.425]         }
  [14:21:06.425]         else {
  [14:21:06.425]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.425]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.425]         }
  [14:21:06.425]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.425]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.425]             base::sink(type = "output", split = FALSE)
  [14:21:06.425]             base::close(...future.stdout)
  [14:21:06.425]         }, add = TRUE)
  [14:21:06.425]     }
  [14:21:06.425]     ...future.frame <- base::sys.nframe()
  [14:21:06.425]     ...future.conditions <- base::list()
  [14:21:06.425]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.425]     ...future.result <- base::tryCatch({
  [14:21:06.425]         base::withCallingHandlers({
  [14:21:06.425]             ...future.value <- base::withVisible(base::local({
  [14:21:06.425]                 ...future.sendCondition <- local({
  [14:21:06.425]                   sendCondition <- NULL
  [14:21:06.425]                   function(frame = 1L) {
  [14:21:06.425]                     if (is.function(sendCondition)) 
  [14:21:06.425]                       return(sendCondition)
  [14:21:06.425]                     ns <- getNamespace("parallel")
  [14:21:06.425]                     if (exists("sendData", mode = "function", 
  [14:21:06.425]                       envir = ns)) {
  [14:21:06.425]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.425]                         envir = ns)
  [14:21:06.425]                       envir <- sys.frame(frame)
  [14:21:06.425]                       master <- NULL
  [14:21:06.425]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.425]                         !identical(envir, emptyenv())) {
  [14:21:06.425]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.425]                           inherits = FALSE)) {
  [14:21:06.425]                           master <- get("master", mode = "list", 
  [14:21:06.425]                             envir = envir, inherits = FALSE)
  [14:21:06.425]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.425]                             sendCondition <<- function(cond) {
  [14:21:06.425]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.425]                                 success = TRUE)
  [14:21:06.425]                               parallel_sendData(master, data)
  [14:21:06.425]                             }
  [14:21:06.425]                             return(sendCondition)
  [14:21:06.425]                           }
  [14:21:06.425]                         }
  [14:21:06.425]                         frame <- frame + 1L
  [14:21:06.425]                         envir <- sys.frame(frame)
  [14:21:06.425]                       }
  [14:21:06.425]                     }
  [14:21:06.425]                     sendCondition <<- function(cond) NULL
  [14:21:06.425]                   }
  [14:21:06.425]                 })
  [14:21:06.425]                 withCallingHandlers({
  [14:21:06.425]                   NULL
  [14:21:06.425]                 }, immediateCondition = function(cond) {
  [14:21:06.425]                   sendCondition <- ...future.sendCondition()
  [14:21:06.425]                   sendCondition(cond)
  [14:21:06.425]                   muffleCondition <- function (cond) 
  [14:21:06.425]                   {
  [14:21:06.425]                     inherits <- base::inherits
  [14:21:06.425]                     invokeRestart <- base::invokeRestart
  [14:21:06.425]                     muffled <- FALSE
  [14:21:06.425]                     if (inherits(cond, "message")) {
  [14:21:06.425]                       invokeRestart("muffleMessage")
  [14:21:06.425]                       muffled <- TRUE
  [14:21:06.425]                     }
  [14:21:06.425]                     else if (inherits(cond, "warning")) {
  [14:21:06.425]                       invokeRestart("muffleWarning")
  [14:21:06.425]                       muffled <- TRUE
  [14:21:06.425]                     }
  [14:21:06.425]                     else if (inherits(cond, "condition")) {
  [14:21:06.425]                       computeRestarts <- base::computeRestarts
  [14:21:06.425]                       grepl <- base::grepl
  [14:21:06.425]                       is.null <- base::is.null
  [14:21:06.425]                       restarts <- computeRestarts(cond)
  [14:21:06.425]                       for (restart in restarts) {
  [14:21:06.425]                         name <- restart$name
  [14:21:06.425]                         if (is.null(name)) 
  [14:21:06.425]                           next
  [14:21:06.425]                         if (!grepl("^muffle", name)) 
  [14:21:06.425]                           next
  [14:21:06.425]                         invokeRestart(restart)
  [14:21:06.425]                         muffled <- TRUE
  [14:21:06.425]                         break
  [14:21:06.425]                       }
  [14:21:06.425]                     }
  [14:21:06.425]                     invisible(muffled)
  [14:21:06.425]                   }
  [14:21:06.425]                   muffleCondition(cond)
  [14:21:06.425]                 })
  [14:21:06.425]             }))
  [14:21:06.425]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.425]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.425]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.425]                 version = "1.8")
  [14:21:06.425]         }, condition = base::local({
  [14:21:06.425]             c <- base::c
  [14:21:06.425]             inherits <- base::inherits
  [14:21:06.425]             invokeRestart <- base::invokeRestart
  [14:21:06.425]             length <- base::length
  [14:21:06.425]             list <- base::list
  [14:21:06.425]             seq.int <- base::seq.int
  [14:21:06.425]             signalCondition <- base::signalCondition
  [14:21:06.425]             sys.calls <- base::sys.calls
  [14:21:06.425]             Sys.time <- base::Sys.time
  [14:21:06.425]             `[[` <- base::`[[`
  [14:21:06.425]             `+` <- base::`+`
  [14:21:06.425]             `<<-` <- base::`<<-`
  [14:21:06.425]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.425]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.425]                   3L)]
  [14:21:06.425]             }
  [14:21:06.425]             function(cond) {
  [14:21:06.425]                 if (inherits(cond, "error")) {
  [14:21:06.425]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.425]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.425]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.425]                   signalCondition(cond)
  [14:21:06.425]                 }
  [14:21:06.425]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.425]                 ))) {
  [14:21:06.425]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.425]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.425]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.425]                   if (!signal) {
  [14:21:06.425]                     muffleCondition <- function (cond) 
  [14:21:06.425]                     {
  [14:21:06.425]                       inherits <- base::inherits
  [14:21:06.425]                       invokeRestart <- base::invokeRestart
  [14:21:06.425]                       muffled <- FALSE
  [14:21:06.425]                       if (inherits(cond, "message")) {
  [14:21:06.425]                         invokeRestart("muffleMessage")
  [14:21:06.425]                         muffled <- TRUE
  [14:21:06.425]                       }
  [14:21:06.425]                       else if (inherits(cond, "warning")) {
  [14:21:06.425]                         invokeRestart("muffleWarning")
  [14:21:06.425]                         muffled <- TRUE
  [14:21:06.425]                       }
  [14:21:06.425]                       else if (inherits(cond, "condition")) {
  [14:21:06.425]                         computeRestarts <- base::computeRestarts
  [14:21:06.425]                         grepl <- base::grepl
  [14:21:06.425]                         is.null <- base::is.null
  [14:21:06.425]                         restarts <- computeRestarts(cond)
  [14:21:06.425]                         for (restart in restarts) {
  [14:21:06.425]                           name <- restart$name
  [14:21:06.425]                           if (is.null(name)) 
  [14:21:06.425]                             next
  [14:21:06.425]                           if (!grepl("^muffle", name)) 
  [14:21:06.425]                             next
  [14:21:06.425]                           invokeRestart(restart)
  [14:21:06.425]                           muffled <- TRUE
  [14:21:06.425]                           break
  [14:21:06.425]                         }
  [14:21:06.425]                       }
  [14:21:06.425]                       invisible(muffled)
  [14:21:06.425]                     }
  [14:21:06.425]                     muffleCondition(cond)
  [14:21:06.425]                   }
  [14:21:06.425]                 }
  [14:21:06.425]             }
  [14:21:06.425]         }))
  [14:21:06.425]     }, error = function(ex) {
  [14:21:06.425]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.425]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.425]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.425]     }, finally = {
  [14:21:06.425]         {
  [14:21:06.425]             NULL
  [14:21:06.425]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.425]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.425]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.425]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.425]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.425]                 ...) 
  [14:21:06.425]             {
  [14:21:06.425]                 if (substitute) 
  [14:21:06.425]                   expr <- substitute(expr)
  [14:21:06.425]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.425]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.425]                   globals = globals, persistent = persistent, 
  [14:21:06.425]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.425]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.425]                   label = label, ...)
  [14:21:06.425]                 if (!future$lazy) 
  [14:21:06.425]                   future <- run(future)
  [14:21:06.425]                 invisible(future)
  [14:21:06.425]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.425]         }
  [14:21:06.425]         base::options(...future.oldOptions)
  [14:21:06.425]     })
  [14:21:06.425]     Sys.time
  [14:21:06.425]     if (base::is.na(TRUE)) {
  [14:21:06.425]     }
  [14:21:06.425]     else {
  [14:21:06.425]         base::sink(type = "output", split = FALSE)
  [14:21:06.425]         if (TRUE) {
  [14:21:06.425]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.425]         }
  [14:21:06.425]         else {
  [14:21:06.425]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.425]         }
  [14:21:06.425]         base::close(...future.stdout)
  [14:21:06.425]         ...future.stdout <- NULL
  [14:21:06.425]     }
  [14:21:06.425]     ...future.result$conditions <- ...future.conditions
  [14:21:06.425]     ...future.result
  [14:21:06.425] }
  [14:21:06.432] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:06.451] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.452] - Validating connection of ClusterFuture
  [14:21:06.452] - received message: FutureResult
  [14:21:06.453] - Received FutureResult
  [14:21:06.453] - Erased future from FutureRegistry
  [14:21:06.454] result() for ClusterFuture ...
  [14:21:06.454] - result already collected: FutureResult
  [14:21:06.454] result() for ClusterFuture ... done
  [14:21:06.455] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:06.455] result() for ClusterFuture ...
  [14:21:06.455] - result already collected: FutureResult
  [14:21:06.456] result() for ClusterFuture ... done
  [14:21:06.456] result() for ClusterFuture ...
  [14:21:06.457] - result already collected: FutureResult
  [14:21:06.457] result() for ClusterFuture ... done
  [14:21:06.471] ClusterFuture started
  [14:21:06.477] getGlobalsAndPackages() ...
  [14:21:06.478] Searching for globals...
  [14:21:06.479] - globals found: [1] '{'
  [14:21:06.480] Searching for globals ... DONE
  [14:21:06.480] Resolving globals: FALSE
  [14:21:06.481] 
  [14:21:06.481] 
  [14:21:06.482] getGlobalsAndPackages() ... DONE
  [14:21:06.486] Packages needed by the future expression (n = 0): <none>
  [14:21:06.486] Packages needed by future strategies (n = 0): <none>
  [14:21:06.508] {
  [14:21:06.508]     {
  [14:21:06.508]         ...future.startTime <- base::Sys.time()
  [14:21:06.508]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.508]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.508]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.508]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.508]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.508]         {
  [14:21:06.508]             {
  [14:21:06.508]                 has_future <- base::requireNamespace("future", 
  [14:21:06.508]                   quietly = TRUE)
  [14:21:06.508]                 version <- if (has_future) 
  [14:21:06.508]                   utils::packageVersion("future")
  [14:21:06.508]                 else NULL
  [14:21:06.508]                 if (!has_future || version < "1.8.0") {
  [14:21:06.508]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.508]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.508]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.508]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.508]                       "release", "version")], collapse = " "), 
  [14:21:06.508]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.508]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.508]                     info)
  [14:21:06.508]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.508]                   if (!has_future) {
  [14:21:06.508]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.508]                       info)
  [14:21:06.508]                   }
  [14:21:06.508]                   else {
  [14:21:06.508]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.508]                       info, version)
  [14:21:06.508]                   }
  [14:21:06.508]                   base::stop(msg)
  [14:21:06.508]                 }
  [14:21:06.508]             }
  [14:21:06.508]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.508]         }
  [14:21:06.508]     }
  [14:21:06.508]     if (base::is.na(TRUE)) {
  [14:21:06.508]     }
  [14:21:06.508]     else {
  [14:21:06.508]         if (TRUE) {
  [14:21:06.508]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.508]                 open = "w")
  [14:21:06.508]         }
  [14:21:06.508]         else {
  [14:21:06.508]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.508]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.508]         }
  [14:21:06.508]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.508]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.508]             base::sink(type = "output", split = FALSE)
  [14:21:06.508]             base::close(...future.stdout)
  [14:21:06.508]         }, add = TRUE)
  [14:21:06.508]     }
  [14:21:06.508]     ...future.frame <- base::sys.nframe()
  [14:21:06.508]     ...future.conditions <- base::list()
  [14:21:06.508]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.508]     ...future.result <- base::tryCatch({
  [14:21:06.508]         base::withCallingHandlers({
  [14:21:06.508]             ...future.value <- base::withVisible(base::local({
  [14:21:06.508]                 ...future.sendCondition <- local({
  [14:21:06.508]                   sendCondition <- NULL
  [14:21:06.508]                   function(frame = 1L) {
  [14:21:06.508]                     if (is.function(sendCondition)) 
  [14:21:06.508]                       return(sendCondition)
  [14:21:06.508]                     ns <- getNamespace("parallel")
  [14:21:06.508]                     if (exists("sendData", mode = "function", 
  [14:21:06.508]                       envir = ns)) {
  [14:21:06.508]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.508]                         envir = ns)
  [14:21:06.508]                       envir <- sys.frame(frame)
  [14:21:06.508]                       master <- NULL
  [14:21:06.508]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.508]                         !identical(envir, emptyenv())) {
  [14:21:06.508]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.508]                           inherits = FALSE)) {
  [14:21:06.508]                           master <- get("master", mode = "list", 
  [14:21:06.508]                             envir = envir, inherits = FALSE)
  [14:21:06.508]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.508]                             sendCondition <<- function(cond) {
  [14:21:06.508]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.508]                                 success = TRUE)
  [14:21:06.508]                               parallel_sendData(master, data)
  [14:21:06.508]                             }
  [14:21:06.508]                             return(sendCondition)
  [14:21:06.508]                           }
  [14:21:06.508]                         }
  [14:21:06.508]                         frame <- frame + 1L
  [14:21:06.508]                         envir <- sys.frame(frame)
  [14:21:06.508]                       }
  [14:21:06.508]                     }
  [14:21:06.508]                     sendCondition <<- function(cond) NULL
  [14:21:06.508]                   }
  [14:21:06.508]                 })
  [14:21:06.508]                 withCallingHandlers({
  [14:21:06.508]                   {
  [14:21:06.508]                     4
  [14:21:06.508]                   }
  [14:21:06.508]                 }, immediateCondition = function(cond) {
  [14:21:06.508]                   sendCondition <- ...future.sendCondition()
  [14:21:06.508]                   sendCondition(cond)
  [14:21:06.508]                   muffleCondition <- function (cond) 
  [14:21:06.508]                   {
  [14:21:06.508]                     inherits <- base::inherits
  [14:21:06.508]                     invokeRestart <- base::invokeRestart
  [14:21:06.508]                     muffled <- FALSE
  [14:21:06.508]                     if (inherits(cond, "message")) {
  [14:21:06.508]                       invokeRestart("muffleMessage")
  [14:21:06.508]                       muffled <- TRUE
  [14:21:06.508]                     }
  [14:21:06.508]                     else if (inherits(cond, "warning")) {
  [14:21:06.508]                       invokeRestart("muffleWarning")
  [14:21:06.508]                       muffled <- TRUE
  [14:21:06.508]                     }
  [14:21:06.508]                     else if (inherits(cond, "condition")) {
  [14:21:06.508]                       computeRestarts <- base::computeRestarts
  [14:21:06.508]                       grepl <- base::grepl
  [14:21:06.508]                       is.null <- base::is.null
  [14:21:06.508]                       restarts <- computeRestarts(cond)
  [14:21:06.508]                       for (restart in restarts) {
  [14:21:06.508]                         name <- restart$name
  [14:21:06.508]                         if (is.null(name)) 
  [14:21:06.508]                           next
  [14:21:06.508]                         if (!grepl("^muffle", name)) 
  [14:21:06.508]                           next
  [14:21:06.508]                         invokeRestart(restart)
  [14:21:06.508]                         muffled <- TRUE
  [14:21:06.508]                         break
  [14:21:06.508]                       }
  [14:21:06.508]                     }
  [14:21:06.508]                     invisible(muffled)
  [14:21:06.508]                   }
  [14:21:06.508]                   muffleCondition(cond)
  [14:21:06.508]                 })
  [14:21:06.508]             }))
  [14:21:06.508]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.508]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.508]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.508]                 version = "1.8")
  [14:21:06.508]         }, condition = base::local({
  [14:21:06.508]             c <- base::c
  [14:21:06.508]             inherits <- base::inherits
  [14:21:06.508]             invokeRestart <- base::invokeRestart
  [14:21:06.508]             length <- base::length
  [14:21:06.508]             list <- base::list
  [14:21:06.508]             seq.int <- base::seq.int
  [14:21:06.508]             signalCondition <- base::signalCondition
  [14:21:06.508]             sys.calls <- base::sys.calls
  [14:21:06.508]             Sys.time <- base::Sys.time
  [14:21:06.508]             `[[` <- base::`[[`
  [14:21:06.508]             `+` <- base::`+`
  [14:21:06.508]             `<<-` <- base::`<<-`
  [14:21:06.508]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.508]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.508]                   3L)]
  [14:21:06.508]             }
  [14:21:06.508]             function(cond) {
  [14:21:06.508]                 if (inherits(cond, "error")) {
  [14:21:06.508]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.508]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.508]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.508]                   signalCondition(cond)
  [14:21:06.508]                 }
  [14:21:06.508]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.508]                 ))) {
  [14:21:06.508]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.508]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.508]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.508]                   if (!signal) {
  [14:21:06.508]                     muffleCondition <- function (cond) 
  [14:21:06.508]                     {
  [14:21:06.508]                       inherits <- base::inherits
  [14:21:06.508]                       invokeRestart <- base::invokeRestart
  [14:21:06.508]                       muffled <- FALSE
  [14:21:06.508]                       if (inherits(cond, "message")) {
  [14:21:06.508]                         invokeRestart("muffleMessage")
  [14:21:06.508]                         muffled <- TRUE
  [14:21:06.508]                       }
  [14:21:06.508]                       else if (inherits(cond, "warning")) {
  [14:21:06.508]                         invokeRestart("muffleWarning")
  [14:21:06.508]                         muffled <- TRUE
  [14:21:06.508]                       }
  [14:21:06.508]                       else if (inherits(cond, "condition")) {
  [14:21:06.508]                         computeRestarts <- base::computeRestarts
  [14:21:06.508]                         grepl <- base::grepl
  [14:21:06.508]                         is.null <- base::is.null
  [14:21:06.508]                         restarts <- computeRestarts(cond)
  [14:21:06.508]                         for (restart in restarts) {
  [14:21:06.508]                           name <- restart$name
  [14:21:06.508]                           if (is.null(name)) 
  [14:21:06.508]                             next
  [14:21:06.508]                           if (!grepl("^muffle", name)) 
  [14:21:06.508]                             next
  [14:21:06.508]                           invokeRestart(restart)
  [14:21:06.508]                           muffled <- TRUE
  [14:21:06.508]                           break
  [14:21:06.508]                         }
  [14:21:06.508]                       }
  [14:21:06.508]                       invisible(muffled)
  [14:21:06.508]                     }
  [14:21:06.508]                     muffleCondition(cond)
  [14:21:06.508]                   }
  [14:21:06.508]                 }
  [14:21:06.508]             }
  [14:21:06.508]         }))
  [14:21:06.508]     }, error = function(ex) {
  [14:21:06.508]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.508]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.508]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.508]     }, finally = {
  [14:21:06.508]         {
  [14:21:06.508]             NULL
  [14:21:06.508]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.508]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.508]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.508]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.508]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.508]                 ...) 
  [14:21:06.508]             {
  [14:21:06.508]                 if (substitute) 
  [14:21:06.508]                   expr <- substitute(expr)
  [14:21:06.508]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.508]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.508]                   globals = globals, persistent = persistent, 
  [14:21:06.508]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.508]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.508]                   label = label, ...)
  [14:21:06.508]                 if (!future$lazy) 
  [14:21:06.508]                   future <- run(future)
  [14:21:06.508]                 invisible(future)
  [14:21:06.508]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.508]         }
  [14:21:06.508]         base::options(...future.oldOptions)
  [14:21:06.508]     })
  [14:21:06.508]     Sys.time
  [14:21:06.508]     if (base::is.na(TRUE)) {
  [14:21:06.508]     }
  [14:21:06.508]     else {
  [14:21:06.508]         base::sink(type = "output", split = FALSE)
  [14:21:06.508]         if (TRUE) {
  [14:21:06.508]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.508]         }
  [14:21:06.508]         else {
  [14:21:06.508]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.508]         }
  [14:21:06.508]         base::close(...future.stdout)
  [14:21:06.508]         ...future.stdout <- NULL
  [14:21:06.508]     }
  [14:21:06.508]     ...future.result$conditions <- ...future.conditions
  [14:21:06.508]     ...future.result
  [14:21:06.508] }
  [14:21:06.515] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:06.527] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.527] - Validating connection of ClusterFuture
  [14:21:06.528] - received message: FutureResult
  [14:21:06.528] - Received FutureResult
  [14:21:06.529] - Erased future from FutureRegistry
  [14:21:06.529] result() for ClusterFuture ...
  [14:21:06.529] - result already collected: FutureResult
  [14:21:06.530] result() for ClusterFuture ... done
  [14:21:06.530] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:06.530] result() for ClusterFuture ...
  [14:21:06.531] - result already collected: FutureResult
  [14:21:06.531] result() for ClusterFuture ... done
  [14:21:06.532] result() for ClusterFuture ...
  [14:21:06.532] - result already collected: FutureResult
  [14:21:06.532] result() for ClusterFuture ... done
  [14:21:06.543] ClusterFuture started
  <environment: 0x5574fa553838> 
  <environment: 0x5574fabbb470> 
  [14:21:06.592] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.592] - Validating connection of ClusterFuture
  [14:21:06.593] - received message: FutureResult
  [14:21:06.593] - Received FutureResult
  [14:21:06.593] - Erased future from FutureRegistry
  [14:21:06.594] result() for ClusterFuture ...
  [14:21:06.594] - result already collected: FutureResult
  [14:21:06.594] result() for ClusterFuture ... done
  [14:21:06.595] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:21:06.598] resolve() on environment ...
  [14:21:06.598]  recursive: 0
  [14:21:06.599]  elements: [4] 'a', 'b', 'c', 'd'
  [14:21:06.600] signalConditionsASAP(numeric, pos=1) ...
  [14:21:06.600] - nx: 4
  [14:21:06.600] - relay: TRUE
  [14:21:06.601] - stdout: TRUE
  [14:21:06.601] - signal: TRUE
  [14:21:06.601] - resignal: FALSE
  [14:21:06.601] - force: TRUE
  [14:21:06.602] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.602] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.602]  - until=2
  [14:21:06.603]  - relaying element #2
  [14:21:06.603] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:06.603] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.604] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:06.604]  length: 3 (resolved future 1)
  [14:21:06.604] Future #2
  [14:21:06.604] result() for ClusterFuture ...
  [14:21:06.605] - result already collected: FutureResult
  [14:21:06.605] result() for ClusterFuture ... done
  [14:21:06.605] result() for ClusterFuture ...
  [14:21:06.606] - result already collected: FutureResult
  [14:21:06.606] result() for ClusterFuture ... done
  [14:21:06.606] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:21:06.607] - nx: 4
  [14:21:06.607] - relay: TRUE
  [14:21:06.607] - stdout: TRUE
  [14:21:06.607] - signal: TRUE
  [14:21:06.608] - resignal: FALSE
  [14:21:06.608] - force: TRUE
  [14:21:06.608] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:06.608] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.609]  - until=2
  [14:21:06.609]  - relaying element #2
  [14:21:06.609] result() for ClusterFuture ...
  [14:21:06.610] - result already collected: FutureResult
  [14:21:06.610] result() for ClusterFuture ... done
  [14:21:06.610] result() for ClusterFuture ...
  [14:21:06.611] - result already collected: FutureResult
  [14:21:06.611] result() for ClusterFuture ... done
  [14:21:06.611] result() for ClusterFuture ...
  [14:21:06.612] - result already collected: FutureResult
  [14:21:06.612] result() for ClusterFuture ... done
  [14:21:06.612] result() for ClusterFuture ...
  [14:21:06.612] - result already collected: FutureResult
  [14:21:06.613] result() for ClusterFuture ... done
  [14:21:06.613] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:06.613] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:06.614] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:21:06.614]  length: 2 (resolved future 2)
  [14:21:06.614] Future #3
  [14:21:06.615] result() for ClusterFuture ...
  [14:21:06.615] - result already collected: FutureResult
  [14:21:06.615] result() for ClusterFuture ... done
  [14:21:06.616] result() for ClusterFuture ...
  [14:21:06.616] - result already collected: FutureResult
  [14:21:06.616] result() for ClusterFuture ... done
  [14:21:06.617] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:21:06.617] - nx: 4
  [14:21:06.617] - relay: TRUE
  [14:21:06.618] - stdout: TRUE
  [14:21:06.618] - signal: TRUE
  [14:21:06.618] - resignal: FALSE
  [14:21:06.634] - force: TRUE
  [14:21:06.635] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:06.635] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:06.636]  - until=3
  [14:21:06.636]  - relaying element #3
  [14:21:06.636] result() for ClusterFuture ...
  [14:21:06.637] - result already collected: FutureResult
  [14:21:06.637] result() for ClusterFuture ... done
  [14:21:06.637] result() for ClusterFuture ...
  [14:21:06.638] - result already collected: FutureResult
  [14:21:06.638] result() for ClusterFuture ... done
  [14:21:06.638] result() for ClusterFuture ...
  [14:21:06.639] - result already collected: FutureResult
  [14:21:06.639] result() for ClusterFuture ... done
  [14:21:06.640] result() for ClusterFuture ...
  [14:21:06.640] - result already collected: FutureResult
  [14:21:06.640] result() for ClusterFuture ... done
  [14:21:06.641] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:06.641] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:06.641] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:21:06.642]  length: 1 (resolved future 3)
  [14:21:06.642] Future #4
  [14:21:06.642] result() for ClusterFuture ...
  [14:21:06.643] - result already collected: FutureResult
  [14:21:06.643] result() for ClusterFuture ... done
  [14:21:06.643] result() for ClusterFuture ...
  [14:21:06.644] - result already collected: FutureResult
  [14:21:06.644] result() for ClusterFuture ... done
  [14:21:06.644] signalConditionsASAP(ClusterFuture, pos=4) ...
  [14:21:06.645] - nx: 4
  [14:21:06.645] - relay: TRUE
  [14:21:06.645] - stdout: TRUE
  [14:21:06.646] - signal: TRUE
  [14:21:06.646] - resignal: FALSE
  [14:21:06.646] - force: TRUE
  [14:21:06.647] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:06.647] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:06.647]  - until=4
  [14:21:06.648]  - relaying element #4
  [14:21:06.648] result() for ClusterFuture ...
  [14:21:06.648] - result already collected: FutureResult
  [14:21:06.649] result() for ClusterFuture ... done
  [14:21:06.649] result() for ClusterFuture ...
  [14:21:06.649] - result already collected: FutureResult
  [14:21:06.650] result() for ClusterFuture ... done
  [14:21:06.650] result() for ClusterFuture ...
  [14:21:06.651] - result already collected: FutureResult
  [14:21:06.651] result() for ClusterFuture ... done
  [14:21:06.651] result() for ClusterFuture ...
  [14:21:06.652] - result already collected: FutureResult
  [14:21:06.652] result() for ClusterFuture ... done
  [14:21:06.652] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.653] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:06.653] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [14:21:06.653]  length: 0 (resolved future 4)
  [14:21:06.654] Relaying remaining futures
  [14:21:06.654] signalConditionsASAP(NULL, pos=0) ...
  [14:21:06.654] - nx: 4
  [14:21:06.654] - relay: TRUE
  [14:21:06.655] - stdout: TRUE
  [14:21:06.655] - signal: TRUE
  [14:21:06.655] - resignal: FALSE
  [14:21:06.656] - force: TRUE
  [14:21:06.656] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.656] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:21:06.657] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.657] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:06.657] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:06.658] resolve() on environment ... DONE
  [14:21:06.658] result() for ClusterFuture ...
  [14:21:06.659] - result already collected: FutureResult
  [14:21:06.659] result() for ClusterFuture ... done
  [14:21:06.659] result() for ClusterFuture ...
  [14:21:06.660] - result already collected: FutureResult
  [14:21:06.660] result() for ClusterFuture ... done
  [14:21:06.660] result() for ClusterFuture ...
  [14:21:06.661] - result already collected: FutureResult
  [14:21:06.661] result() for ClusterFuture ... done
  [14:21:06.661] result() for ClusterFuture ...
  [14:21:06.662] - result already collected: FutureResult
  [14:21:06.662] result() for ClusterFuture ... done
  [14:21:06.662] result() for ClusterFuture ...
  [14:21:06.663] - result already collected: FutureResult
  [14:21:06.663] result() for ClusterFuture ... done
  [14:21:06.663] result() for ClusterFuture ...
  [14:21:06.664] - result already collected: FutureResult
  [14:21:06.664] result() for ClusterFuture ... done
  <environment: 0x5574f8cb4b60> 
  Dimensions: c(1, 6)
  [14:21:06.671] getGlobalsAndPackages() ...
  [14:21:06.672] Searching for globals...
  [14:21:06.673] 
  [14:21:06.679] Searching for globals ... DONE
  [14:21:06.680] - globals: [0] <none>
  [14:21:06.680] getGlobalsAndPackages() ... DONE
  [14:21:06.684] Packages needed by the future expression (n = 0): <none>
  [14:21:06.685] Packages needed by future strategies (n = 0): <none>
  [14:21:06.690] {
  [14:21:06.690]     {
  [14:21:06.690]         ...future.startTime <- base::Sys.time()
  [14:21:06.690]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.690]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.690]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.690]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.690]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.690]         {
  [14:21:06.690]             {
  [14:21:06.690]                 has_future <- base::requireNamespace("future", 
  [14:21:06.690]                   quietly = TRUE)
  [14:21:06.690]                 version <- if (has_future) 
  [14:21:06.690]                   utils::packageVersion("future")
  [14:21:06.690]                 else NULL
  [14:21:06.690]                 if (!has_future || version < "1.8.0") {
  [14:21:06.690]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.690]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.690]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.690]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.690]                       "release", "version")], collapse = " "), 
  [14:21:06.690]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.690]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.690]                     info)
  [14:21:06.690]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.690]                   if (!has_future) {
  [14:21:06.690]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.690]                       info)
  [14:21:06.690]                   }
  [14:21:06.690]                   else {
  [14:21:06.690]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.690]                       info, version)
  [14:21:06.690]                   }
  [14:21:06.690]                   base::stop(msg)
  [14:21:06.690]                 }
  [14:21:06.690]             }
  [14:21:06.690]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.690]         }
  [14:21:06.690]     }
  [14:21:06.690]     if (base::is.na(TRUE)) {
  [14:21:06.690]     }
  [14:21:06.690]     else {
  [14:21:06.690]         if (TRUE) {
  [14:21:06.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.690]                 open = "w")
  [14:21:06.690]         }
  [14:21:06.690]         else {
  [14:21:06.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.690]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.690]         }
  [14:21:06.690]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.690]             base::sink(type = "output", split = FALSE)
  [14:21:06.690]             base::close(...future.stdout)
  [14:21:06.690]         }, add = TRUE)
  [14:21:06.690]     }
  [14:21:06.690]     ...future.frame <- base::sys.nframe()
  [14:21:06.690]     ...future.conditions <- base::list()
  [14:21:06.690]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.690]     ...future.result <- base::tryCatch({
  [14:21:06.690]         base::withCallingHandlers({
  [14:21:06.690]             ...future.value <- base::withVisible(base::local({
  [14:21:06.690]                 ...future.sendCondition <- local({
  [14:21:06.690]                   sendCondition <- NULL
  [14:21:06.690]                   function(frame = 1L) {
  [14:21:06.690]                     if (is.function(sendCondition)) 
  [14:21:06.690]                       return(sendCondition)
  [14:21:06.690]                     ns <- getNamespace("parallel")
  [14:21:06.690]                     if (exists("sendData", mode = "function", 
  [14:21:06.690]                       envir = ns)) {
  [14:21:06.690]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.690]                         envir = ns)
  [14:21:06.690]                       envir <- sys.frame(frame)
  [14:21:06.690]                       master <- NULL
  [14:21:06.690]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.690]                         !identical(envir, emptyenv())) {
  [14:21:06.690]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.690]                           inherits = FALSE)) {
  [14:21:06.690]                           master <- get("master", mode = "list", 
  [14:21:06.690]                             envir = envir, inherits = FALSE)
  [14:21:06.690]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.690]                             sendCondition <<- function(cond) {
  [14:21:06.690]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.690]                                 success = TRUE)
  [14:21:06.690]                               parallel_sendData(master, data)
  [14:21:06.690]                             }
  [14:21:06.690]                             return(sendCondition)
  [14:21:06.690]                           }
  [14:21:06.690]                         }
  [14:21:06.690]                         frame <- frame + 1L
  [14:21:06.690]                         envir <- sys.frame(frame)
  [14:21:06.690]                       }
  [14:21:06.690]                     }
  [14:21:06.690]                     sendCondition <<- function(cond) NULL
  [14:21:06.690]                   }
  [14:21:06.690]                 })
  [14:21:06.690]                 withCallingHandlers({
  [14:21:06.690]                   2
  [14:21:06.690]                 }, immediateCondition = function(cond) {
  [14:21:06.690]                   sendCondition <- ...future.sendCondition()
  [14:21:06.690]                   sendCondition(cond)
  [14:21:06.690]                   muffleCondition <- function (cond) 
  [14:21:06.690]                   {
  [14:21:06.690]                     inherits <- base::inherits
  [14:21:06.690]                     invokeRestart <- base::invokeRestart
  [14:21:06.690]                     muffled <- FALSE
  [14:21:06.690]                     if (inherits(cond, "message")) {
  [14:21:06.690]                       invokeRestart("muffleMessage")
  [14:21:06.690]                       muffled <- TRUE
  [14:21:06.690]                     }
  [14:21:06.690]                     else if (inherits(cond, "warning")) {
  [14:21:06.690]                       invokeRestart("muffleWarning")
  [14:21:06.690]                       muffled <- TRUE
  [14:21:06.690]                     }
  [14:21:06.690]                     else if (inherits(cond, "condition")) {
  [14:21:06.690]                       computeRestarts <- base::computeRestarts
  [14:21:06.690]                       grepl <- base::grepl
  [14:21:06.690]                       is.null <- base::is.null
  [14:21:06.690]                       restarts <- computeRestarts(cond)
  [14:21:06.690]                       for (restart in restarts) {
  [14:21:06.690]                         name <- restart$name
  [14:21:06.690]                         if (is.null(name)) 
  [14:21:06.690]                           next
  [14:21:06.690]                         if (!grepl("^muffle", name)) 
  [14:21:06.690]                           next
  [14:21:06.690]                         invokeRestart(restart)
  [14:21:06.690]                         muffled <- TRUE
  [14:21:06.690]                         break
  [14:21:06.690]                       }
  [14:21:06.690]                     }
  [14:21:06.690]                     invisible(muffled)
  [14:21:06.690]                   }
  [14:21:06.690]                   muffleCondition(cond)
  [14:21:06.690]                 })
  [14:21:06.690]             }))
  [14:21:06.690]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.690]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.690]                 version = "1.8")
  [14:21:06.690]         }, condition = base::local({
  [14:21:06.690]             c <- base::c
  [14:21:06.690]             inherits <- base::inherits
  [14:21:06.690]             invokeRestart <- base::invokeRestart
  [14:21:06.690]             length <- base::length
  [14:21:06.690]             list <- base::list
  [14:21:06.690]             seq.int <- base::seq.int
  [14:21:06.690]             signalCondition <- base::signalCondition
  [14:21:06.690]             sys.calls <- base::sys.calls
  [14:21:06.690]             Sys.time <- base::Sys.time
  [14:21:06.690]             `[[` <- base::`[[`
  [14:21:06.690]             `+` <- base::`+`
  [14:21:06.690]             `<<-` <- base::`<<-`
  [14:21:06.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.690]                   3L)]
  [14:21:06.690]             }
  [14:21:06.690]             function(cond) {
  [14:21:06.690]                 if (inherits(cond, "error")) {
  [14:21:06.690]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.690]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.690]                   signalCondition(cond)
  [14:21:06.690]                 }
  [14:21:06.690]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.690]                 ))) {
  [14:21:06.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.690]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.690]                   if (!signal) {
  [14:21:06.690]                     muffleCondition <- function (cond) 
  [14:21:06.690]                     {
  [14:21:06.690]                       inherits <- base::inherits
  [14:21:06.690]                       invokeRestart <- base::invokeRestart
  [14:21:06.690]                       muffled <- FALSE
  [14:21:06.690]                       if (inherits(cond, "message")) {
  [14:21:06.690]                         invokeRestart("muffleMessage")
  [14:21:06.690]                         muffled <- TRUE
  [14:21:06.690]                       }
  [14:21:06.690]                       else if (inherits(cond, "warning")) {
  [14:21:06.690]                         invokeRestart("muffleWarning")
  [14:21:06.690]                         muffled <- TRUE
  [14:21:06.690]                       }
  [14:21:06.690]                       else if (inherits(cond, "condition")) {
  [14:21:06.690]                         computeRestarts <- base::computeRestarts
  [14:21:06.690]                         grepl <- base::grepl
  [14:21:06.690]                         is.null <- base::is.null
  [14:21:06.690]                         restarts <- computeRestarts(cond)
  [14:21:06.690]                         for (restart in restarts) {
  [14:21:06.690]                           name <- restart$name
  [14:21:06.690]                           if (is.null(name)) 
  [14:21:06.690]                             next
  [14:21:06.690]                           if (!grepl("^muffle", name)) 
  [14:21:06.690]                             next
  [14:21:06.690]                           invokeRestart(restart)
  [14:21:06.690]                           muffled <- TRUE
  [14:21:06.690]                           break
  [14:21:06.690]                         }
  [14:21:06.690]                       }
  [14:21:06.690]                       invisible(muffled)
  [14:21:06.690]                     }
  [14:21:06.690]                     muffleCondition(cond)
  [14:21:06.690]                   }
  [14:21:06.690]                 }
  [14:21:06.690]             }
  [14:21:06.690]         }))
  [14:21:06.690]     }, error = function(ex) {
  [14:21:06.690]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.690]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.690]     }, finally = {
  [14:21:06.690]         {
  [14:21:06.690]             NULL
  [14:21:06.690]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.690]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.690]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.690]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.690]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.690]                 ...) 
  [14:21:06.690]             {
  [14:21:06.690]                 if (substitute) 
  [14:21:06.690]                   expr <- substitute(expr)
  [14:21:06.690]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.690]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.690]                   globals = globals, persistent = persistent, 
  [14:21:06.690]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.690]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.690]                   label = label, ...)
  [14:21:06.690]                 if (!future$lazy) 
  [14:21:06.690]                   future <- run(future)
  [14:21:06.690]                 invisible(future)
  [14:21:06.690]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.690]         }
  [14:21:06.690]         base::options(...future.oldOptions)
  [14:21:06.690]     })
  [14:21:06.690]     Sys.time
  [14:21:06.690]     if (base::is.na(TRUE)) {
  [14:21:06.690]     }
  [14:21:06.690]     else {
  [14:21:06.690]         base::sink(type = "output", split = FALSE)
  [14:21:06.690]         if (TRUE) {
  [14:21:06.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.690]         }
  [14:21:06.690]         else {
  [14:21:06.690]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.690]         }
  [14:21:06.690]         base::close(...future.stdout)
  [14:21:06.690]         ...future.stdout <- NULL
  [14:21:06.690]     }
  [14:21:06.690]     ...future.result$conditions <- ...future.conditions
  [14:21:06.690]     ...future.result
  [14:21:06.690] }
  [14:21:06.699] ClusterFuture started
  [14:21:06.704] getGlobalsAndPackages() ...
  [14:21:06.704] Searching for globals...
  [14:21:06.705] 
  [14:21:06.706] Searching for globals ... DONE
  [14:21:06.706] - globals: [0] <none>
  [14:21:06.706] getGlobalsAndPackages() ... DONE
  [14:21:06.710] Packages needed by the future expression (n = 0): <none>
  [14:21:06.711] Packages needed by future strategies (n = 0): <none>
  [14:21:06.718] {
  [14:21:06.718]     {
  [14:21:06.718]         ...future.startTime <- base::Sys.time()
  [14:21:06.718]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.718]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.718]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.718]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.718]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.718]         {
  [14:21:06.718]             {
  [14:21:06.718]                 has_future <- base::requireNamespace("future", 
  [14:21:06.718]                   quietly = TRUE)
  [14:21:06.718]                 version <- if (has_future) 
  [14:21:06.718]                   utils::packageVersion("future")
  [14:21:06.718]                 else NULL
  [14:21:06.718]                 if (!has_future || version < "1.8.0") {
  [14:21:06.718]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.718]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.718]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.718]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.718]                       "release", "version")], collapse = " "), 
  [14:21:06.718]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.718]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.718]                     info)
  [14:21:06.718]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.718]                   if (!has_future) {
  [14:21:06.718]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.718]                       info)
  [14:21:06.718]                   }
  [14:21:06.718]                   else {
  [14:21:06.718]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.718]                       info, version)
  [14:21:06.718]                   }
  [14:21:06.718]                   base::stop(msg)
  [14:21:06.718]                 }
  [14:21:06.718]             }
  [14:21:06.718]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.718]         }
  [14:21:06.718]     }
  [14:21:06.718]     if (base::is.na(TRUE)) {
  [14:21:06.718]     }
  [14:21:06.718]     else {
  [14:21:06.718]         if (TRUE) {
  [14:21:06.718]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.718]                 open = "w")
  [14:21:06.718]         }
  [14:21:06.718]         else {
  [14:21:06.718]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.718]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.718]         }
  [14:21:06.718]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.718]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.718]             base::sink(type = "output", split = FALSE)
  [14:21:06.718]             base::close(...future.stdout)
  [14:21:06.718]         }, add = TRUE)
  [14:21:06.718]     }
  [14:21:06.718]     ...future.frame <- base::sys.nframe()
  [14:21:06.718]     ...future.conditions <- base::list()
  [14:21:06.718]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.718]     ...future.result <- base::tryCatch({
  [14:21:06.718]         base::withCallingHandlers({
  [14:21:06.718]             ...future.value <- base::withVisible(base::local({
  [14:21:06.718]                 ...future.sendCondition <- local({
  [14:21:06.718]                   sendCondition <- NULL
  [14:21:06.718]                   function(frame = 1L) {
  [14:21:06.718]                     if (is.function(sendCondition)) 
  [14:21:06.718]                       return(sendCondition)
  [14:21:06.718]                     ns <- getNamespace("parallel")
  [14:21:06.718]                     if (exists("sendData", mode = "function", 
  [14:21:06.718]                       envir = ns)) {
  [14:21:06.718]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.718]                         envir = ns)
  [14:21:06.718]                       envir <- sys.frame(frame)
  [14:21:06.718]                       master <- NULL
  [14:21:06.718]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.718]                         !identical(envir, emptyenv())) {
  [14:21:06.718]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.718]                           inherits = FALSE)) {
  [14:21:06.718]                           master <- get("master", mode = "list", 
  [14:21:06.718]                             envir = envir, inherits = FALSE)
  [14:21:06.718]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.718]                             sendCondition <<- function(cond) {
  [14:21:06.718]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.718]                                 success = TRUE)
  [14:21:06.718]                               parallel_sendData(master, data)
  [14:21:06.718]                             }
  [14:21:06.718]                             return(sendCondition)
  [14:21:06.718]                           }
  [14:21:06.718]                         }
  [14:21:06.718]                         frame <- frame + 1L
  [14:21:06.718]                         envir <- sys.frame(frame)
  [14:21:06.718]                       }
  [14:21:06.718]                     }
  [14:21:06.718]                     sendCondition <<- function(cond) NULL
  [14:21:06.718]                   }
  [14:21:06.718]                 })
  [14:21:06.718]                 withCallingHandlers({
  [14:21:06.718]                   NULL
  [14:21:06.718]                 }, immediateCondition = function(cond) {
  [14:21:06.718]                   sendCondition <- ...future.sendCondition()
  [14:21:06.718]                   sendCondition(cond)
  [14:21:06.718]                   muffleCondition <- function (cond) 
  [14:21:06.718]                   {
  [14:21:06.718]                     inherits <- base::inherits
  [14:21:06.718]                     invokeRestart <- base::invokeRestart
  [14:21:06.718]                     muffled <- FALSE
  [14:21:06.718]                     if (inherits(cond, "message")) {
  [14:21:06.718]                       invokeRestart("muffleMessage")
  [14:21:06.718]                       muffled <- TRUE
  [14:21:06.718]                     }
  [14:21:06.718]                     else if (inherits(cond, "warning")) {
  [14:21:06.718]                       invokeRestart("muffleWarning")
  [14:21:06.718]                       muffled <- TRUE
  [14:21:06.718]                     }
  [14:21:06.718]                     else if (inherits(cond, "condition")) {
  [14:21:06.718]                       computeRestarts <- base::computeRestarts
  [14:21:06.718]                       grepl <- base::grepl
  [14:21:06.718]                       is.null <- base::is.null
  [14:21:06.718]                       restarts <- computeRestarts(cond)
  [14:21:06.718]                       for (restart in restarts) {
  [14:21:06.718]                         name <- restart$name
  [14:21:06.718]                         if (is.null(name)) 
  [14:21:06.718]                           next
  [14:21:06.718]                         if (!grepl("^muffle", name)) 
  [14:21:06.718]                           next
  [14:21:06.718]                         invokeRestart(restart)
  [14:21:06.718]                         muffled <- TRUE
  [14:21:06.718]                         break
  [14:21:06.718]                       }
  [14:21:06.718]                     }
  [14:21:06.718]                     invisible(muffled)
  [14:21:06.718]                   }
  [14:21:06.718]                   muffleCondition(cond)
  [14:21:06.718]                 })
  [14:21:06.718]             }))
  [14:21:06.718]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.718]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.718]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.718]                 version = "1.8")
  [14:21:06.718]         }, condition = base::local({
  [14:21:06.718]             c <- base::c
  [14:21:06.718]             inherits <- base::inherits
  [14:21:06.718]             invokeRestart <- base::invokeRestart
  [14:21:06.718]             length <- base::length
  [14:21:06.718]             list <- base::list
  [14:21:06.718]             seq.int <- base::seq.int
  [14:21:06.718]             signalCondition <- base::signalCondition
  [14:21:06.718]             sys.calls <- base::sys.calls
  [14:21:06.718]             Sys.time <- base::Sys.time
  [14:21:06.718]             `[[` <- base::`[[`
  [14:21:06.718]             `+` <- base::`+`
  [14:21:06.718]             `<<-` <- base::`<<-`
  [14:21:06.718]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.718]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.718]                   3L)]
  [14:21:06.718]             }
  [14:21:06.718]             function(cond) {
  [14:21:06.718]                 if (inherits(cond, "error")) {
  [14:21:06.718]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.718]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.718]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.718]                   signalCondition(cond)
  [14:21:06.718]                 }
  [14:21:06.718]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.718]                 ))) {
  [14:21:06.718]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.718]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.718]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.718]                   if (!signal) {
  [14:21:06.718]                     muffleCondition <- function (cond) 
  [14:21:06.718]                     {
  [14:21:06.718]                       inherits <- base::inherits
  [14:21:06.718]                       invokeRestart <- base::invokeRestart
  [14:21:06.718]                       muffled <- FALSE
  [14:21:06.718]                       if (inherits(cond, "message")) {
  [14:21:06.718]                         invokeRestart("muffleMessage")
  [14:21:06.718]                         muffled <- TRUE
  [14:21:06.718]                       }
  [14:21:06.718]                       else if (inherits(cond, "warning")) {
  [14:21:06.718]                         invokeRestart("muffleWarning")
  [14:21:06.718]                         muffled <- TRUE
  [14:21:06.718]                       }
  [14:21:06.718]                       else if (inherits(cond, "condition")) {
  [14:21:06.718]                         computeRestarts <- base::computeRestarts
  [14:21:06.718]                         grepl <- base::grepl
  [14:21:06.718]                         is.null <- base::is.null
  [14:21:06.718]                         restarts <- computeRestarts(cond)
  [14:21:06.718]                         for (restart in restarts) {
  [14:21:06.718]                           name <- restart$name
  [14:21:06.718]                           if (is.null(name)) 
  [14:21:06.718]                             next
  [14:21:06.718]                           if (!grepl("^muffle", name)) 
  [14:21:06.718]                             next
  [14:21:06.718]                           invokeRestart(restart)
  [14:21:06.718]                           muffled <- TRUE
  [14:21:06.718]                           break
  [14:21:06.718]                         }
  [14:21:06.718]                       }
  [14:21:06.718]                       invisible(muffled)
  [14:21:06.718]                     }
  [14:21:06.718]                     muffleCondition(cond)
  [14:21:06.718]                   }
  [14:21:06.718]                 }
  [14:21:06.718]             }
  [14:21:06.718]         }))
  [14:21:06.718]     }, error = function(ex) {
  [14:21:06.718]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.718]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.718]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.718]     }, finally = {
  [14:21:06.718]         {
  [14:21:06.718]             NULL
  [14:21:06.718]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.718]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.718]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.718]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.718]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.718]                 ...) 
  [14:21:06.718]             {
  [14:21:06.718]                 if (substitute) 
  [14:21:06.718]                   expr <- substitute(expr)
  [14:21:06.718]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.718]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.718]                   globals = globals, persistent = persistent, 
  [14:21:06.718]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.718]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.718]                   label = label, ...)
  [14:21:06.718]                 if (!future$lazy) 
  [14:21:06.718]                   future <- run(future)
  [14:21:06.718]                 invisible(future)
  [14:21:06.718]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.718]         }
  [14:21:06.718]         base::options(...future.oldOptions)
  [14:21:06.718]     })
  [14:21:06.718]     Sys.time
  [14:21:06.718]     if (base::is.na(TRUE)) {
  [14:21:06.718]     }
  [14:21:06.718]     else {
  [14:21:06.718]         base::sink(type = "output", split = FALSE)
  [14:21:06.718]         if (TRUE) {
  [14:21:06.718]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.718]         }
  [14:21:06.718]         else {
  [14:21:06.718]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.718]         }
  [14:21:06.718]         base::close(...future.stdout)
  [14:21:06.718]         ...future.stdout <- NULL
  [14:21:06.718]     }
  [14:21:06.718]     ...future.result$conditions <- ...future.conditions
  [14:21:06.718]     ...future.result
  [14:21:06.718] }
  [14:21:06.724] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:06.744] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.744] - Validating connection of ClusterFuture
  [14:21:06.745] - received message: FutureResult
  [14:21:06.745] - Received FutureResult
  [14:21:06.746] - Erased future from FutureRegistry
  [14:21:06.746] result() for ClusterFuture ...
  [14:21:06.746] - result already collected: FutureResult
  [14:21:06.747] result() for ClusterFuture ... done
  [14:21:06.747] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:06.748] result() for ClusterFuture ...
  [14:21:06.748] - result already collected: FutureResult
  [14:21:06.748] result() for ClusterFuture ... done
  [14:21:06.748] result() for ClusterFuture ...
  [14:21:06.749] - result already collected: FutureResult
  [14:21:06.749] result() for ClusterFuture ... done
  [14:21:06.751] ClusterFuture started
  [14:21:06.757] getGlobalsAndPackages() ...
  [14:21:06.758] Searching for globals...
  [14:21:06.779] - globals found: [1] '{'
  [14:21:06.780] Searching for globals ... DONE
  [14:21:06.780] Resolving globals: FALSE
  [14:21:06.781] 
  [14:21:06.781] 
  [14:21:06.782] getGlobalsAndPackages() ... DONE
  [14:21:06.786] Packages needed by the future expression (n = 0): <none>
  [14:21:06.786] Packages needed by future strategies (n = 0): <none>
  [14:21:06.792] {
  [14:21:06.792]     {
  [14:21:06.792]         ...future.startTime <- base::Sys.time()
  [14:21:06.792]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:06.792]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:06.792]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:06.792]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:06.792]             future.resolve.recursive = NULL, width = 80L)
  [14:21:06.792]         {
  [14:21:06.792]             {
  [14:21:06.792]                 has_future <- base::requireNamespace("future", 
  [14:21:06.792]                   quietly = TRUE)
  [14:21:06.792]                 version <- if (has_future) 
  [14:21:06.792]                   utils::packageVersion("future")
  [14:21:06.792]                 else NULL
  [14:21:06.792]                 if (!has_future || version < "1.8.0") {
  [14:21:06.792]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:06.792]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:06.792]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:06.792]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:06.792]                       "release", "version")], collapse = " "), 
  [14:21:06.792]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:06.792]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:06.792]                     info)
  [14:21:06.792]                   info <- base::paste(info, collapse = "; ")
  [14:21:06.792]                   if (!has_future) {
  [14:21:06.792]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:06.792]                       info)
  [14:21:06.792]                   }
  [14:21:06.792]                   else {
  [14:21:06.792]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:06.792]                       info, version)
  [14:21:06.792]                   }
  [14:21:06.792]                   base::stop(msg)
  [14:21:06.792]                 }
  [14:21:06.792]             }
  [14:21:06.792]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:06.792]         }
  [14:21:06.792]     }
  [14:21:06.792]     if (base::is.na(TRUE)) {
  [14:21:06.792]     }
  [14:21:06.792]     else {
  [14:21:06.792]         if (TRUE) {
  [14:21:06.792]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:06.792]                 open = "w")
  [14:21:06.792]         }
  [14:21:06.792]         else {
  [14:21:06.792]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:06.792]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:06.792]         }
  [14:21:06.792]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:06.792]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:06.792]             base::sink(type = "output", split = FALSE)
  [14:21:06.792]             base::close(...future.stdout)
  [14:21:06.792]         }, add = TRUE)
  [14:21:06.792]     }
  [14:21:06.792]     ...future.frame <- base::sys.nframe()
  [14:21:06.792]     ...future.conditions <- base::list()
  [14:21:06.792]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:06.792]     ...future.result <- base::tryCatch({
  [14:21:06.792]         base::withCallingHandlers({
  [14:21:06.792]             ...future.value <- base::withVisible(base::local({
  [14:21:06.792]                 ...future.sendCondition <- local({
  [14:21:06.792]                   sendCondition <- NULL
  [14:21:06.792]                   function(frame = 1L) {
  [14:21:06.792]                     if (is.function(sendCondition)) 
  [14:21:06.792]                       return(sendCondition)
  [14:21:06.792]                     ns <- getNamespace("parallel")
  [14:21:06.792]                     if (exists("sendData", mode = "function", 
  [14:21:06.792]                       envir = ns)) {
  [14:21:06.792]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:06.792]                         envir = ns)
  [14:21:06.792]                       envir <- sys.frame(frame)
  [14:21:06.792]                       master <- NULL
  [14:21:06.792]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:06.792]                         !identical(envir, emptyenv())) {
  [14:21:06.792]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:06.792]                           inherits = FALSE)) {
  [14:21:06.792]                           master <- get("master", mode = "list", 
  [14:21:06.792]                             envir = envir, inherits = FALSE)
  [14:21:06.792]                           if (inherits(master, "SOCKnode")) {
  [14:21:06.792]                             sendCondition <<- function(cond) {
  [14:21:06.792]                               data <- list(type = "VALUE", value = cond, 
  [14:21:06.792]                                 success = TRUE)
  [14:21:06.792]                               parallel_sendData(master, data)
  [14:21:06.792]                             }
  [14:21:06.792]                             return(sendCondition)
  [14:21:06.792]                           }
  [14:21:06.792]                         }
  [14:21:06.792]                         frame <- frame + 1L
  [14:21:06.792]                         envir <- sys.frame(frame)
  [14:21:06.792]                       }
  [14:21:06.792]                     }
  [14:21:06.792]                     sendCondition <<- function(cond) NULL
  [14:21:06.792]                   }
  [14:21:06.792]                 })
  [14:21:06.792]                 withCallingHandlers({
  [14:21:06.792]                   {
  [14:21:06.792]                     4
  [14:21:06.792]                   }
  [14:21:06.792]                 }, immediateCondition = function(cond) {
  [14:21:06.792]                   sendCondition <- ...future.sendCondition()
  [14:21:06.792]                   sendCondition(cond)
  [14:21:06.792]                   muffleCondition <- function (cond) 
  [14:21:06.792]                   {
  [14:21:06.792]                     inherits <- base::inherits
  [14:21:06.792]                     invokeRestart <- base::invokeRestart
  [14:21:06.792]                     muffled <- FALSE
  [14:21:06.792]                     if (inherits(cond, "message")) {
  [14:21:06.792]                       invokeRestart("muffleMessage")
  [14:21:06.792]                       muffled <- TRUE
  [14:21:06.792]                     }
  [14:21:06.792]                     else if (inherits(cond, "warning")) {
  [14:21:06.792]                       invokeRestart("muffleWarning")
  [14:21:06.792]                       muffled <- TRUE
  [14:21:06.792]                     }
  [14:21:06.792]                     else if (inherits(cond, "condition")) {
  [14:21:06.792]                       computeRestarts <- base::computeRestarts
  [14:21:06.792]                       grepl <- base::grepl
  [14:21:06.792]                       is.null <- base::is.null
  [14:21:06.792]                       restarts <- computeRestarts(cond)
  [14:21:06.792]                       for (restart in restarts) {
  [14:21:06.792]                         name <- restart$name
  [14:21:06.792]                         if (is.null(name)) 
  [14:21:06.792]                           next
  [14:21:06.792]                         if (!grepl("^muffle", name)) 
  [14:21:06.792]                           next
  [14:21:06.792]                         invokeRestart(restart)
  [14:21:06.792]                         muffled <- TRUE
  [14:21:06.792]                         break
  [14:21:06.792]                       }
  [14:21:06.792]                     }
  [14:21:06.792]                     invisible(muffled)
  [14:21:06.792]                   }
  [14:21:06.792]                   muffleCondition(cond)
  [14:21:06.792]                 })
  [14:21:06.792]             }))
  [14:21:06.792]             future::FutureResult(value = ...future.value$value, 
  [14:21:06.792]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.792]                   ...future.rng), started = ...future.startTime, 
  [14:21:06.792]                 version = "1.8")
  [14:21:06.792]         }, condition = base::local({
  [14:21:06.792]             c <- base::c
  [14:21:06.792]             inherits <- base::inherits
  [14:21:06.792]             invokeRestart <- base::invokeRestart
  [14:21:06.792]             length <- base::length
  [14:21:06.792]             list <- base::list
  [14:21:06.792]             seq.int <- base::seq.int
  [14:21:06.792]             signalCondition <- base::signalCondition
  [14:21:06.792]             sys.calls <- base::sys.calls
  [14:21:06.792]             Sys.time <- base::Sys.time
  [14:21:06.792]             `[[` <- base::`[[`
  [14:21:06.792]             `+` <- base::`+`
  [14:21:06.792]             `<<-` <- base::`<<-`
  [14:21:06.792]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:06.792]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:06.792]                   3L)]
  [14:21:06.792]             }
  [14:21:06.792]             function(cond) {
  [14:21:06.792]                 if (inherits(cond, "error")) {
  [14:21:06.792]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.792]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:06.792]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:06.792]                   signalCondition(cond)
  [14:21:06.792]                 }
  [14:21:06.792]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:06.792]                 ))) {
  [14:21:06.792]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:06.792]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:06.792]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:06.792]                   if (!signal) {
  [14:21:06.792]                     muffleCondition <- function (cond) 
  [14:21:06.792]                     {
  [14:21:06.792]                       inherits <- base::inherits
  [14:21:06.792]                       invokeRestart <- base::invokeRestart
  [14:21:06.792]                       muffled <- FALSE
  [14:21:06.792]                       if (inherits(cond, "message")) {
  [14:21:06.792]                         invokeRestart("muffleMessage")
  [14:21:06.792]                         muffled <- TRUE
  [14:21:06.792]                       }
  [14:21:06.792]                       else if (inherits(cond, "warning")) {
  [14:21:06.792]                         invokeRestart("muffleWarning")
  [14:21:06.792]                         muffled <- TRUE
  [14:21:06.792]                       }
  [14:21:06.792]                       else if (inherits(cond, "condition")) {
  [14:21:06.792]                         computeRestarts <- base::computeRestarts
  [14:21:06.792]                         grepl <- base::grepl
  [14:21:06.792]                         is.null <- base::is.null
  [14:21:06.792]                         restarts <- computeRestarts(cond)
  [14:21:06.792]                         for (restart in restarts) {
  [14:21:06.792]                           name <- restart$name
  [14:21:06.792]                           if (is.null(name)) 
  [14:21:06.792]                             next
  [14:21:06.792]                           if (!grepl("^muffle", name)) 
  [14:21:06.792]                             next
  [14:21:06.792]                           invokeRestart(restart)
  [14:21:06.792]                           muffled <- TRUE
  [14:21:06.792]                           break
  [14:21:06.792]                         }
  [14:21:06.792]                       }
  [14:21:06.792]                       invisible(muffled)
  [14:21:06.792]                     }
  [14:21:06.792]                     muffleCondition(cond)
  [14:21:06.792]                   }
  [14:21:06.792]                 }
  [14:21:06.792]             }
  [14:21:06.792]         }))
  [14:21:06.792]     }, error = function(ex) {
  [14:21:06.792]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:06.792]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:06.792]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:06.792]     }, finally = {
  [14:21:06.792]         {
  [14:21:06.792]             NULL
  [14:21:06.792]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:06.792]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:06.792]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:06.792]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:06.792]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:06.792]                 ...) 
  [14:21:06.792]             {
  [14:21:06.792]                 if (substitute) 
  [14:21:06.792]                   expr <- substitute(expr)
  [14:21:06.792]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:06.792]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:06.792]                   globals = globals, persistent = persistent, 
  [14:21:06.792]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:06.792]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:06.792]                   label = label, ...)
  [14:21:06.792]                 if (!future$lazy) 
  [14:21:06.792]                   future <- run(future)
  [14:21:06.792]                 invisible(future)
  [14:21:06.792]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:06.792]         }
  [14:21:06.792]         base::options(...future.oldOptions)
  [14:21:06.792]     })
  [14:21:06.792]     Sys.time
  [14:21:06.792]     if (base::is.na(TRUE)) {
  [14:21:06.792]     }
  [14:21:06.792]     else {
  [14:21:06.792]         base::sink(type = "output", split = FALSE)
  [14:21:06.792]         if (TRUE) {
  [14:21:06.792]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:06.792]         }
  [14:21:06.792]         else {
  [14:21:06.792]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:06.792]         }
  [14:21:06.792]         base::close(...future.stdout)
  [14:21:06.792]         ...future.stdout <- NULL
  [14:21:06.792]     }
  [14:21:06.792]     ...future.result$conditions <- ...future.conditions
  [14:21:06.792]     ...future.result
  [14:21:06.792] }
  [14:21:06.814] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:06.831] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.831] - Validating connection of ClusterFuture
  [14:21:06.832] - received message: FutureResult
  [14:21:06.832] - Received FutureResult
  [14:21:06.833] - Erased future from FutureRegistry
  [14:21:06.833] result() for ClusterFuture ...
  [14:21:06.834] - result already collected: FutureResult
  [14:21:06.834] result() for ClusterFuture ... done
  [14:21:06.835] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:06.835] result() for ClusterFuture ...
  [14:21:06.836] - result already collected: FutureResult
  [14:21:06.836] result() for ClusterFuture ... done
  [14:21:06.836] result() for ClusterFuture ...
  [14:21:06.837] - result already collected: FutureResult
  [14:21:06.837] result() for ClusterFuture ... done
  [14:21:06.848] ClusterFuture started
  <environment: 0x5574fa64c1d0> 
  <environment: 0x5574f8f6c358> 
  [14:21:06.892] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:06.892] - Validating connection of ClusterFuture
  [14:21:06.893] - received message: FutureResult
  [14:21:06.893] - Received FutureResult
  [14:21:06.893] - Erased future from FutureRegistry
  [14:21:06.894] result() for ClusterFuture ...
  [14:21:06.894] - result already collected: FutureResult
  [14:21:06.894] result() for ClusterFuture ... done
  [14:21:06.895] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:21:06.898] resolve() on environment ...
  [14:21:06.898]  recursive: 0
  [14:21:06.900]  elements: [4] 'a', 'b', 'c', 'd'
  [14:21:06.900] signalConditionsASAP(numeric, pos=1) ...
  [14:21:06.900] - nx: 4
  [14:21:06.901] - relay: TRUE
  [14:21:06.901] - stdout: TRUE
  [14:21:06.901] - signal: TRUE
  [14:21:06.902] - resignal: FALSE
  [14:21:06.902] - force: TRUE
  [14:21:06.902] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.913] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.914]  - until=2
  [14:21:06.914]  - relaying element #2
  [14:21:06.914] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:06.915] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.915] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:06.916]  length: 3 (resolved future 1)
  [14:21:06.916] Future #2
  [14:21:06.916] result() for ClusterFuture ...
  [14:21:06.917] - result already collected: FutureResult
  [14:21:06.917] result() for ClusterFuture ... done
  [14:21:06.917] result() for ClusterFuture ...
  [14:21:06.918] - result already collected: FutureResult
  [14:21:06.918] result() for ClusterFuture ... done
  [14:21:06.918] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:21:06.919] - nx: 4
  [14:21:06.919] - relay: TRUE
  [14:21:06.919] - stdout: TRUE
  [14:21:06.920] - signal: TRUE
  [14:21:06.920] - resignal: FALSE
  [14:21:06.920] - force: TRUE
  [14:21:06.920] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:06.921] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:06.921]  - until=2
  [14:21:06.921]  - relaying element #2
  [14:21:06.922] result() for ClusterFuture ...
  [14:21:06.922] - result already collected: FutureResult
  [14:21:06.922] result() for ClusterFuture ... done
  [14:21:06.923] result() for ClusterFuture ...
  [14:21:06.923] - result already collected: FutureResult
  [14:21:06.924] result() for ClusterFuture ... done
  [14:21:06.924] result() for ClusterFuture ...
  [14:21:06.924] - result already collected: FutureResult
  [14:21:06.925] result() for ClusterFuture ... done
  [14:21:06.925] result() for ClusterFuture ...
  [14:21:06.925] - result already collected: FutureResult
  [14:21:06.926] result() for ClusterFuture ... done
  [14:21:06.926] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:06.930] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:06.930] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:21:06.930]  length: 2 (resolved future 2)
  [14:21:06.931] Future #3
  [14:21:06.931] result() for ClusterFuture ...
  [14:21:06.931] - result already collected: FutureResult
  [14:21:06.932] result() for ClusterFuture ... done
  [14:21:06.932] result() for ClusterFuture ...
  [14:21:06.932] - result already collected: FutureResult
  [14:21:06.933] result() for ClusterFuture ... done
  [14:21:06.933] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:21:06.933] - nx: 4
  [14:21:06.934] - relay: TRUE
  [14:21:06.934] - stdout: TRUE
  [14:21:06.934] - signal: TRUE
  [14:21:06.934] - resignal: FALSE
  [14:21:06.935] - force: TRUE
  [14:21:06.935] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:06.935] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:06.936]  - until=3
  [14:21:06.936]  - relaying element #3
  [14:21:06.936] result() for ClusterFuture ...
  [14:21:06.937] - result already collected: FutureResult
  [14:21:06.937] result() for ClusterFuture ... done
  [14:21:06.937] result() for ClusterFuture ...
  [14:21:06.938] - result already collected: FutureResult
  [14:21:06.938] result() for ClusterFuture ... done
  [14:21:06.938] result() for ClusterFuture ...
  [14:21:06.955] - result already collected: FutureResult
  [14:21:06.955] result() for ClusterFuture ... done
  [14:21:06.955] result() for ClusterFuture ...
  [14:21:06.956] - result already collected: FutureResult
  [14:21:06.956] result() for ClusterFuture ... done
  [14:21:06.956] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:06.957] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:06.957] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:21:06.957]  length: 1 (resolved future 3)
  [14:21:06.958] Future #4
  [14:21:06.958] result() for ClusterFuture ...
  [14:21:06.958] - result already collected: FutureResult
  [14:21:06.965] result() for ClusterFuture ... done
  [14:21:06.966] result() for ClusterFuture ...
  [14:21:06.966] - result already collected: FutureResult
  [14:21:06.966] result() for ClusterFuture ... done
  [14:21:06.967] signalConditionsASAP(ClusterFuture, pos=4) ...
  [14:21:06.967] - nx: 4
  [14:21:06.967] - relay: TRUE
  [14:21:06.968] - stdout: TRUE
  [14:21:06.968] - signal: TRUE
  [14:21:06.968] - resignal: FALSE
  [14:21:06.969] - force: TRUE
  [14:21:06.969] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:06.969] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:06.969]  - until=4
  [14:21:06.970]  - relaying element #4
  [14:21:06.970] result() for ClusterFuture ...
  [14:21:06.970] - result already collected: FutureResult
  [14:21:06.971] result() for ClusterFuture ... done
  [14:21:06.971] result() for ClusterFuture ...
  [14:21:06.971] - result already collected: FutureResult
  [14:21:06.972] result() for ClusterFuture ... done
  [14:21:06.972] result() for ClusterFuture ...
  [14:21:06.973] - result already collected: FutureResult
  [14:21:06.973] result() for ClusterFuture ... done
  [14:21:06.973] result() for ClusterFuture ...
  [14:21:06.973] - result already collected: FutureResult
  [14:21:06.974] result() for ClusterFuture ... done
  [14:21:06.974] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.974] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:06.975] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [14:21:06.975]  length: 0 (resolved future 4)
  [14:21:06.975] Relaying remaining futures
  [14:21:06.976] signalConditionsASAP(NULL, pos=0) ...
  [14:21:06.976] - nx: 4
  [14:21:06.976] - relay: TRUE
  [14:21:06.976] - stdout: TRUE
  [14:21:06.977] - signal: TRUE
  [14:21:06.977] - resignal: FALSE
  [14:21:06.977] - force: TRUE
  [14:21:06.978] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.978] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:21:06.978] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:06.979] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:06.979] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:06.979] resolve() on environment ... DONE
  [14:21:06.980] result() for ClusterFuture ...
  [14:21:06.980] - result already collected: FutureResult
  [14:21:06.980] result() for ClusterFuture ... done
  [14:21:06.981] result() for ClusterFuture ...
  [14:21:06.988] - result already collected: FutureResult
  [14:21:06.989] result() for ClusterFuture ... done
  [14:21:06.989] result() for ClusterFuture ...
  [14:21:06.989] - result already collected: FutureResult
  [14:21:06.990] result() for ClusterFuture ... done
  [14:21:06.990] result() for ClusterFuture ...
  [14:21:06.991] - result already collected: FutureResult
  [14:21:06.991] result() for ClusterFuture ... done
  [14:21:06.991] result() for ClusterFuture ...
  [14:21:06.992] - result already collected: FutureResult
  [14:21:06.992] result() for ClusterFuture ... done
  [14:21:06.992] result() for ClusterFuture ...
  [14:21:06.993] - result already collected: FutureResult
  [14:21:06.993] result() for ClusterFuture ... done
  <environment: 0x5574f86445d8> 
  Dimensions: c(2, 3)
  [14:21:07.003] getGlobalsAndPackages() ...
  [14:21:07.004] Searching for globals...
  [14:21:07.005] 
  [14:21:07.005] Searching for globals ... DONE
  [14:21:07.005] - globals: [0] <none>
  [14:21:07.006] getGlobalsAndPackages() ... DONE
  [14:21:07.010] Packages needed by the future expression (n = 0): <none>
  [14:21:07.010] Packages needed by future strategies (n = 0): <none>
  [14:21:07.016] {
  [14:21:07.016]     {
  [14:21:07.016]         ...future.startTime <- base::Sys.time()
  [14:21:07.016]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.016]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.016]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.016]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.016]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.016]         {
  [14:21:07.016]             {
  [14:21:07.016]                 has_future <- base::requireNamespace("future", 
  [14:21:07.016]                   quietly = TRUE)
  [14:21:07.016]                 version <- if (has_future) 
  [14:21:07.016]                   utils::packageVersion("future")
  [14:21:07.016]                 else NULL
  [14:21:07.016]                 if (!has_future || version < "1.8.0") {
  [14:21:07.016]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.016]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.016]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.016]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.016]                       "release", "version")], collapse = " "), 
  [14:21:07.016]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.016]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.016]                     info)
  [14:21:07.016]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.016]                   if (!has_future) {
  [14:21:07.016]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.016]                       info)
  [14:21:07.016]                   }
  [14:21:07.016]                   else {
  [14:21:07.016]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.016]                       info, version)
  [14:21:07.016]                   }
  [14:21:07.016]                   base::stop(msg)
  [14:21:07.016]                 }
  [14:21:07.016]             }
  [14:21:07.016]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.016]         }
  [14:21:07.016]     }
  [14:21:07.016]     if (base::is.na(TRUE)) {
  [14:21:07.016]     }
  [14:21:07.016]     else {
  [14:21:07.016]         if (TRUE) {
  [14:21:07.016]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.016]                 open = "w")
  [14:21:07.016]         }
  [14:21:07.016]         else {
  [14:21:07.016]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.016]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.016]         }
  [14:21:07.016]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.016]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.016]             base::sink(type = "output", split = FALSE)
  [14:21:07.016]             base::close(...future.stdout)
  [14:21:07.016]         }, add = TRUE)
  [14:21:07.016]     }
  [14:21:07.016]     ...future.frame <- base::sys.nframe()
  [14:21:07.016]     ...future.conditions <- base::list()
  [14:21:07.016]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.016]     ...future.result <- base::tryCatch({
  [14:21:07.016]         base::withCallingHandlers({
  [14:21:07.016]             ...future.value <- base::withVisible(base::local({
  [14:21:07.016]                 ...future.sendCondition <- local({
  [14:21:07.016]                   sendCondition <- NULL
  [14:21:07.016]                   function(frame = 1L) {
  [14:21:07.016]                     if (is.function(sendCondition)) 
  [14:21:07.016]                       return(sendCondition)
  [14:21:07.016]                     ns <- getNamespace("parallel")
  [14:21:07.016]                     if (exists("sendData", mode = "function", 
  [14:21:07.016]                       envir = ns)) {
  [14:21:07.016]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.016]                         envir = ns)
  [14:21:07.016]                       envir <- sys.frame(frame)
  [14:21:07.016]                       master <- NULL
  [14:21:07.016]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.016]                         !identical(envir, emptyenv())) {
  [14:21:07.016]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.016]                           inherits = FALSE)) {
  [14:21:07.016]                           master <- get("master", mode = "list", 
  [14:21:07.016]                             envir = envir, inherits = FALSE)
  [14:21:07.016]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.016]                             sendCondition <<- function(cond) {
  [14:21:07.016]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.016]                                 success = TRUE)
  [14:21:07.016]                               parallel_sendData(master, data)
  [14:21:07.016]                             }
  [14:21:07.016]                             return(sendCondition)
  [14:21:07.016]                           }
  [14:21:07.016]                         }
  [14:21:07.016]                         frame <- frame + 1L
  [14:21:07.016]                         envir <- sys.frame(frame)
  [14:21:07.016]                       }
  [14:21:07.016]                     }
  [14:21:07.016]                     sendCondition <<- function(cond) NULL
  [14:21:07.016]                   }
  [14:21:07.016]                 })
  [14:21:07.016]                 withCallingHandlers({
  [14:21:07.016]                   2
  [14:21:07.016]                 }, immediateCondition = function(cond) {
  [14:21:07.016]                   sendCondition <- ...future.sendCondition()
  [14:21:07.016]                   sendCondition(cond)
  [14:21:07.016]                   muffleCondition <- function (cond) 
  [14:21:07.016]                   {
  [14:21:07.016]                     inherits <- base::inherits
  [14:21:07.016]                     invokeRestart <- base::invokeRestart
  [14:21:07.016]                     muffled <- FALSE
  [14:21:07.016]                     if (inherits(cond, "message")) {
  [14:21:07.016]                       invokeRestart("muffleMessage")
  [14:21:07.016]                       muffled <- TRUE
  [14:21:07.016]                     }
  [14:21:07.016]                     else if (inherits(cond, "warning")) {
  [14:21:07.016]                       invokeRestart("muffleWarning")
  [14:21:07.016]                       muffled <- TRUE
  [14:21:07.016]                     }
  [14:21:07.016]                     else if (inherits(cond, "condition")) {
  [14:21:07.016]                       computeRestarts <- base::computeRestarts
  [14:21:07.016]                       grepl <- base::grepl
  [14:21:07.016]                       is.null <- base::is.null
  [14:21:07.016]                       restarts <- computeRestarts(cond)
  [14:21:07.016]                       for (restart in restarts) {
  [14:21:07.016]                         name <- restart$name
  [14:21:07.016]                         if (is.null(name)) 
  [14:21:07.016]                           next
  [14:21:07.016]                         if (!grepl("^muffle", name)) 
  [14:21:07.016]                           next
  [14:21:07.016]                         invokeRestart(restart)
  [14:21:07.016]                         muffled <- TRUE
  [14:21:07.016]                         break
  [14:21:07.016]                       }
  [14:21:07.016]                     }
  [14:21:07.016]                     invisible(muffled)
  [14:21:07.016]                   }
  [14:21:07.016]                   muffleCondition(cond)
  [14:21:07.016]                 })
  [14:21:07.016]             }))
  [14:21:07.016]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.016]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.016]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.016]                 version = "1.8")
  [14:21:07.016]         }, condition = base::local({
  [14:21:07.016]             c <- base::c
  [14:21:07.016]             inherits <- base::inherits
  [14:21:07.016]             invokeRestart <- base::invokeRestart
  [14:21:07.016]             length <- base::length
  [14:21:07.016]             list <- base::list
  [14:21:07.016]             seq.int <- base::seq.int
  [14:21:07.016]             signalCondition <- base::signalCondition
  [14:21:07.016]             sys.calls <- base::sys.calls
  [14:21:07.016]             Sys.time <- base::Sys.time
  [14:21:07.016]             `[[` <- base::`[[`
  [14:21:07.016]             `+` <- base::`+`
  [14:21:07.016]             `<<-` <- base::`<<-`
  [14:21:07.016]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.016]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.016]                   3L)]
  [14:21:07.016]             }
  [14:21:07.016]             function(cond) {
  [14:21:07.016]                 if (inherits(cond, "error")) {
  [14:21:07.016]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.016]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.016]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.016]                   signalCondition(cond)
  [14:21:07.016]                 }
  [14:21:07.016]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.016]                 ))) {
  [14:21:07.016]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.016]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.016]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.016]                   if (!signal) {
  [14:21:07.016]                     muffleCondition <- function (cond) 
  [14:21:07.016]                     {
  [14:21:07.016]                       inherits <- base::inherits
  [14:21:07.016]                       invokeRestart <- base::invokeRestart
  [14:21:07.016]                       muffled <- FALSE
  [14:21:07.016]                       if (inherits(cond, "message")) {
  [14:21:07.016]                         invokeRestart("muffleMessage")
  [14:21:07.016]                         muffled <- TRUE
  [14:21:07.016]                       }
  [14:21:07.016]                       else if (inherits(cond, "warning")) {
  [14:21:07.016]                         invokeRestart("muffleWarning")
  [14:21:07.016]                         muffled <- TRUE
  [14:21:07.016]                       }
  [14:21:07.016]                       else if (inherits(cond, "condition")) {
  [14:21:07.016]                         computeRestarts <- base::computeRestarts
  [14:21:07.016]                         grepl <- base::grepl
  [14:21:07.016]                         is.null <- base::is.null
  [14:21:07.016]                         restarts <- computeRestarts(cond)
  [14:21:07.016]                         for (restart in restarts) {
  [14:21:07.016]                           name <- restart$name
  [14:21:07.016]                           if (is.null(name)) 
  [14:21:07.016]                             next
  [14:21:07.016]                           if (!grepl("^muffle", name)) 
  [14:21:07.016]                             next
  [14:21:07.016]                           invokeRestart(restart)
  [14:21:07.016]                           muffled <- TRUE
  [14:21:07.016]                           break
  [14:21:07.016]                         }
  [14:21:07.016]                       }
  [14:21:07.016]                       invisible(muffled)
  [14:21:07.016]                     }
  [14:21:07.016]                     muffleCondition(cond)
  [14:21:07.016]                   }
  [14:21:07.016]                 }
  [14:21:07.016]             }
  [14:21:07.016]         }))
  [14:21:07.016]     }, error = function(ex) {
  [14:21:07.016]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.016]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.016]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.016]     }, finally = {
  [14:21:07.016]         {
  [14:21:07.016]             NULL
  [14:21:07.016]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.016]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.016]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.016]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.016]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.016]                 ...) 
  [14:21:07.016]             {
  [14:21:07.016]                 if (substitute) 
  [14:21:07.016]                   expr <- substitute(expr)
  [14:21:07.016]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.016]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.016]                   globals = globals, persistent = persistent, 
  [14:21:07.016]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.016]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.016]                   label = label, ...)
  [14:21:07.016]                 if (!future$lazy) 
  [14:21:07.016]                   future <- run(future)
  [14:21:07.016]                 invisible(future)
  [14:21:07.016]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.016]         }
  [14:21:07.016]         base::options(...future.oldOptions)
  [14:21:07.016]     })
  [14:21:07.016]     Sys.time
  [14:21:07.016]     if (base::is.na(TRUE)) {
  [14:21:07.016]     }
  [14:21:07.016]     else {
  [14:21:07.016]         base::sink(type = "output", split = FALSE)
  [14:21:07.016]         if (TRUE) {
  [14:21:07.016]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.016]         }
  [14:21:07.016]         else {
  [14:21:07.016]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.016]         }
  [14:21:07.016]         base::close(...future.stdout)
  [14:21:07.016]         ...future.stdout <- NULL
  [14:21:07.016]     }
  [14:21:07.016]     ...future.result$conditions <- ...future.conditions
  [14:21:07.016]     ...future.result
  [14:21:07.016] }
  [14:21:07.024] ClusterFuture started
  [14:21:07.029] getGlobalsAndPackages() ...
  [14:21:07.030] Searching for globals...
  [14:21:07.031] 
  [14:21:07.031] Searching for globals ... DONE
  [14:21:07.031] - globals: [0] <none>
  [14:21:07.032] getGlobalsAndPackages() ... DONE
  [14:21:07.035] Packages needed by the future expression (n = 0): <none>
  [14:21:07.036] Packages needed by future strategies (n = 0): <none>
  [14:21:07.041] {
  [14:21:07.041]     {
  [14:21:07.041]         ...future.startTime <- base::Sys.time()
  [14:21:07.041]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.041]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.041]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.041]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.041]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.041]         {
  [14:21:07.041]             {
  [14:21:07.041]                 has_future <- base::requireNamespace("future", 
  [14:21:07.041]                   quietly = TRUE)
  [14:21:07.041]                 version <- if (has_future) 
  [14:21:07.041]                   utils::packageVersion("future")
  [14:21:07.041]                 else NULL
  [14:21:07.041]                 if (!has_future || version < "1.8.0") {
  [14:21:07.041]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.041]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.041]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.041]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.041]                       "release", "version")], collapse = " "), 
  [14:21:07.041]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.041]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.041]                     info)
  [14:21:07.041]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.041]                   if (!has_future) {
  [14:21:07.041]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.041]                       info)
  [14:21:07.041]                   }
  [14:21:07.041]                   else {
  [14:21:07.041]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.041]                       info, version)
  [14:21:07.041]                   }
  [14:21:07.041]                   base::stop(msg)
  [14:21:07.041]                 }
  [14:21:07.041]             }
  [14:21:07.041]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.041]         }
  [14:21:07.041]     }
  [14:21:07.041]     if (base::is.na(TRUE)) {
  [14:21:07.041]     }
  [14:21:07.041]     else {
  [14:21:07.041]         if (TRUE) {
  [14:21:07.041]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.041]                 open = "w")
  [14:21:07.041]         }
  [14:21:07.041]         else {
  [14:21:07.041]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.041]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.041]         }
  [14:21:07.041]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.041]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.041]             base::sink(type = "output", split = FALSE)
  [14:21:07.041]             base::close(...future.stdout)
  [14:21:07.041]         }, add = TRUE)
  [14:21:07.041]     }
  [14:21:07.041]     ...future.frame <- base::sys.nframe()
  [14:21:07.041]     ...future.conditions <- base::list()
  [14:21:07.041]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.041]     ...future.result <- base::tryCatch({
  [14:21:07.041]         base::withCallingHandlers({
  [14:21:07.041]             ...future.value <- base::withVisible(base::local({
  [14:21:07.041]                 ...future.sendCondition <- local({
  [14:21:07.041]                   sendCondition <- NULL
  [14:21:07.041]                   function(frame = 1L) {
  [14:21:07.041]                     if (is.function(sendCondition)) 
  [14:21:07.041]                       return(sendCondition)
  [14:21:07.041]                     ns <- getNamespace("parallel")
  [14:21:07.041]                     if (exists("sendData", mode = "function", 
  [14:21:07.041]                       envir = ns)) {
  [14:21:07.041]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.041]                         envir = ns)
  [14:21:07.041]                       envir <- sys.frame(frame)
  [14:21:07.041]                       master <- NULL
  [14:21:07.041]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.041]                         !identical(envir, emptyenv())) {
  [14:21:07.041]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.041]                           inherits = FALSE)) {
  [14:21:07.041]                           master <- get("master", mode = "list", 
  [14:21:07.041]                             envir = envir, inherits = FALSE)
  [14:21:07.041]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.041]                             sendCondition <<- function(cond) {
  [14:21:07.041]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.041]                                 success = TRUE)
  [14:21:07.041]                               parallel_sendData(master, data)
  [14:21:07.041]                             }
  [14:21:07.041]                             return(sendCondition)
  [14:21:07.041]                           }
  [14:21:07.041]                         }
  [14:21:07.041]                         frame <- frame + 1L
  [14:21:07.041]                         envir <- sys.frame(frame)
  [14:21:07.041]                       }
  [14:21:07.041]                     }
  [14:21:07.041]                     sendCondition <<- function(cond) NULL
  [14:21:07.041]                   }
  [14:21:07.041]                 })
  [14:21:07.041]                 withCallingHandlers({
  [14:21:07.041]                   NULL
  [14:21:07.041]                 }, immediateCondition = function(cond) {
  [14:21:07.041]                   sendCondition <- ...future.sendCondition()
  [14:21:07.041]                   sendCondition(cond)
  [14:21:07.041]                   muffleCondition <- function (cond) 
  [14:21:07.041]                   {
  [14:21:07.041]                     inherits <- base::inherits
  [14:21:07.041]                     invokeRestart <- base::invokeRestart
  [14:21:07.041]                     muffled <- FALSE
  [14:21:07.041]                     if (inherits(cond, "message")) {
  [14:21:07.041]                       invokeRestart("muffleMessage")
  [14:21:07.041]                       muffled <- TRUE
  [14:21:07.041]                     }
  [14:21:07.041]                     else if (inherits(cond, "warning")) {
  [14:21:07.041]                       invokeRestart("muffleWarning")
  [14:21:07.041]                       muffled <- TRUE
  [14:21:07.041]                     }
  [14:21:07.041]                     else if (inherits(cond, "condition")) {
  [14:21:07.041]                       computeRestarts <- base::computeRestarts
  [14:21:07.041]                       grepl <- base::grepl
  [14:21:07.041]                       is.null <- base::is.null
  [14:21:07.041]                       restarts <- computeRestarts(cond)
  [14:21:07.041]                       for (restart in restarts) {
  [14:21:07.041]                         name <- restart$name
  [14:21:07.041]                         if (is.null(name)) 
  [14:21:07.041]                           next
  [14:21:07.041]                         if (!grepl("^muffle", name)) 
  [14:21:07.041]                           next
  [14:21:07.041]                         invokeRestart(restart)
  [14:21:07.041]                         muffled <- TRUE
  [14:21:07.041]                         break
  [14:21:07.041]                       }
  [14:21:07.041]                     }
  [14:21:07.041]                     invisible(muffled)
  [14:21:07.041]                   }
  [14:21:07.041]                   muffleCondition(cond)
  [14:21:07.041]                 })
  [14:21:07.041]             }))
  [14:21:07.041]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.041]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.041]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.041]                 version = "1.8")
  [14:21:07.041]         }, condition = base::local({
  [14:21:07.041]             c <- base::c
  [14:21:07.041]             inherits <- base::inherits
  [14:21:07.041]             invokeRestart <- base::invokeRestart
  [14:21:07.041]             length <- base::length
  [14:21:07.041]             list <- base::list
  [14:21:07.041]             seq.int <- base::seq.int
  [14:21:07.041]             signalCondition <- base::signalCondition
  [14:21:07.041]             sys.calls <- base::sys.calls
  [14:21:07.041]             Sys.time <- base::Sys.time
  [14:21:07.041]             `[[` <- base::`[[`
  [14:21:07.041]             `+` <- base::`+`
  [14:21:07.041]             `<<-` <- base::`<<-`
  [14:21:07.041]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.041]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.041]                   3L)]
  [14:21:07.041]             }
  [14:21:07.041]             function(cond) {
  [14:21:07.041]                 if (inherits(cond, "error")) {
  [14:21:07.041]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.041]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.041]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.041]                   signalCondition(cond)
  [14:21:07.041]                 }
  [14:21:07.041]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.041]                 ))) {
  [14:21:07.041]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.041]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.041]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.041]                   if (!signal) {
  [14:21:07.041]                     muffleCondition <- function (cond) 
  [14:21:07.041]                     {
  [14:21:07.041]                       inherits <- base::inherits
  [14:21:07.041]                       invokeRestart <- base::invokeRestart
  [14:21:07.041]                       muffled <- FALSE
  [14:21:07.041]                       if (inherits(cond, "message")) {
  [14:21:07.041]                         invokeRestart("muffleMessage")
  [14:21:07.041]                         muffled <- TRUE
  [14:21:07.041]                       }
  [14:21:07.041]                       else if (inherits(cond, "warning")) {
  [14:21:07.041]                         invokeRestart("muffleWarning")
  [14:21:07.041]                         muffled <- TRUE
  [14:21:07.041]                       }
  [14:21:07.041]                       else if (inherits(cond, "condition")) {
  [14:21:07.041]                         computeRestarts <- base::computeRestarts
  [14:21:07.041]                         grepl <- base::grepl
  [14:21:07.041]                         is.null <- base::is.null
  [14:21:07.041]                         restarts <- computeRestarts(cond)
  [14:21:07.041]                         for (restart in restarts) {
  [14:21:07.041]                           name <- restart$name
  [14:21:07.041]                           if (is.null(name)) 
  [14:21:07.041]                             next
  [14:21:07.041]                           if (!grepl("^muffle", name)) 
  [14:21:07.041]                             next
  [14:21:07.041]                           invokeRestart(restart)
  [14:21:07.041]                           muffled <- TRUE
  [14:21:07.041]                           break
  [14:21:07.041]                         }
  [14:21:07.041]                       }
  [14:21:07.041]                       invisible(muffled)
  [14:21:07.041]                     }
  [14:21:07.041]                     muffleCondition(cond)
  [14:21:07.041]                   }
  [14:21:07.041]                 }
  [14:21:07.041]             }
  [14:21:07.041]         }))
  [14:21:07.041]     }, error = function(ex) {
  [14:21:07.041]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.041]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.041]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.041]     }, finally = {
  [14:21:07.041]         {
  [14:21:07.041]             NULL
  [14:21:07.041]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.041]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.041]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.041]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.041]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.041]                 ...) 
  [14:21:07.041]             {
  [14:21:07.041]                 if (substitute) 
  [14:21:07.041]                   expr <- substitute(expr)
  [14:21:07.041]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.041]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.041]                   globals = globals, persistent = persistent, 
  [14:21:07.041]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.041]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.041]                   label = label, ...)
  [14:21:07.041]                 if (!future$lazy) 
  [14:21:07.041]                   future <- run(future)
  [14:21:07.041]                 invisible(future)
  [14:21:07.041]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.041]         }
  [14:21:07.041]         base::options(...future.oldOptions)
  [14:21:07.041]     })
  [14:21:07.041]     Sys.time
  [14:21:07.041]     if (base::is.na(TRUE)) {
  [14:21:07.041]     }
  [14:21:07.041]     else {
  [14:21:07.041]         base::sink(type = "output", split = FALSE)
  [14:21:07.041]         if (TRUE) {
  [14:21:07.041]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.041]         }
  [14:21:07.041]         else {
  [14:21:07.041]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.041]         }
  [14:21:07.041]         base::close(...future.stdout)
  [14:21:07.041]         ...future.stdout <- NULL
  [14:21:07.041]     }
  [14:21:07.041]     ...future.result$conditions <- ...future.conditions
  [14:21:07.041]     ...future.result
  [14:21:07.041] }
  [14:21:07.047] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.072] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.073] - Validating connection of ClusterFuture
  [14:21:07.073] - received message: FutureResult
  [14:21:07.074] - Received FutureResult
  [14:21:07.074] - Erased future from FutureRegistry
  [14:21:07.075] result() for ClusterFuture ...
  [14:21:07.075] - result already collected: FutureResult
  [14:21:07.075] result() for ClusterFuture ... done
  [14:21:07.076] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.076] result() for ClusterFuture ...
  [14:21:07.077] - result already collected: FutureResult
  [14:21:07.077] result() for ClusterFuture ... done
  [14:21:07.077] result() for ClusterFuture ...
  [14:21:07.078] - result already collected: FutureResult
  [14:21:07.078] result() for ClusterFuture ... done
  [14:21:07.080] ClusterFuture started
  [14:21:07.086] getGlobalsAndPackages() ...
  [14:21:07.087] Searching for globals...
  [14:21:07.088] - globals found: [1] '{'
  [14:21:07.089] Searching for globals ... DONE
  [14:21:07.089] Resolving globals: FALSE
  [14:21:07.090] 
  [14:21:07.107] 
  [14:21:07.107] getGlobalsAndPackages() ... DONE
  [14:21:07.111] Packages needed by the future expression (n = 0): <none>
  [14:21:07.112] Packages needed by future strategies (n = 0): <none>
  [14:21:07.144] {
  [14:21:07.144]     {
  [14:21:07.144]         ...future.startTime <- base::Sys.time()
  [14:21:07.144]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.144]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.144]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.144]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.144]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.144]         {
  [14:21:07.144]             {
  [14:21:07.144]                 has_future <- base::requireNamespace("future", 
  [14:21:07.144]                   quietly = TRUE)
  [14:21:07.144]                 version <- if (has_future) 
  [14:21:07.144]                   utils::packageVersion("future")
  [14:21:07.144]                 else NULL
  [14:21:07.144]                 if (!has_future || version < "1.8.0") {
  [14:21:07.144]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.144]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.144]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.144]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.144]                       "release", "version")], collapse = " "), 
  [14:21:07.144]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.144]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.144]                     info)
  [14:21:07.144]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.144]                   if (!has_future) {
  [14:21:07.144]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.144]                       info)
  [14:21:07.144]                   }
  [14:21:07.144]                   else {
  [14:21:07.144]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.144]                       info, version)
  [14:21:07.144]                   }
  [14:21:07.144]                   base::stop(msg)
  [14:21:07.144]                 }
  [14:21:07.144]             }
  [14:21:07.144]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.144]         }
  [14:21:07.144]     }
  [14:21:07.144]     if (base::is.na(TRUE)) {
  [14:21:07.144]     }
  [14:21:07.144]     else {
  [14:21:07.144]         if (TRUE) {
  [14:21:07.144]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.144]                 open = "w")
  [14:21:07.144]         }
  [14:21:07.144]         else {
  [14:21:07.144]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.144]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.144]         }
  [14:21:07.144]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.144]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.144]             base::sink(type = "output", split = FALSE)
  [14:21:07.144]             base::close(...future.stdout)
  [14:21:07.144]         }, add = TRUE)
  [14:21:07.144]     }
  [14:21:07.144]     ...future.frame <- base::sys.nframe()
  [14:21:07.144]     ...future.conditions <- base::list()
  [14:21:07.144]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.144]     ...future.result <- base::tryCatch({
  [14:21:07.144]         base::withCallingHandlers({
  [14:21:07.144]             ...future.value <- base::withVisible(base::local({
  [14:21:07.144]                 ...future.sendCondition <- local({
  [14:21:07.144]                   sendCondition <- NULL
  [14:21:07.144]                   function(frame = 1L) {
  [14:21:07.144]                     if (is.function(sendCondition)) 
  [14:21:07.144]                       return(sendCondition)
  [14:21:07.144]                     ns <- getNamespace("parallel")
  [14:21:07.144]                     if (exists("sendData", mode = "function", 
  [14:21:07.144]                       envir = ns)) {
  [14:21:07.144]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.144]                         envir = ns)
  [14:21:07.144]                       envir <- sys.frame(frame)
  [14:21:07.144]                       master <- NULL
  [14:21:07.144]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.144]                         !identical(envir, emptyenv())) {
  [14:21:07.144]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.144]                           inherits = FALSE)) {
  [14:21:07.144]                           master <- get("master", mode = "list", 
  [14:21:07.144]                             envir = envir, inherits = FALSE)
  [14:21:07.144]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.144]                             sendCondition <<- function(cond) {
  [14:21:07.144]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.144]                                 success = TRUE)
  [14:21:07.144]                               parallel_sendData(master, data)
  [14:21:07.144]                             }
  [14:21:07.144]                             return(sendCondition)
  [14:21:07.144]                           }
  [14:21:07.144]                         }
  [14:21:07.144]                         frame <- frame + 1L
  [14:21:07.144]                         envir <- sys.frame(frame)
  [14:21:07.144]                       }
  [14:21:07.144]                     }
  [14:21:07.144]                     sendCondition <<- function(cond) NULL
  [14:21:07.144]                   }
  [14:21:07.144]                 })
  [14:21:07.144]                 withCallingHandlers({
  [14:21:07.144]                   {
  [14:21:07.144]                     4
  [14:21:07.144]                   }
  [14:21:07.144]                 }, immediateCondition = function(cond) {
  [14:21:07.144]                   sendCondition <- ...future.sendCondition()
  [14:21:07.144]                   sendCondition(cond)
  [14:21:07.144]                   muffleCondition <- function (cond) 
  [14:21:07.144]                   {
  [14:21:07.144]                     inherits <- base::inherits
  [14:21:07.144]                     invokeRestart <- base::invokeRestart
  [14:21:07.144]                     muffled <- FALSE
  [14:21:07.144]                     if (inherits(cond, "message")) {
  [14:21:07.144]                       invokeRestart("muffleMessage")
  [14:21:07.144]                       muffled <- TRUE
  [14:21:07.144]                     }
  [14:21:07.144]                     else if (inherits(cond, "warning")) {
  [14:21:07.144]                       invokeRestart("muffleWarning")
  [14:21:07.144]                       muffled <- TRUE
  [14:21:07.144]                     }
  [14:21:07.144]                     else if (inherits(cond, "condition")) {
  [14:21:07.144]                       computeRestarts <- base::computeRestarts
  [14:21:07.144]                       grepl <- base::grepl
  [14:21:07.144]                       is.null <- base::is.null
  [14:21:07.144]                       restarts <- computeRestarts(cond)
  [14:21:07.144]                       for (restart in restarts) {
  [14:21:07.144]                         name <- restart$name
  [14:21:07.144]                         if (is.null(name)) 
  [14:21:07.144]                           next
  [14:21:07.144]                         if (!grepl("^muffle", name)) 
  [14:21:07.144]                           next
  [14:21:07.144]                         invokeRestart(restart)
  [14:21:07.144]                         muffled <- TRUE
  [14:21:07.144]                         break
  [14:21:07.144]                       }
  [14:21:07.144]                     }
  [14:21:07.144]                     invisible(muffled)
  [14:21:07.144]                   }
  [14:21:07.144]                   muffleCondition(cond)
  [14:21:07.144]                 })
  [14:21:07.144]             }))
  [14:21:07.144]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.144]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.144]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.144]                 version = "1.8")
  [14:21:07.144]         }, condition = base::local({
  [14:21:07.144]             c <- base::c
  [14:21:07.144]             inherits <- base::inherits
  [14:21:07.144]             invokeRestart <- base::invokeRestart
  [14:21:07.144]             length <- base::length
  [14:21:07.144]             list <- base::list
  [14:21:07.144]             seq.int <- base::seq.int
  [14:21:07.144]             signalCondition <- base::signalCondition
  [14:21:07.144]             sys.calls <- base::sys.calls
  [14:21:07.144]             Sys.time <- base::Sys.time
  [14:21:07.144]             `[[` <- base::`[[`
  [14:21:07.144]             `+` <- base::`+`
  [14:21:07.144]             `<<-` <- base::`<<-`
  [14:21:07.144]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.144]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.144]                   3L)]
  [14:21:07.144]             }
  [14:21:07.144]             function(cond) {
  [14:21:07.144]                 if (inherits(cond, "error")) {
  [14:21:07.144]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.144]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.144]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.144]                   signalCondition(cond)
  [14:21:07.144]                 }
  [14:21:07.144]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.144]                 ))) {
  [14:21:07.144]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.144]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.144]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.144]                   if (!signal) {
  [14:21:07.144]                     muffleCondition <- function (cond) 
  [14:21:07.144]                     {
  [14:21:07.144]                       inherits <- base::inherits
  [14:21:07.144]                       invokeRestart <- base::invokeRestart
  [14:21:07.144]                       muffled <- FALSE
  [14:21:07.144]                       if (inherits(cond, "message")) {
  [14:21:07.144]                         invokeRestart("muffleMessage")
  [14:21:07.144]                         muffled <- TRUE
  [14:21:07.144]                       }
  [14:21:07.144]                       else if (inherits(cond, "warning")) {
  [14:21:07.144]                         invokeRestart("muffleWarning")
  [14:21:07.144]                         muffled <- TRUE
  [14:21:07.144]                       }
  [14:21:07.144]                       else if (inherits(cond, "condition")) {
  [14:21:07.144]                         computeRestarts <- base::computeRestarts
  [14:21:07.144]                         grepl <- base::grepl
  [14:21:07.144]                         is.null <- base::is.null
  [14:21:07.144]                         restarts <- computeRestarts(cond)
  [14:21:07.144]                         for (restart in restarts) {
  [14:21:07.144]                           name <- restart$name
  [14:21:07.144]                           if (is.null(name)) 
  [14:21:07.144]                             next
  [14:21:07.144]                           if (!grepl("^muffle", name)) 
  [14:21:07.144]                             next
  [14:21:07.144]                           invokeRestart(restart)
  [14:21:07.144]                           muffled <- TRUE
  [14:21:07.144]                           break
  [14:21:07.144]                         }
  [14:21:07.144]                       }
  [14:21:07.144]                       invisible(muffled)
  [14:21:07.144]                     }
  [14:21:07.144]                     muffleCondition(cond)
  [14:21:07.144]                   }
  [14:21:07.144]                 }
  [14:21:07.144]             }
  [14:21:07.144]         }))
  [14:21:07.144]     }, error = function(ex) {
  [14:21:07.144]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.144]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.144]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.144]     }, finally = {
  [14:21:07.144]         {
  [14:21:07.144]             NULL
  [14:21:07.144]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.144]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.144]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.144]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.144]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.144]                 ...) 
  [14:21:07.144]             {
  [14:21:07.144]                 if (substitute) 
  [14:21:07.144]                   expr <- substitute(expr)
  [14:21:07.144]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.144]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.144]                   globals = globals, persistent = persistent, 
  [14:21:07.144]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.144]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.144]                   label = label, ...)
  [14:21:07.144]                 if (!future$lazy) 
  [14:21:07.144]                   future <- run(future)
  [14:21:07.144]                 invisible(future)
  [14:21:07.144]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.144]         }
  [14:21:07.144]         base::options(...future.oldOptions)
  [14:21:07.144]     })
  [14:21:07.144]     Sys.time
  [14:21:07.144]     if (base::is.na(TRUE)) {
  [14:21:07.144]     }
  [14:21:07.144]     else {
  [14:21:07.144]         base::sink(type = "output", split = FALSE)
  [14:21:07.144]         if (TRUE) {
  [14:21:07.144]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.144]         }
  [14:21:07.144]         else {
  [14:21:07.144]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.144]         }
  [14:21:07.144]         base::close(...future.stdout)
  [14:21:07.144]         ...future.stdout <- NULL
  [14:21:07.144]     }
  [14:21:07.144]     ...future.result$conditions <- ...future.conditions
  [14:21:07.144]     ...future.result
  [14:21:07.144] }
  [14:21:07.150] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.162] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.163] - Validating connection of ClusterFuture
  [14:21:07.163] - received message: FutureResult
  [14:21:07.164] - Received FutureResult
  [14:21:07.164] - Erased future from FutureRegistry
  [14:21:07.165] result() for ClusterFuture ...
  [14:21:07.165] - result already collected: FutureResult
  [14:21:07.165] result() for ClusterFuture ... done
  [14:21:07.166] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.166] result() for ClusterFuture ...
  [14:21:07.167] - result already collected: FutureResult
  [14:21:07.167] result() for ClusterFuture ... done
  [14:21:07.167] result() for ClusterFuture ...
  [14:21:07.168] - result already collected: FutureResult
  [14:21:07.168] result() for ClusterFuture ... done
  [14:21:07.171] ClusterFuture started
  <environment: 0x5574f9604d58> 
  <environment: 0x5574f8644760> 
  [14:21:07.216] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.216] - Validating connection of ClusterFuture
  [14:21:07.217] - received message: FutureResult
  [14:21:07.217] - Received FutureResult
  [14:21:07.218] - Erased future from FutureRegistry
  [14:21:07.218] result() for ClusterFuture ...
  [14:21:07.218] - result already collected: FutureResult
  [14:21:07.219] result() for ClusterFuture ... done
  [14:21:07.219] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:21:07.223] resolve() on environment ...
  [14:21:07.223]  recursive: 0
  [14:21:07.225]  elements: [4] 'a', 'b', 'c', 'd'
  [14:21:07.225] signalConditionsASAP(numeric, pos=1) ...
  [14:21:07.225] - nx: 4
  [14:21:07.226] - relay: TRUE
  [14:21:07.226] - stdout: TRUE
  [14:21:07.226] - signal: TRUE
  [14:21:07.227] - resignal: FALSE
  [14:21:07.227] - force: TRUE
  [14:21:07.227] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.228] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.228]  - until=2
  [14:21:07.228]  - relaying element #2
  [14:21:07.228] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:07.229] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.229] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:07.229]  length: 3 (resolved future 1)
  [14:21:07.230] Future #2
  [14:21:07.230] result() for ClusterFuture ...
  [14:21:07.231] - result already collected: FutureResult
  [14:21:07.231] result() for ClusterFuture ... done
  [14:21:07.231] result() for ClusterFuture ...
  [14:21:07.232] - result already collected: FutureResult
  [14:21:07.232] result() for ClusterFuture ... done
  [14:21:07.232] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:21:07.233] - nx: 4
  [14:21:07.233] - relay: TRUE
  [14:21:07.233] - stdout: TRUE
  [14:21:07.233] - signal: TRUE
  [14:21:07.234] - resignal: FALSE
  [14:21:07.234] - force: TRUE
  [14:21:07.234] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:07.235] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.235]  - until=2
  [14:21:07.235]  - relaying element #2
  [14:21:07.236] result() for ClusterFuture ...
  [14:21:07.236] - result already collected: FutureResult
  [14:21:07.236] result() for ClusterFuture ... done
  [14:21:07.237] result() for ClusterFuture ...
  [14:21:07.237] - result already collected: FutureResult
  [14:21:07.237] result() for ClusterFuture ... done
  [14:21:07.238] result() for ClusterFuture ...
  [14:21:07.238] - result already collected: FutureResult
  [14:21:07.255] result() for ClusterFuture ... done
  [14:21:07.255] result() for ClusterFuture ...
  [14:21:07.256] - result already collected: FutureResult
  [14:21:07.256] result() for ClusterFuture ... done
  [14:21:07.256] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:07.257] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:07.257] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:21:07.257]  length: 2 (resolved future 2)
  [14:21:07.258] Future #3
  [14:21:07.258] result() for ClusterFuture ...
  [14:21:07.259] - result already collected: FutureResult
  [14:21:07.259] result() for ClusterFuture ... done
  [14:21:07.259] result() for ClusterFuture ...
  [14:21:07.260] - result already collected: FutureResult
  [14:21:07.260] result() for ClusterFuture ... done
  [14:21:07.260] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:21:07.261] - nx: 4
  [14:21:07.261] - relay: TRUE
  [14:21:07.261] - stdout: TRUE
  [14:21:07.262] - signal: TRUE
  [14:21:07.262] - resignal: FALSE
  [14:21:07.262] - force: TRUE
  [14:21:07.262] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:07.263] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:07.263]  - until=3
  [14:21:07.263]  - relaying element #3
  [14:21:07.264] result() for ClusterFuture ...
  [14:21:07.264] - result already collected: FutureResult
  [14:21:07.265] result() for ClusterFuture ... done
  [14:21:07.265] result() for ClusterFuture ...
  [14:21:07.265] - result already collected: FutureResult
  [14:21:07.266] result() for ClusterFuture ... done
  [14:21:07.266] result() for ClusterFuture ...
  [14:21:07.267] - result already collected: FutureResult
  [14:21:07.267] result() for ClusterFuture ... done
  [14:21:07.267] result() for ClusterFuture ...
  [14:21:07.268] - result already collected: FutureResult
  [14:21:07.268] result() for ClusterFuture ... done
  [14:21:07.268] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:07.269] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:07.269] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:21:07.269]  length: 1 (resolved future 3)
  [14:21:07.270] Future #4
  [14:21:07.270] result() for ClusterFuture ...
  [14:21:07.270] - result already collected: FutureResult
  [14:21:07.287] result() for ClusterFuture ... done
  [14:21:07.287] result() for ClusterFuture ...
  [14:21:07.288] - result already collected: FutureResult
  [14:21:07.288] result() for ClusterFuture ... done
  [14:21:07.288] signalConditionsASAP(ClusterFuture, pos=4) ...
  [14:21:07.289] - nx: 4
  [14:21:07.289] - relay: TRUE
  [14:21:07.289] - stdout: TRUE
  [14:21:07.289] - signal: TRUE
  [14:21:07.290] - resignal: FALSE
  [14:21:07.290] - force: TRUE
  [14:21:07.290] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:07.291] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:07.291]  - until=4
  [14:21:07.291]  - relaying element #4
  [14:21:07.292] result() for ClusterFuture ...
  [14:21:07.292] - result already collected: FutureResult
  [14:21:07.292] result() for ClusterFuture ... done
  [14:21:07.298] result() for ClusterFuture ...
  [14:21:07.298] - result already collected: FutureResult
  [14:21:07.299] result() for ClusterFuture ... done
  [14:21:07.299] result() for ClusterFuture ...
  [14:21:07.300] - result already collected: FutureResult
  [14:21:07.300] result() for ClusterFuture ... done
  [14:21:07.300] result() for ClusterFuture ...
  [14:21:07.301] - result already collected: FutureResult
  [14:21:07.301] result() for ClusterFuture ... done
  [14:21:07.301] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.302] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:07.302] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [14:21:07.318]  length: 0 (resolved future 4)
  [14:21:07.319] Relaying remaining futures
  [14:21:07.319] signalConditionsASAP(NULL, pos=0) ...
  [14:21:07.320] - nx: 4
  [14:21:07.320] - relay: TRUE
  [14:21:07.320] - stdout: TRUE
  [14:21:07.321] - signal: TRUE
  [14:21:07.321] - resignal: FALSE
  [14:21:07.321] - force: TRUE
  [14:21:07.321] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.322] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:21:07.322] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.323] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:07.323] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:07.323] resolve() on environment ... DONE
  [14:21:07.324] result() for ClusterFuture ...
  [14:21:07.324] - result already collected: FutureResult
  [14:21:07.324] result() for ClusterFuture ... done
  [14:21:07.325] result() for ClusterFuture ...
  [14:21:07.325] - result already collected: FutureResult
  [14:21:07.325] result() for ClusterFuture ... done
  [14:21:07.326] result() for ClusterFuture ...
  [14:21:07.326] - result already collected: FutureResult
  [14:21:07.326] result() for ClusterFuture ... done
  [14:21:07.327] result() for ClusterFuture ...
  [14:21:07.327] - result already collected: FutureResult
  [14:21:07.327] result() for ClusterFuture ... done
  [14:21:07.328] result() for ClusterFuture ...
  [14:21:07.328] - result already collected: FutureResult
  [14:21:07.328] result() for ClusterFuture ... done
  [14:21:07.329] result() for ClusterFuture ...
  [14:21:07.329] - result already collected: FutureResult
  [14:21:07.329] result() for ClusterFuture ... done
  <environment: 0x5574f88c87a8> 
  Dimensions: c(2, 3, 1)
  [14:21:07.352] getGlobalsAndPackages() ...
  [14:21:07.352] Searching for globals...
  [14:21:07.353] 
  [14:21:07.353] Searching for globals ... DONE
  [14:21:07.354] - globals: [0] <none>
  [14:21:07.354] getGlobalsAndPackages() ... DONE
  [14:21:07.358] Packages needed by the future expression (n = 0): <none>
  [14:21:07.359] Packages needed by future strategies (n = 0): <none>
  [14:21:07.364] {
  [14:21:07.364]     {
  [14:21:07.364]         ...future.startTime <- base::Sys.time()
  [14:21:07.364]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.364]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.364]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.364]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.364]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.364]         {
  [14:21:07.364]             {
  [14:21:07.364]                 has_future <- base::requireNamespace("future", 
  [14:21:07.364]                   quietly = TRUE)
  [14:21:07.364]                 version <- if (has_future) 
  [14:21:07.364]                   utils::packageVersion("future")
  [14:21:07.364]                 else NULL
  [14:21:07.364]                 if (!has_future || version < "1.8.0") {
  [14:21:07.364]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.364]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.364]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.364]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.364]                       "release", "version")], collapse = " "), 
  [14:21:07.364]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.364]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.364]                     info)
  [14:21:07.364]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.364]                   if (!has_future) {
  [14:21:07.364]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.364]                       info)
  [14:21:07.364]                   }
  [14:21:07.364]                   else {
  [14:21:07.364]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.364]                       info, version)
  [14:21:07.364]                   }
  [14:21:07.364]                   base::stop(msg)
  [14:21:07.364]                 }
  [14:21:07.364]             }
  [14:21:07.364]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.364]         }
  [14:21:07.364]     }
  [14:21:07.364]     if (base::is.na(TRUE)) {
  [14:21:07.364]     }
  [14:21:07.364]     else {
  [14:21:07.364]         if (TRUE) {
  [14:21:07.364]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.364]                 open = "w")
  [14:21:07.364]         }
  [14:21:07.364]         else {
  [14:21:07.364]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.364]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.364]         }
  [14:21:07.364]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.364]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.364]             base::sink(type = "output", split = FALSE)
  [14:21:07.364]             base::close(...future.stdout)
  [14:21:07.364]         }, add = TRUE)
  [14:21:07.364]     }
  [14:21:07.364]     ...future.frame <- base::sys.nframe()
  [14:21:07.364]     ...future.conditions <- base::list()
  [14:21:07.364]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.364]     ...future.result <- base::tryCatch({
  [14:21:07.364]         base::withCallingHandlers({
  [14:21:07.364]             ...future.value <- base::withVisible(base::local({
  [14:21:07.364]                 ...future.sendCondition <- local({
  [14:21:07.364]                   sendCondition <- NULL
  [14:21:07.364]                   function(frame = 1L) {
  [14:21:07.364]                     if (is.function(sendCondition)) 
  [14:21:07.364]                       return(sendCondition)
  [14:21:07.364]                     ns <- getNamespace("parallel")
  [14:21:07.364]                     if (exists("sendData", mode = "function", 
  [14:21:07.364]                       envir = ns)) {
  [14:21:07.364]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.364]                         envir = ns)
  [14:21:07.364]                       envir <- sys.frame(frame)
  [14:21:07.364]                       master <- NULL
  [14:21:07.364]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.364]                         !identical(envir, emptyenv())) {
  [14:21:07.364]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.364]                           inherits = FALSE)) {
  [14:21:07.364]                           master <- get("master", mode = "list", 
  [14:21:07.364]                             envir = envir, inherits = FALSE)
  [14:21:07.364]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.364]                             sendCondition <<- function(cond) {
  [14:21:07.364]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.364]                                 success = TRUE)
  [14:21:07.364]                               parallel_sendData(master, data)
  [14:21:07.364]                             }
  [14:21:07.364]                             return(sendCondition)
  [14:21:07.364]                           }
  [14:21:07.364]                         }
  [14:21:07.364]                         frame <- frame + 1L
  [14:21:07.364]                         envir <- sys.frame(frame)
  [14:21:07.364]                       }
  [14:21:07.364]                     }
  [14:21:07.364]                     sendCondition <<- function(cond) NULL
  [14:21:07.364]                   }
  [14:21:07.364]                 })
  [14:21:07.364]                 withCallingHandlers({
  [14:21:07.364]                   2
  [14:21:07.364]                 }, immediateCondition = function(cond) {
  [14:21:07.364]                   sendCondition <- ...future.sendCondition()
  [14:21:07.364]                   sendCondition(cond)
  [14:21:07.364]                   muffleCondition <- function (cond) 
  [14:21:07.364]                   {
  [14:21:07.364]                     inherits <- base::inherits
  [14:21:07.364]                     invokeRestart <- base::invokeRestart
  [14:21:07.364]                     muffled <- FALSE
  [14:21:07.364]                     if (inherits(cond, "message")) {
  [14:21:07.364]                       invokeRestart("muffleMessage")
  [14:21:07.364]                       muffled <- TRUE
  [14:21:07.364]                     }
  [14:21:07.364]                     else if (inherits(cond, "warning")) {
  [14:21:07.364]                       invokeRestart("muffleWarning")
  [14:21:07.364]                       muffled <- TRUE
  [14:21:07.364]                     }
  [14:21:07.364]                     else if (inherits(cond, "condition")) {
  [14:21:07.364]                       computeRestarts <- base::computeRestarts
  [14:21:07.364]                       grepl <- base::grepl
  [14:21:07.364]                       is.null <- base::is.null
  [14:21:07.364]                       restarts <- computeRestarts(cond)
  [14:21:07.364]                       for (restart in restarts) {
  [14:21:07.364]                         name <- restart$name
  [14:21:07.364]                         if (is.null(name)) 
  [14:21:07.364]                           next
  [14:21:07.364]                         if (!grepl("^muffle", name)) 
  [14:21:07.364]                           next
  [14:21:07.364]                         invokeRestart(restart)
  [14:21:07.364]                         muffled <- TRUE
  [14:21:07.364]                         break
  [14:21:07.364]                       }
  [14:21:07.364]                     }
  [14:21:07.364]                     invisible(muffled)
  [14:21:07.364]                   }
  [14:21:07.364]                   muffleCondition(cond)
  [14:21:07.364]                 })
  [14:21:07.364]             }))
  [14:21:07.364]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.364]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.364]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.364]                 version = "1.8")
  [14:21:07.364]         }, condition = base::local({
  [14:21:07.364]             c <- base::c
  [14:21:07.364]             inherits <- base::inherits
  [14:21:07.364]             invokeRestart <- base::invokeRestart
  [14:21:07.364]             length <- base::length
  [14:21:07.364]             list <- base::list
  [14:21:07.364]             seq.int <- base::seq.int
  [14:21:07.364]             signalCondition <- base::signalCondition
  [14:21:07.364]             sys.calls <- base::sys.calls
  [14:21:07.364]             Sys.time <- base::Sys.time
  [14:21:07.364]             `[[` <- base::`[[`
  [14:21:07.364]             `+` <- base::`+`
  [14:21:07.364]             `<<-` <- base::`<<-`
  [14:21:07.364]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.364]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.364]                   3L)]
  [14:21:07.364]             }
  [14:21:07.364]             function(cond) {
  [14:21:07.364]                 if (inherits(cond, "error")) {
  [14:21:07.364]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.364]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.364]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.364]                   signalCondition(cond)
  [14:21:07.364]                 }
  [14:21:07.364]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.364]                 ))) {
  [14:21:07.364]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.364]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.364]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.364]                   if (!signal) {
  [14:21:07.364]                     muffleCondition <- function (cond) 
  [14:21:07.364]                     {
  [14:21:07.364]                       inherits <- base::inherits
  [14:21:07.364]                       invokeRestart <- base::invokeRestart
  [14:21:07.364]                       muffled <- FALSE
  [14:21:07.364]                       if (inherits(cond, "message")) {
  [14:21:07.364]                         invokeRestart("muffleMessage")
  [14:21:07.364]                         muffled <- TRUE
  [14:21:07.364]                       }
  [14:21:07.364]                       else if (inherits(cond, "warning")) {
  [14:21:07.364]                         invokeRestart("muffleWarning")
  [14:21:07.364]                         muffled <- TRUE
  [14:21:07.364]                       }
  [14:21:07.364]                       else if (inherits(cond, "condition")) {
  [14:21:07.364]                         computeRestarts <- base::computeRestarts
  [14:21:07.364]                         grepl <- base::grepl
  [14:21:07.364]                         is.null <- base::is.null
  [14:21:07.364]                         restarts <- computeRestarts(cond)
  [14:21:07.364]                         for (restart in restarts) {
  [14:21:07.364]                           name <- restart$name
  [14:21:07.364]                           if (is.null(name)) 
  [14:21:07.364]                             next
  [14:21:07.364]                           if (!grepl("^muffle", name)) 
  [14:21:07.364]                             next
  [14:21:07.364]                           invokeRestart(restart)
  [14:21:07.364]                           muffled <- TRUE
  [14:21:07.364]                           break
  [14:21:07.364]                         }
  [14:21:07.364]                       }
  [14:21:07.364]                       invisible(muffled)
  [14:21:07.364]                     }
  [14:21:07.364]                     muffleCondition(cond)
  [14:21:07.364]                   }
  [14:21:07.364]                 }
  [14:21:07.364]             }
  [14:21:07.364]         }))
  [14:21:07.364]     }, error = function(ex) {
  [14:21:07.364]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.364]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.364]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.364]     }, finally = {
  [14:21:07.364]         {
  [14:21:07.364]             NULL
  [14:21:07.364]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.364]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.364]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.364]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.364]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.364]                 ...) 
  [14:21:07.364]             {
  [14:21:07.364]                 if (substitute) 
  [14:21:07.364]                   expr <- substitute(expr)
  [14:21:07.364]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.364]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.364]                   globals = globals, persistent = persistent, 
  [14:21:07.364]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.364]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.364]                   label = label, ...)
  [14:21:07.364]                 if (!future$lazy) 
  [14:21:07.364]                   future <- run(future)
  [14:21:07.364]                 invisible(future)
  [14:21:07.364]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.364]         }
  [14:21:07.364]         base::options(...future.oldOptions)
  [14:21:07.364]     })
  [14:21:07.364]     Sys.time
  [14:21:07.364]     if (base::is.na(TRUE)) {
  [14:21:07.364]     }
  [14:21:07.364]     else {
  [14:21:07.364]         base::sink(type = "output", split = FALSE)
  [14:21:07.364]         if (TRUE) {
  [14:21:07.364]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.364]         }
  [14:21:07.364]         else {
  [14:21:07.364]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.364]         }
  [14:21:07.364]         base::close(...future.stdout)
  [14:21:07.364]         ...future.stdout <- NULL
  [14:21:07.364]     }
  [14:21:07.364]     ...future.result$conditions <- ...future.conditions
  [14:21:07.364]     ...future.result
  [14:21:07.364] }
  [14:21:07.475] ClusterFuture started
  [14:21:07.481] getGlobalsAndPackages() ...
  [14:21:07.481] Searching for globals...
  [14:21:07.482] 
  [14:21:07.482] Searching for globals ... DONE
  [14:21:07.483] - globals: [0] <none>
  [14:21:07.483] getGlobalsAndPackages() ... DONE
  [14:21:07.494] Packages needed by the future expression (n = 0): <none>
  [14:21:07.495] Packages needed by future strategies (n = 0): <none>
  [14:21:07.500] {
  [14:21:07.500]     {
  [14:21:07.500]         ...future.startTime <- base::Sys.time()
  [14:21:07.500]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.500]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.500]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.500]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.500]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.500]         {
  [14:21:07.500]             {
  [14:21:07.500]                 has_future <- base::requireNamespace("future", 
  [14:21:07.500]                   quietly = TRUE)
  [14:21:07.500]                 version <- if (has_future) 
  [14:21:07.500]                   utils::packageVersion("future")
  [14:21:07.500]                 else NULL
  [14:21:07.500]                 if (!has_future || version < "1.8.0") {
  [14:21:07.500]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.500]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.500]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.500]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.500]                       "release", "version")], collapse = " "), 
  [14:21:07.500]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.500]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.500]                     info)
  [14:21:07.500]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.500]                   if (!has_future) {
  [14:21:07.500]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.500]                       info)
  [14:21:07.500]                   }
  [14:21:07.500]                   else {
  [14:21:07.500]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.500]                       info, version)
  [14:21:07.500]                   }
  [14:21:07.500]                   base::stop(msg)
  [14:21:07.500]                 }
  [14:21:07.500]             }
  [14:21:07.500]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.500]         }
  [14:21:07.500]     }
  [14:21:07.500]     if (base::is.na(TRUE)) {
  [14:21:07.500]     }
  [14:21:07.500]     else {
  [14:21:07.500]         if (TRUE) {
  [14:21:07.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.500]                 open = "w")
  [14:21:07.500]         }
  [14:21:07.500]         else {
  [14:21:07.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.500]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.500]         }
  [14:21:07.500]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.500]             base::sink(type = "output", split = FALSE)
  [14:21:07.500]             base::close(...future.stdout)
  [14:21:07.500]         }, add = TRUE)
  [14:21:07.500]     }
  [14:21:07.500]     ...future.frame <- base::sys.nframe()
  [14:21:07.500]     ...future.conditions <- base::list()
  [14:21:07.500]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.500]     ...future.result <- base::tryCatch({
  [14:21:07.500]         base::withCallingHandlers({
  [14:21:07.500]             ...future.value <- base::withVisible(base::local({
  [14:21:07.500]                 ...future.sendCondition <- local({
  [14:21:07.500]                   sendCondition <- NULL
  [14:21:07.500]                   function(frame = 1L) {
  [14:21:07.500]                     if (is.function(sendCondition)) 
  [14:21:07.500]                       return(sendCondition)
  [14:21:07.500]                     ns <- getNamespace("parallel")
  [14:21:07.500]                     if (exists("sendData", mode = "function", 
  [14:21:07.500]                       envir = ns)) {
  [14:21:07.500]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.500]                         envir = ns)
  [14:21:07.500]                       envir <- sys.frame(frame)
  [14:21:07.500]                       master <- NULL
  [14:21:07.500]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.500]                         !identical(envir, emptyenv())) {
  [14:21:07.500]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.500]                           inherits = FALSE)) {
  [14:21:07.500]                           master <- get("master", mode = "list", 
  [14:21:07.500]                             envir = envir, inherits = FALSE)
  [14:21:07.500]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.500]                             sendCondition <<- function(cond) {
  [14:21:07.500]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.500]                                 success = TRUE)
  [14:21:07.500]                               parallel_sendData(master, data)
  [14:21:07.500]                             }
  [14:21:07.500]                             return(sendCondition)
  [14:21:07.500]                           }
  [14:21:07.500]                         }
  [14:21:07.500]                         frame <- frame + 1L
  [14:21:07.500]                         envir <- sys.frame(frame)
  [14:21:07.500]                       }
  [14:21:07.500]                     }
  [14:21:07.500]                     sendCondition <<- function(cond) NULL
  [14:21:07.500]                   }
  [14:21:07.500]                 })
  [14:21:07.500]                 withCallingHandlers({
  [14:21:07.500]                   NULL
  [14:21:07.500]                 }, immediateCondition = function(cond) {
  [14:21:07.500]                   sendCondition <- ...future.sendCondition()
  [14:21:07.500]                   sendCondition(cond)
  [14:21:07.500]                   muffleCondition <- function (cond) 
  [14:21:07.500]                   {
  [14:21:07.500]                     inherits <- base::inherits
  [14:21:07.500]                     invokeRestart <- base::invokeRestart
  [14:21:07.500]                     muffled <- FALSE
  [14:21:07.500]                     if (inherits(cond, "message")) {
  [14:21:07.500]                       invokeRestart("muffleMessage")
  [14:21:07.500]                       muffled <- TRUE
  [14:21:07.500]                     }
  [14:21:07.500]                     else if (inherits(cond, "warning")) {
  [14:21:07.500]                       invokeRestart("muffleWarning")
  [14:21:07.500]                       muffled <- TRUE
  [14:21:07.500]                     }
  [14:21:07.500]                     else if (inherits(cond, "condition")) {
  [14:21:07.500]                       computeRestarts <- base::computeRestarts
  [14:21:07.500]                       grepl <- base::grepl
  [14:21:07.500]                       is.null <- base::is.null
  [14:21:07.500]                       restarts <- computeRestarts(cond)
  [14:21:07.500]                       for (restart in restarts) {
  [14:21:07.500]                         name <- restart$name
  [14:21:07.500]                         if (is.null(name)) 
  [14:21:07.500]                           next
  [14:21:07.500]                         if (!grepl("^muffle", name)) 
  [14:21:07.500]                           next
  [14:21:07.500]                         invokeRestart(restart)
  [14:21:07.500]                         muffled <- TRUE
  [14:21:07.500]                         break
  [14:21:07.500]                       }
  [14:21:07.500]                     }
  [14:21:07.500]                     invisible(muffled)
  [14:21:07.500]                   }
  [14:21:07.500]                   muffleCondition(cond)
  [14:21:07.500]                 })
  [14:21:07.500]             }))
  [14:21:07.500]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.500]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.500]                 version = "1.8")
  [14:21:07.500]         }, condition = base::local({
  [14:21:07.500]             c <- base::c
  [14:21:07.500]             inherits <- base::inherits
  [14:21:07.500]             invokeRestart <- base::invokeRestart
  [14:21:07.500]             length <- base::length
  [14:21:07.500]             list <- base::list
  [14:21:07.500]             seq.int <- base::seq.int
  [14:21:07.500]             signalCondition <- base::signalCondition
  [14:21:07.500]             sys.calls <- base::sys.calls
  [14:21:07.500]             Sys.time <- base::Sys.time
  [14:21:07.500]             `[[` <- base::`[[`
  [14:21:07.500]             `+` <- base::`+`
  [14:21:07.500]             `<<-` <- base::`<<-`
  [14:21:07.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.500]                   3L)]
  [14:21:07.500]             }
  [14:21:07.500]             function(cond) {
  [14:21:07.500]                 if (inherits(cond, "error")) {
  [14:21:07.500]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.500]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.500]                   signalCondition(cond)
  [14:21:07.500]                 }
  [14:21:07.500]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.500]                 ))) {
  [14:21:07.500]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.500]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.500]                   if (!signal) {
  [14:21:07.500]                     muffleCondition <- function (cond) 
  [14:21:07.500]                     {
  [14:21:07.500]                       inherits <- base::inherits
  [14:21:07.500]                       invokeRestart <- base::invokeRestart
  [14:21:07.500]                       muffled <- FALSE
  [14:21:07.500]                       if (inherits(cond, "message")) {
  [14:21:07.500]                         invokeRestart("muffleMessage")
  [14:21:07.500]                         muffled <- TRUE
  [14:21:07.500]                       }
  [14:21:07.500]                       else if (inherits(cond, "warning")) {
  [14:21:07.500]                         invokeRestart("muffleWarning")
  [14:21:07.500]                         muffled <- TRUE
  [14:21:07.500]                       }
  [14:21:07.500]                       else if (inherits(cond, "condition")) {
  [14:21:07.500]                         computeRestarts <- base::computeRestarts
  [14:21:07.500]                         grepl <- base::grepl
  [14:21:07.500]                         is.null <- base::is.null
  [14:21:07.500]                         restarts <- computeRestarts(cond)
  [14:21:07.500]                         for (restart in restarts) {
  [14:21:07.500]                           name <- restart$name
  [14:21:07.500]                           if (is.null(name)) 
  [14:21:07.500]                             next
  [14:21:07.500]                           if (!grepl("^muffle", name)) 
  [14:21:07.500]                             next
  [14:21:07.500]                           invokeRestart(restart)
  [14:21:07.500]                           muffled <- TRUE
  [14:21:07.500]                           break
  [14:21:07.500]                         }
  [14:21:07.500]                       }
  [14:21:07.500]                       invisible(muffled)
  [14:21:07.500]                     }
  [14:21:07.500]                     muffleCondition(cond)
  [14:21:07.500]                   }
  [14:21:07.500]                 }
  [14:21:07.500]             }
  [14:21:07.500]         }))
  [14:21:07.500]     }, error = function(ex) {
  [14:21:07.500]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.500]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.500]     }, finally = {
  [14:21:07.500]         {
  [14:21:07.500]             NULL
  [14:21:07.500]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.500]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.500]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.500]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.500]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.500]                 ...) 
  [14:21:07.500]             {
  [14:21:07.500]                 if (substitute) 
  [14:21:07.500]                   expr <- substitute(expr)
  [14:21:07.500]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.500]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.500]                   globals = globals, persistent = persistent, 
  [14:21:07.500]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.500]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.500]                   label = label, ...)
  [14:21:07.500]                 if (!future$lazy) 
  [14:21:07.500]                   future <- run(future)
  [14:21:07.500]                 invisible(future)
  [14:21:07.500]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.500]         }
  [14:21:07.500]         base::options(...future.oldOptions)
  [14:21:07.500]     })
  [14:21:07.500]     Sys.time
  [14:21:07.500]     if (base::is.na(TRUE)) {
  [14:21:07.500]     }
  [14:21:07.500]     else {
  [14:21:07.500]         base::sink(type = "output", split = FALSE)
  [14:21:07.500]         if (TRUE) {
  [14:21:07.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.500]         }
  [14:21:07.500]         else {
  [14:21:07.500]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.500]         }
  [14:21:07.500]         base::close(...future.stdout)
  [14:21:07.500]         ...future.stdout <- NULL
  [14:21:07.500]     }
  [14:21:07.500]     ...future.result$conditions <- ...future.conditions
  [14:21:07.500]     ...future.result
  [14:21:07.500] }
  [14:21:07.506] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.518] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.518] - Validating connection of ClusterFuture
  [14:21:07.519] - received message: FutureResult
  [14:21:07.519] - Received FutureResult
  [14:21:07.520] - Erased future from FutureRegistry
  [14:21:07.520] result() for ClusterFuture ...
  [14:21:07.520] - result already collected: FutureResult
  [14:21:07.521] result() for ClusterFuture ... done
  [14:21:07.521] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.521] result() for ClusterFuture ...
  [14:21:07.522] - result already collected: FutureResult
  [14:21:07.522] result() for ClusterFuture ... done
  [14:21:07.523] result() for ClusterFuture ...
  [14:21:07.523] - result already collected: FutureResult
  [14:21:07.523] result() for ClusterFuture ... done
  [14:21:07.526] ClusterFuture started
  [14:21:07.537] getGlobalsAndPackages() ...
  [14:21:07.538] Searching for globals...
  [14:21:07.555] - globals found: [1] '{'
  [14:21:07.556] Searching for globals ... DONE
  [14:21:07.556] Resolving globals: FALSE
  [14:21:07.557] 
  [14:21:07.558] 
  [14:21:07.558] getGlobalsAndPackages() ... DONE
  [14:21:07.562] Packages needed by the future expression (n = 0): <none>
  [14:21:07.562] Packages needed by future strategies (n = 0): <none>
  [14:21:07.567] {
  [14:21:07.567]     {
  [14:21:07.567]         ...future.startTime <- base::Sys.time()
  [14:21:07.567]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.567]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.567]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.567]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.567]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.567]         {
  [14:21:07.567]             {
  [14:21:07.567]                 has_future <- base::requireNamespace("future", 
  [14:21:07.567]                   quietly = TRUE)
  [14:21:07.567]                 version <- if (has_future) 
  [14:21:07.567]                   utils::packageVersion("future")
  [14:21:07.567]                 else NULL
  [14:21:07.567]                 if (!has_future || version < "1.8.0") {
  [14:21:07.567]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.567]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.567]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.567]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.567]                       "release", "version")], collapse = " "), 
  [14:21:07.567]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.567]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.567]                     info)
  [14:21:07.567]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.567]                   if (!has_future) {
  [14:21:07.567]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.567]                       info)
  [14:21:07.567]                   }
  [14:21:07.567]                   else {
  [14:21:07.567]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.567]                       info, version)
  [14:21:07.567]                   }
  [14:21:07.567]                   base::stop(msg)
  [14:21:07.567]                 }
  [14:21:07.567]             }
  [14:21:07.567]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.567]         }
  [14:21:07.567]     }
  [14:21:07.567]     if (base::is.na(TRUE)) {
  [14:21:07.567]     }
  [14:21:07.567]     else {
  [14:21:07.567]         if (TRUE) {
  [14:21:07.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.567]                 open = "w")
  [14:21:07.567]         }
  [14:21:07.567]         else {
  [14:21:07.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.567]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.567]         }
  [14:21:07.567]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.567]             base::sink(type = "output", split = FALSE)
  [14:21:07.567]             base::close(...future.stdout)
  [14:21:07.567]         }, add = TRUE)
  [14:21:07.567]     }
  [14:21:07.567]     ...future.frame <- base::sys.nframe()
  [14:21:07.567]     ...future.conditions <- base::list()
  [14:21:07.567]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.567]     ...future.result <- base::tryCatch({
  [14:21:07.567]         base::withCallingHandlers({
  [14:21:07.567]             ...future.value <- base::withVisible(base::local({
  [14:21:07.567]                 ...future.sendCondition <- local({
  [14:21:07.567]                   sendCondition <- NULL
  [14:21:07.567]                   function(frame = 1L) {
  [14:21:07.567]                     if (is.function(sendCondition)) 
  [14:21:07.567]                       return(sendCondition)
  [14:21:07.567]                     ns <- getNamespace("parallel")
  [14:21:07.567]                     if (exists("sendData", mode = "function", 
  [14:21:07.567]                       envir = ns)) {
  [14:21:07.567]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.567]                         envir = ns)
  [14:21:07.567]                       envir <- sys.frame(frame)
  [14:21:07.567]                       master <- NULL
  [14:21:07.567]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.567]                         !identical(envir, emptyenv())) {
  [14:21:07.567]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.567]                           inherits = FALSE)) {
  [14:21:07.567]                           master <- get("master", mode = "list", 
  [14:21:07.567]                             envir = envir, inherits = FALSE)
  [14:21:07.567]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.567]                             sendCondition <<- function(cond) {
  [14:21:07.567]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.567]                                 success = TRUE)
  [14:21:07.567]                               parallel_sendData(master, data)
  [14:21:07.567]                             }
  [14:21:07.567]                             return(sendCondition)
  [14:21:07.567]                           }
  [14:21:07.567]                         }
  [14:21:07.567]                         frame <- frame + 1L
  [14:21:07.567]                         envir <- sys.frame(frame)
  [14:21:07.567]                       }
  [14:21:07.567]                     }
  [14:21:07.567]                     sendCondition <<- function(cond) NULL
  [14:21:07.567]                   }
  [14:21:07.567]                 })
  [14:21:07.567]                 withCallingHandlers({
  [14:21:07.567]                   {
  [14:21:07.567]                     4
  [14:21:07.567]                   }
  [14:21:07.567]                 }, immediateCondition = function(cond) {
  [14:21:07.567]                   sendCondition <- ...future.sendCondition()
  [14:21:07.567]                   sendCondition(cond)
  [14:21:07.567]                   muffleCondition <- function (cond) 
  [14:21:07.567]                   {
  [14:21:07.567]                     inherits <- base::inherits
  [14:21:07.567]                     invokeRestart <- base::invokeRestart
  [14:21:07.567]                     muffled <- FALSE
  [14:21:07.567]                     if (inherits(cond, "message")) {
  [14:21:07.567]                       invokeRestart("muffleMessage")
  [14:21:07.567]                       muffled <- TRUE
  [14:21:07.567]                     }
  [14:21:07.567]                     else if (inherits(cond, "warning")) {
  [14:21:07.567]                       invokeRestart("muffleWarning")
  [14:21:07.567]                       muffled <- TRUE
  [14:21:07.567]                     }
  [14:21:07.567]                     else if (inherits(cond, "condition")) {
  [14:21:07.567]                       computeRestarts <- base::computeRestarts
  [14:21:07.567]                       grepl <- base::grepl
  [14:21:07.567]                       is.null <- base::is.null
  [14:21:07.567]                       restarts <- computeRestarts(cond)
  [14:21:07.567]                       for (restart in restarts) {
  [14:21:07.567]                         name <- restart$name
  [14:21:07.567]                         if (is.null(name)) 
  [14:21:07.567]                           next
  [14:21:07.567]                         if (!grepl("^muffle", name)) 
  [14:21:07.567]                           next
  [14:21:07.567]                         invokeRestart(restart)
  [14:21:07.567]                         muffled <- TRUE
  [14:21:07.567]                         break
  [14:21:07.567]                       }
  [14:21:07.567]                     }
  [14:21:07.567]                     invisible(muffled)
  [14:21:07.567]                   }
  [14:21:07.567]                   muffleCondition(cond)
  [14:21:07.567]                 })
  [14:21:07.567]             }))
  [14:21:07.567]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.567]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.567]                 version = "1.8")
  [14:21:07.567]         }, condition = base::local({
  [14:21:07.567]             c <- base::c
  [14:21:07.567]             inherits <- base::inherits
  [14:21:07.567]             invokeRestart <- base::invokeRestart
  [14:21:07.567]             length <- base::length
  [14:21:07.567]             list <- base::list
  [14:21:07.567]             seq.int <- base::seq.int
  [14:21:07.567]             signalCondition <- base::signalCondition
  [14:21:07.567]             sys.calls <- base::sys.calls
  [14:21:07.567]             Sys.time <- base::Sys.time
  [14:21:07.567]             `[[` <- base::`[[`
  [14:21:07.567]             `+` <- base::`+`
  [14:21:07.567]             `<<-` <- base::`<<-`
  [14:21:07.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.567]                   3L)]
  [14:21:07.567]             }
  [14:21:07.567]             function(cond) {
  [14:21:07.567]                 if (inherits(cond, "error")) {
  [14:21:07.567]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.567]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.567]                   signalCondition(cond)
  [14:21:07.567]                 }
  [14:21:07.567]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.567]                 ))) {
  [14:21:07.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.567]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.567]                   if (!signal) {
  [14:21:07.567]                     muffleCondition <- function (cond) 
  [14:21:07.567]                     {
  [14:21:07.567]                       inherits <- base::inherits
  [14:21:07.567]                       invokeRestart <- base::invokeRestart
  [14:21:07.567]                       muffled <- FALSE
  [14:21:07.567]                       if (inherits(cond, "message")) {
  [14:21:07.567]                         invokeRestart("muffleMessage")
  [14:21:07.567]                         muffled <- TRUE
  [14:21:07.567]                       }
  [14:21:07.567]                       else if (inherits(cond, "warning")) {
  [14:21:07.567]                         invokeRestart("muffleWarning")
  [14:21:07.567]                         muffled <- TRUE
  [14:21:07.567]                       }
  [14:21:07.567]                       else if (inherits(cond, "condition")) {
  [14:21:07.567]                         computeRestarts <- base::computeRestarts
  [14:21:07.567]                         grepl <- base::grepl
  [14:21:07.567]                         is.null <- base::is.null
  [14:21:07.567]                         restarts <- computeRestarts(cond)
  [14:21:07.567]                         for (restart in restarts) {
  [14:21:07.567]                           name <- restart$name
  [14:21:07.567]                           if (is.null(name)) 
  [14:21:07.567]                             next
  [14:21:07.567]                           if (!grepl("^muffle", name)) 
  [14:21:07.567]                             next
  [14:21:07.567]                           invokeRestart(restart)
  [14:21:07.567]                           muffled <- TRUE
  [14:21:07.567]                           break
  [14:21:07.567]                         }
  [14:21:07.567]                       }
  [14:21:07.567]                       invisible(muffled)
  [14:21:07.567]                     }
  [14:21:07.567]                     muffleCondition(cond)
  [14:21:07.567]                   }
  [14:21:07.567]                 }
  [14:21:07.567]             }
  [14:21:07.567]         }))
  [14:21:07.567]     }, error = function(ex) {
  [14:21:07.567]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.567]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.567]     }, finally = {
  [14:21:07.567]         {
  [14:21:07.567]             NULL
  [14:21:07.567]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.567]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.567]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.567]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.567]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.567]                 ...) 
  [14:21:07.567]             {
  [14:21:07.567]                 if (substitute) 
  [14:21:07.567]                   expr <- substitute(expr)
  [14:21:07.567]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.567]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.567]                   globals = globals, persistent = persistent, 
  [14:21:07.567]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.567]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.567]                   label = label, ...)
  [14:21:07.567]                 if (!future$lazy) 
  [14:21:07.567]                   future <- run(future)
  [14:21:07.567]                 invisible(future)
  [14:21:07.567]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.567]         }
  [14:21:07.567]         base::options(...future.oldOptions)
  [14:21:07.567]     })
  [14:21:07.567]     Sys.time
  [14:21:07.567]     if (base::is.na(TRUE)) {
  [14:21:07.567]     }
  [14:21:07.567]     else {
  [14:21:07.567]         base::sink(type = "output", split = FALSE)
  [14:21:07.567]         if (TRUE) {
  [14:21:07.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.567]         }
  [14:21:07.567]         else {
  [14:21:07.567]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.567]         }
  [14:21:07.567]         base::close(...future.stdout)
  [14:21:07.567]         ...future.stdout <- NULL
  [14:21:07.567]     }
  [14:21:07.567]     ...future.result$conditions <- ...future.conditions
  [14:21:07.567]     ...future.result
  [14:21:07.567] }
  [14:21:07.573] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.585] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.586] - Validating connection of ClusterFuture
  [14:21:07.586] - received message: FutureResult
  [14:21:07.587] - Received FutureResult
  [14:21:07.587] - Erased future from FutureRegistry
  [14:21:07.587] result() for ClusterFuture ...
  [14:21:07.588] - result already collected: FutureResult
  [14:21:07.588] result() for ClusterFuture ... done
  [14:21:07.589] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.589] result() for ClusterFuture ...
  [14:21:07.590] - result already collected: FutureResult
  [14:21:07.590] result() for ClusterFuture ... done
  [14:21:07.590] result() for ClusterFuture ...
  [14:21:07.591] - result already collected: FutureResult
  [14:21:07.591] result() for ClusterFuture ... done
  [14:21:07.607] ClusterFuture started
  <environment: 0x5574f956d5b8> 
  <environment: 0x5574f97fa610> 
  [14:21:07.656] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.657] - Validating connection of ClusterFuture
  [14:21:07.657] - received message: FutureResult
  [14:21:07.657] - Received FutureResult
  [14:21:07.658] - Erased future from FutureRegistry
  [14:21:07.658] result() for ClusterFuture ...
  [14:21:07.658] - result already collected: FutureResult
  [14:21:07.659] result() for ClusterFuture ... done
  [14:21:07.659] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:21:07.662] resolve() on environment ...
  [14:21:07.662]  recursive: 0
  [14:21:07.664]  elements: [4] 'a', 'b', 'c', 'd'
  [14:21:07.664] signalConditionsASAP(numeric, pos=1) ...
  [14:21:07.664] - nx: 4
  [14:21:07.665] - relay: TRUE
  [14:21:07.665] - stdout: TRUE
  [14:21:07.665] - signal: TRUE
  [14:21:07.666] - resignal: FALSE
  [14:21:07.666] - force: TRUE
  [14:21:07.666] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.667] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.667]  - until=2
  [14:21:07.667]  - relaying element #2
  [14:21:07.668] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:07.668] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.668] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:07.669]  length: 3 (resolved future 1)
  [14:21:07.669] Future #2
  [14:21:07.669] result() for ClusterFuture ...
  [14:21:07.670] - result already collected: FutureResult
  [14:21:07.670] result() for ClusterFuture ... done
  [14:21:07.670] result() for ClusterFuture ...
  [14:21:07.671] - result already collected: FutureResult
  [14:21:07.671] result() for ClusterFuture ... done
  [14:21:07.671] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:21:07.672] - nx: 4
  [14:21:07.672] - relay: TRUE
  [14:21:07.672] - stdout: TRUE
  [14:21:07.673] - signal: TRUE
  [14:21:07.673] - resignal: FALSE
  [14:21:07.673] - force: TRUE
  [14:21:07.673] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:07.674] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.674]  - until=2
  [14:21:07.674]  - relaying element #2
  [14:21:07.675] result() for ClusterFuture ...
  [14:21:07.675] - result already collected: FutureResult
  [14:21:07.675] result() for ClusterFuture ... done
  [14:21:07.676] result() for ClusterFuture ...
  [14:21:07.676] - result already collected: FutureResult
  [14:21:07.676] result() for ClusterFuture ... done
  [14:21:07.677] result() for ClusterFuture ...
  [14:21:07.677] - result already collected: FutureResult
  [14:21:07.677] result() for ClusterFuture ... done
  [14:21:07.678] result() for ClusterFuture ...
  [14:21:07.678] - result already collected: FutureResult
  [14:21:07.678] result() for ClusterFuture ... done
  [14:21:07.679] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:07.679] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:07.679] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:21:07.680]  length: 2 (resolved future 2)
  [14:21:07.680] Future #3
  [14:21:07.680] result() for ClusterFuture ...
  [14:21:07.681] - result already collected: FutureResult
  [14:21:07.681] result() for ClusterFuture ... done
  [14:21:07.681] result() for ClusterFuture ...
  [14:21:07.682] - result already collected: FutureResult
  [14:21:07.682] result() for ClusterFuture ... done
  [14:21:07.699] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:21:07.699] - nx: 4
  [14:21:07.699] - relay: TRUE
  [14:21:07.700] - stdout: TRUE
  [14:21:07.700] - signal: TRUE
  [14:21:07.700] - resignal: FALSE
  [14:21:07.700] - force: TRUE
  [14:21:07.701] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:07.701] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:07.701]  - until=3
  [14:21:07.706]  - relaying element #3
  [14:21:07.707] result() for ClusterFuture ...
  [14:21:07.707] - result already collected: FutureResult
  [14:21:07.707] result() for ClusterFuture ... done
  [14:21:07.708] result() for ClusterFuture ...
  [14:21:07.708] - result already collected: FutureResult
  [14:21:07.709] result() for ClusterFuture ... done
  [14:21:07.709] result() for ClusterFuture ...
  [14:21:07.709] - result already collected: FutureResult
  [14:21:07.710] result() for ClusterFuture ... done
  [14:21:07.710] result() for ClusterFuture ...
  [14:21:07.710] - result already collected: FutureResult
  [14:21:07.711] result() for ClusterFuture ... done
  [14:21:07.711] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:07.711] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:07.712] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:21:07.712]  length: 1 (resolved future 3)
  [14:21:07.713] Future #4
  [14:21:07.713] result() for ClusterFuture ...
  [14:21:07.713] - result already collected: FutureResult
  [14:21:07.714] result() for ClusterFuture ... done
  [14:21:07.714] result() for ClusterFuture ...
  [14:21:07.714] - result already collected: FutureResult
  [14:21:07.731] result() for ClusterFuture ... done
  [14:21:07.731] signalConditionsASAP(ClusterFuture, pos=4) ...
  [14:21:07.732] - nx: 4
  [14:21:07.732] - relay: TRUE
  [14:21:07.732] - stdout: TRUE
  [14:21:07.732] - signal: TRUE
  [14:21:07.733] - resignal: FALSE
  [14:21:07.733] - force: TRUE
  [14:21:07.733] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:07.734] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:07.734]  - until=4
  [14:21:07.734]  - relaying element #4
  [14:21:07.735] result() for ClusterFuture ...
  [14:21:07.735] - result already collected: FutureResult
  [14:21:07.735] result() for ClusterFuture ... done
  [14:21:07.736] result() for ClusterFuture ...
  [14:21:07.736] - result already collected: FutureResult
  [14:21:07.736] result() for ClusterFuture ... done
  [14:21:07.737] result() for ClusterFuture ...
  [14:21:07.737] - result already collected: FutureResult
  [14:21:07.737] result() for ClusterFuture ... done
  [14:21:07.738] result() for ClusterFuture ...
  [14:21:07.738] - result already collected: FutureResult
  [14:21:07.738] result() for ClusterFuture ... done
  [14:21:07.738] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.739] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:07.739] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [14:21:07.739]  length: 0 (resolved future 4)
  [14:21:07.740] Relaying remaining futures
  [14:21:07.740] signalConditionsASAP(NULL, pos=0) ...
  [14:21:07.740] - nx: 4
  [14:21:07.740] - relay: TRUE
  [14:21:07.741] - stdout: TRUE
  [14:21:07.741] - signal: TRUE
  [14:21:07.741] - resignal: FALSE
  [14:21:07.742] - force: TRUE
  [14:21:07.742] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.742] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:21:07.743] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:07.743] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:07.743] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:07.744] resolve() on environment ... DONE
  [14:21:07.744] result() for ClusterFuture ...
  [14:21:07.744] - result already collected: FutureResult
  [14:21:07.745] result() for ClusterFuture ... done
  [14:21:07.745] result() for ClusterFuture ...
  [14:21:07.745] - result already collected: FutureResult
  [14:21:07.746] result() for ClusterFuture ... done
  [14:21:07.746] result() for ClusterFuture ...
  [14:21:07.763] - result already collected: FutureResult
  [14:21:07.763] result() for ClusterFuture ... done
  [14:21:07.763] result() for ClusterFuture ...
  [14:21:07.764] - result already collected: FutureResult
  [14:21:07.764] result() for ClusterFuture ... done
  [14:21:07.764] result() for ClusterFuture ...
  [14:21:07.765] - result already collected: FutureResult
  [14:21:07.765] result() for ClusterFuture ... done
  [14:21:07.765] result() for ClusterFuture ...
  [14:21:07.766] - result already collected: FutureResult
  [14:21:07.766] result() for ClusterFuture ... done
  <environment: 0x5574fa0db4f0> 
  Dimensions: c(2, 1, 3, 1)
  [14:21:07.772] getGlobalsAndPackages() ...
  [14:21:07.773] Searching for globals...
  [14:21:07.773] 
  [14:21:07.774] Searching for globals ... DONE
  [14:21:07.774] - globals: [0] <none>
  [14:21:07.774] getGlobalsAndPackages() ... DONE
  [14:21:07.778] Packages needed by the future expression (n = 0): <none>
  [14:21:07.779] Packages needed by future strategies (n = 0): <none>
  [14:21:07.784] {
  [14:21:07.784]     {
  [14:21:07.784]         ...future.startTime <- base::Sys.time()
  [14:21:07.784]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.784]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.784]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.784]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.784]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.784]         {
  [14:21:07.784]             {
  [14:21:07.784]                 has_future <- base::requireNamespace("future", 
  [14:21:07.784]                   quietly = TRUE)
  [14:21:07.784]                 version <- if (has_future) 
  [14:21:07.784]                   utils::packageVersion("future")
  [14:21:07.784]                 else NULL
  [14:21:07.784]                 if (!has_future || version < "1.8.0") {
  [14:21:07.784]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.784]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.784]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.784]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.784]                       "release", "version")], collapse = " "), 
  [14:21:07.784]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.784]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.784]                     info)
  [14:21:07.784]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.784]                   if (!has_future) {
  [14:21:07.784]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.784]                       info)
  [14:21:07.784]                   }
  [14:21:07.784]                   else {
  [14:21:07.784]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.784]                       info, version)
  [14:21:07.784]                   }
  [14:21:07.784]                   base::stop(msg)
  [14:21:07.784]                 }
  [14:21:07.784]             }
  [14:21:07.784]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.784]         }
  [14:21:07.784]     }
  [14:21:07.784]     if (base::is.na(TRUE)) {
  [14:21:07.784]     }
  [14:21:07.784]     else {
  [14:21:07.784]         if (TRUE) {
  [14:21:07.784]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.784]                 open = "w")
  [14:21:07.784]         }
  [14:21:07.784]         else {
  [14:21:07.784]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.784]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.784]         }
  [14:21:07.784]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.784]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.784]             base::sink(type = "output", split = FALSE)
  [14:21:07.784]             base::close(...future.stdout)
  [14:21:07.784]         }, add = TRUE)
  [14:21:07.784]     }
  [14:21:07.784]     ...future.frame <- base::sys.nframe()
  [14:21:07.784]     ...future.conditions <- base::list()
  [14:21:07.784]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.784]     ...future.result <- base::tryCatch({
  [14:21:07.784]         base::withCallingHandlers({
  [14:21:07.784]             ...future.value <- base::withVisible(base::local({
  [14:21:07.784]                 ...future.sendCondition <- local({
  [14:21:07.784]                   sendCondition <- NULL
  [14:21:07.784]                   function(frame = 1L) {
  [14:21:07.784]                     if (is.function(sendCondition)) 
  [14:21:07.784]                       return(sendCondition)
  [14:21:07.784]                     ns <- getNamespace("parallel")
  [14:21:07.784]                     if (exists("sendData", mode = "function", 
  [14:21:07.784]                       envir = ns)) {
  [14:21:07.784]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.784]                         envir = ns)
  [14:21:07.784]                       envir <- sys.frame(frame)
  [14:21:07.784]                       master <- NULL
  [14:21:07.784]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.784]                         !identical(envir, emptyenv())) {
  [14:21:07.784]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.784]                           inherits = FALSE)) {
  [14:21:07.784]                           master <- get("master", mode = "list", 
  [14:21:07.784]                             envir = envir, inherits = FALSE)
  [14:21:07.784]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.784]                             sendCondition <<- function(cond) {
  [14:21:07.784]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.784]                                 success = TRUE)
  [14:21:07.784]                               parallel_sendData(master, data)
  [14:21:07.784]                             }
  [14:21:07.784]                             return(sendCondition)
  [14:21:07.784]                           }
  [14:21:07.784]                         }
  [14:21:07.784]                         frame <- frame + 1L
  [14:21:07.784]                         envir <- sys.frame(frame)
  [14:21:07.784]                       }
  [14:21:07.784]                     }
  [14:21:07.784]                     sendCondition <<- function(cond) NULL
  [14:21:07.784]                   }
  [14:21:07.784]                 })
  [14:21:07.784]                 withCallingHandlers({
  [14:21:07.784]                   2
  [14:21:07.784]                 }, immediateCondition = function(cond) {
  [14:21:07.784]                   sendCondition <- ...future.sendCondition()
  [14:21:07.784]                   sendCondition(cond)
  [14:21:07.784]                   muffleCondition <- function (cond) 
  [14:21:07.784]                   {
  [14:21:07.784]                     inherits <- base::inherits
  [14:21:07.784]                     invokeRestart <- base::invokeRestart
  [14:21:07.784]                     muffled <- FALSE
  [14:21:07.784]                     if (inherits(cond, "message")) {
  [14:21:07.784]                       invokeRestart("muffleMessage")
  [14:21:07.784]                       muffled <- TRUE
  [14:21:07.784]                     }
  [14:21:07.784]                     else if (inherits(cond, "warning")) {
  [14:21:07.784]                       invokeRestart("muffleWarning")
  [14:21:07.784]                       muffled <- TRUE
  [14:21:07.784]                     }
  [14:21:07.784]                     else if (inherits(cond, "condition")) {
  [14:21:07.784]                       computeRestarts <- base::computeRestarts
  [14:21:07.784]                       grepl <- base::grepl
  [14:21:07.784]                       is.null <- base::is.null
  [14:21:07.784]                       restarts <- computeRestarts(cond)
  [14:21:07.784]                       for (restart in restarts) {
  [14:21:07.784]                         name <- restart$name
  [14:21:07.784]                         if (is.null(name)) 
  [14:21:07.784]                           next
  [14:21:07.784]                         if (!grepl("^muffle", name)) 
  [14:21:07.784]                           next
  [14:21:07.784]                         invokeRestart(restart)
  [14:21:07.784]                         muffled <- TRUE
  [14:21:07.784]                         break
  [14:21:07.784]                       }
  [14:21:07.784]                     }
  [14:21:07.784]                     invisible(muffled)
  [14:21:07.784]                   }
  [14:21:07.784]                   muffleCondition(cond)
  [14:21:07.784]                 })
  [14:21:07.784]             }))
  [14:21:07.784]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.784]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.784]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.784]                 version = "1.8")
  [14:21:07.784]         }, condition = base::local({
  [14:21:07.784]             c <- base::c
  [14:21:07.784]             inherits <- base::inherits
  [14:21:07.784]             invokeRestart <- base::invokeRestart
  [14:21:07.784]             length <- base::length
  [14:21:07.784]             list <- base::list
  [14:21:07.784]             seq.int <- base::seq.int
  [14:21:07.784]             signalCondition <- base::signalCondition
  [14:21:07.784]             sys.calls <- base::sys.calls
  [14:21:07.784]             Sys.time <- base::Sys.time
  [14:21:07.784]             `[[` <- base::`[[`
  [14:21:07.784]             `+` <- base::`+`
  [14:21:07.784]             `<<-` <- base::`<<-`
  [14:21:07.784]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.784]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.784]                   3L)]
  [14:21:07.784]             }
  [14:21:07.784]             function(cond) {
  [14:21:07.784]                 if (inherits(cond, "error")) {
  [14:21:07.784]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.784]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.784]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.784]                   signalCondition(cond)
  [14:21:07.784]                 }
  [14:21:07.784]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.784]                 ))) {
  [14:21:07.784]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.784]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.784]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.784]                   if (!signal) {
  [14:21:07.784]                     muffleCondition <- function (cond) 
  [14:21:07.784]                     {
  [14:21:07.784]                       inherits <- base::inherits
  [14:21:07.784]                       invokeRestart <- base::invokeRestart
  [14:21:07.784]                       muffled <- FALSE
  [14:21:07.784]                       if (inherits(cond, "message")) {
  [14:21:07.784]                         invokeRestart("muffleMessage")
  [14:21:07.784]                         muffled <- TRUE
  [14:21:07.784]                       }
  [14:21:07.784]                       else if (inherits(cond, "warning")) {
  [14:21:07.784]                         invokeRestart("muffleWarning")
  [14:21:07.784]                         muffled <- TRUE
  [14:21:07.784]                       }
  [14:21:07.784]                       else if (inherits(cond, "condition")) {
  [14:21:07.784]                         computeRestarts <- base::computeRestarts
  [14:21:07.784]                         grepl <- base::grepl
  [14:21:07.784]                         is.null <- base::is.null
  [14:21:07.784]                         restarts <- computeRestarts(cond)
  [14:21:07.784]                         for (restart in restarts) {
  [14:21:07.784]                           name <- restart$name
  [14:21:07.784]                           if (is.null(name)) 
  [14:21:07.784]                             next
  [14:21:07.784]                           if (!grepl("^muffle", name)) 
  [14:21:07.784]                             next
  [14:21:07.784]                           invokeRestart(restart)
  [14:21:07.784]                           muffled <- TRUE
  [14:21:07.784]                           break
  [14:21:07.784]                         }
  [14:21:07.784]                       }
  [14:21:07.784]                       invisible(muffled)
  [14:21:07.784]                     }
  [14:21:07.784]                     muffleCondition(cond)
  [14:21:07.784]                   }
  [14:21:07.784]                 }
  [14:21:07.784]             }
  [14:21:07.784]         }))
  [14:21:07.784]     }, error = function(ex) {
  [14:21:07.784]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.784]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.784]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.784]     }, finally = {
  [14:21:07.784]         {
  [14:21:07.784]             NULL
  [14:21:07.784]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.784]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.784]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.784]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.784]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.784]                 ...) 
  [14:21:07.784]             {
  [14:21:07.784]                 if (substitute) 
  [14:21:07.784]                   expr <- substitute(expr)
  [14:21:07.784]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.784]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.784]                   globals = globals, persistent = persistent, 
  [14:21:07.784]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.784]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.784]                   label = label, ...)
  [14:21:07.784]                 if (!future$lazy) 
  [14:21:07.784]                   future <- run(future)
  [14:21:07.784]                 invisible(future)
  [14:21:07.784]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.784]         }
  [14:21:07.784]         base::options(...future.oldOptions)
  [14:21:07.784]     })
  [14:21:07.784]     Sys.time
  [14:21:07.784]     if (base::is.na(TRUE)) {
  [14:21:07.784]     }
  [14:21:07.784]     else {
  [14:21:07.784]         base::sink(type = "output", split = FALSE)
  [14:21:07.784]         if (TRUE) {
  [14:21:07.784]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.784]         }
  [14:21:07.784]         else {
  [14:21:07.784]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.784]         }
  [14:21:07.784]         base::close(...future.stdout)
  [14:21:07.784]         ...future.stdout <- NULL
  [14:21:07.784]     }
  [14:21:07.784]     ...future.result$conditions <- ...future.conditions
  [14:21:07.784]     ...future.result
  [14:21:07.784] }
  [14:21:07.792] ClusterFuture started
  [14:21:07.797] getGlobalsAndPackages() ...
  [14:21:07.798] Searching for globals...
  [14:21:07.799] 
  [14:21:07.799] Searching for globals ... DONE
  [14:21:07.799] - globals: [0] <none>
  [14:21:07.799] getGlobalsAndPackages() ... DONE
  [14:21:07.803] Packages needed by the future expression (n = 0): <none>
  [14:21:07.804] Packages needed by future strategies (n = 0): <none>
  [14:21:07.814] {
  [14:21:07.814]     {
  [14:21:07.814]         ...future.startTime <- base::Sys.time()
  [14:21:07.814]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.814]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.814]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.814]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.814]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.814]         {
  [14:21:07.814]             {
  [14:21:07.814]                 has_future <- base::requireNamespace("future", 
  [14:21:07.814]                   quietly = TRUE)
  [14:21:07.814]                 version <- if (has_future) 
  [14:21:07.814]                   utils::packageVersion("future")
  [14:21:07.814]                 else NULL
  [14:21:07.814]                 if (!has_future || version < "1.8.0") {
  [14:21:07.814]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.814]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.814]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.814]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.814]                       "release", "version")], collapse = " "), 
  [14:21:07.814]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.814]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.814]                     info)
  [14:21:07.814]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.814]                   if (!has_future) {
  [14:21:07.814]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.814]                       info)
  [14:21:07.814]                   }
  [14:21:07.814]                   else {
  [14:21:07.814]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.814]                       info, version)
  [14:21:07.814]                   }
  [14:21:07.814]                   base::stop(msg)
  [14:21:07.814]                 }
  [14:21:07.814]             }
  [14:21:07.814]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.814]         }
  [14:21:07.814]     }
  [14:21:07.814]     if (base::is.na(TRUE)) {
  [14:21:07.814]     }
  [14:21:07.814]     else {
  [14:21:07.814]         if (TRUE) {
  [14:21:07.814]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.814]                 open = "w")
  [14:21:07.814]         }
  [14:21:07.814]         else {
  [14:21:07.814]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.814]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.814]         }
  [14:21:07.814]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.814]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.814]             base::sink(type = "output", split = FALSE)
  [14:21:07.814]             base::close(...future.stdout)
  [14:21:07.814]         }, add = TRUE)
  [14:21:07.814]     }
  [14:21:07.814]     ...future.frame <- base::sys.nframe()
  [14:21:07.814]     ...future.conditions <- base::list()
  [14:21:07.814]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.814]     ...future.result <- base::tryCatch({
  [14:21:07.814]         base::withCallingHandlers({
  [14:21:07.814]             ...future.value <- base::withVisible(base::local({
  [14:21:07.814]                 ...future.sendCondition <- local({
  [14:21:07.814]                   sendCondition <- NULL
  [14:21:07.814]                   function(frame = 1L) {
  [14:21:07.814]                     if (is.function(sendCondition)) 
  [14:21:07.814]                       return(sendCondition)
  [14:21:07.814]                     ns <- getNamespace("parallel")
  [14:21:07.814]                     if (exists("sendData", mode = "function", 
  [14:21:07.814]                       envir = ns)) {
  [14:21:07.814]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.814]                         envir = ns)
  [14:21:07.814]                       envir <- sys.frame(frame)
  [14:21:07.814]                       master <- NULL
  [14:21:07.814]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.814]                         !identical(envir, emptyenv())) {
  [14:21:07.814]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.814]                           inherits = FALSE)) {
  [14:21:07.814]                           master <- get("master", mode = "list", 
  [14:21:07.814]                             envir = envir, inherits = FALSE)
  [14:21:07.814]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.814]                             sendCondition <<- function(cond) {
  [14:21:07.814]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.814]                                 success = TRUE)
  [14:21:07.814]                               parallel_sendData(master, data)
  [14:21:07.814]                             }
  [14:21:07.814]                             return(sendCondition)
  [14:21:07.814]                           }
  [14:21:07.814]                         }
  [14:21:07.814]                         frame <- frame + 1L
  [14:21:07.814]                         envir <- sys.frame(frame)
  [14:21:07.814]                       }
  [14:21:07.814]                     }
  [14:21:07.814]                     sendCondition <<- function(cond) NULL
  [14:21:07.814]                   }
  [14:21:07.814]                 })
  [14:21:07.814]                 withCallingHandlers({
  [14:21:07.814]                   NULL
  [14:21:07.814]                 }, immediateCondition = function(cond) {
  [14:21:07.814]                   sendCondition <- ...future.sendCondition()
  [14:21:07.814]                   sendCondition(cond)
  [14:21:07.814]                   muffleCondition <- function (cond) 
  [14:21:07.814]                   {
  [14:21:07.814]                     inherits <- base::inherits
  [14:21:07.814]                     invokeRestart <- base::invokeRestart
  [14:21:07.814]                     muffled <- FALSE
  [14:21:07.814]                     if (inherits(cond, "message")) {
  [14:21:07.814]                       invokeRestart("muffleMessage")
  [14:21:07.814]                       muffled <- TRUE
  [14:21:07.814]                     }
  [14:21:07.814]                     else if (inherits(cond, "warning")) {
  [14:21:07.814]                       invokeRestart("muffleWarning")
  [14:21:07.814]                       muffled <- TRUE
  [14:21:07.814]                     }
  [14:21:07.814]                     else if (inherits(cond, "condition")) {
  [14:21:07.814]                       computeRestarts <- base::computeRestarts
  [14:21:07.814]                       grepl <- base::grepl
  [14:21:07.814]                       is.null <- base::is.null
  [14:21:07.814]                       restarts <- computeRestarts(cond)
  [14:21:07.814]                       for (restart in restarts) {
  [14:21:07.814]                         name <- restart$name
  [14:21:07.814]                         if (is.null(name)) 
  [14:21:07.814]                           next
  [14:21:07.814]                         if (!grepl("^muffle", name)) 
  [14:21:07.814]                           next
  [14:21:07.814]                         invokeRestart(restart)
  [14:21:07.814]                         muffled <- TRUE
  [14:21:07.814]                         break
  [14:21:07.814]                       }
  [14:21:07.814]                     }
  [14:21:07.814]                     invisible(muffled)
  [14:21:07.814]                   }
  [14:21:07.814]                   muffleCondition(cond)
  [14:21:07.814]                 })
  [14:21:07.814]             }))
  [14:21:07.814]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.814]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.814]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.814]                 version = "1.8")
  [14:21:07.814]         }, condition = base::local({
  [14:21:07.814]             c <- base::c
  [14:21:07.814]             inherits <- base::inherits
  [14:21:07.814]             invokeRestart <- base::invokeRestart
  [14:21:07.814]             length <- base::length
  [14:21:07.814]             list <- base::list
  [14:21:07.814]             seq.int <- base::seq.int
  [14:21:07.814]             signalCondition <- base::signalCondition
  [14:21:07.814]             sys.calls <- base::sys.calls
  [14:21:07.814]             Sys.time <- base::Sys.time
  [14:21:07.814]             `[[` <- base::`[[`
  [14:21:07.814]             `+` <- base::`+`
  [14:21:07.814]             `<<-` <- base::`<<-`
  [14:21:07.814]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.814]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.814]                   3L)]
  [14:21:07.814]             }
  [14:21:07.814]             function(cond) {
  [14:21:07.814]                 if (inherits(cond, "error")) {
  [14:21:07.814]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.814]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.814]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.814]                   signalCondition(cond)
  [14:21:07.814]                 }
  [14:21:07.814]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.814]                 ))) {
  [14:21:07.814]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.814]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.814]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.814]                   if (!signal) {
  [14:21:07.814]                     muffleCondition <- function (cond) 
  [14:21:07.814]                     {
  [14:21:07.814]                       inherits <- base::inherits
  [14:21:07.814]                       invokeRestart <- base::invokeRestart
  [14:21:07.814]                       muffled <- FALSE
  [14:21:07.814]                       if (inherits(cond, "message")) {
  [14:21:07.814]                         invokeRestart("muffleMessage")
  [14:21:07.814]                         muffled <- TRUE
  [14:21:07.814]                       }
  [14:21:07.814]                       else if (inherits(cond, "warning")) {
  [14:21:07.814]                         invokeRestart("muffleWarning")
  [14:21:07.814]                         muffled <- TRUE
  [14:21:07.814]                       }
  [14:21:07.814]                       else if (inherits(cond, "condition")) {
  [14:21:07.814]                         computeRestarts <- base::computeRestarts
  [14:21:07.814]                         grepl <- base::grepl
  [14:21:07.814]                         is.null <- base::is.null
  [14:21:07.814]                         restarts <- computeRestarts(cond)
  [14:21:07.814]                         for (restart in restarts) {
  [14:21:07.814]                           name <- restart$name
  [14:21:07.814]                           if (is.null(name)) 
  [14:21:07.814]                             next
  [14:21:07.814]                           if (!grepl("^muffle", name)) 
  [14:21:07.814]                             next
  [14:21:07.814]                           invokeRestart(restart)
  [14:21:07.814]                           muffled <- TRUE
  [14:21:07.814]                           break
  [14:21:07.814]                         }
  [14:21:07.814]                       }
  [14:21:07.814]                       invisible(muffled)
  [14:21:07.814]                     }
  [14:21:07.814]                     muffleCondition(cond)
  [14:21:07.814]                   }
  [14:21:07.814]                 }
  [14:21:07.814]             }
  [14:21:07.814]         }))
  [14:21:07.814]     }, error = function(ex) {
  [14:21:07.814]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.814]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.814]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.814]     }, finally = {
  [14:21:07.814]         {
  [14:21:07.814]             NULL
  [14:21:07.814]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.814]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.814]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.814]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.814]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.814]                 ...) 
  [14:21:07.814]             {
  [14:21:07.814]                 if (substitute) 
  [14:21:07.814]                   expr <- substitute(expr)
  [14:21:07.814]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.814]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.814]                   globals = globals, persistent = persistent, 
  [14:21:07.814]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.814]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.814]                   label = label, ...)
  [14:21:07.814]                 if (!future$lazy) 
  [14:21:07.814]                   future <- run(future)
  [14:21:07.814]                 invisible(future)
  [14:21:07.814]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.814]         }
  [14:21:07.814]         base::options(...future.oldOptions)
  [14:21:07.814]     })
  [14:21:07.814]     Sys.time
  [14:21:07.814]     if (base::is.na(TRUE)) {
  [14:21:07.814]     }
  [14:21:07.814]     else {
  [14:21:07.814]         base::sink(type = "output", split = FALSE)
  [14:21:07.814]         if (TRUE) {
  [14:21:07.814]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.814]         }
  [14:21:07.814]         else {
  [14:21:07.814]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.814]         }
  [14:21:07.814]         base::close(...future.stdout)
  [14:21:07.814]         ...future.stdout <- NULL
  [14:21:07.814]     }
  [14:21:07.814]     ...future.result$conditions <- ...future.conditions
  [14:21:07.814]     ...future.result
  [14:21:07.814] }
  [14:21:07.821] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.840] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.840] - Validating connection of ClusterFuture
  [14:21:07.841] - received message: FutureResult
  [14:21:07.841] - Received FutureResult
  [14:21:07.842] - Erased future from FutureRegistry
  [14:21:07.842] result() for ClusterFuture ...
  [14:21:07.842] - result already collected: FutureResult
  [14:21:07.843] result() for ClusterFuture ... done
  [14:21:07.843] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.844] result() for ClusterFuture ...
  [14:21:07.844] - result already collected: FutureResult
  [14:21:07.844] result() for ClusterFuture ... done
  [14:21:07.845] result() for ClusterFuture ...
  [14:21:07.845] - result already collected: FutureResult
  [14:21:07.845] result() for ClusterFuture ... done
  [14:21:07.848] ClusterFuture started
  [14:21:07.854] getGlobalsAndPackages() ...
  [14:21:07.871] Searching for globals...
  [14:21:07.872] - globals found: [1] '{'
  [14:21:07.873] Searching for globals ... DONE
  [14:21:07.873] Resolving globals: FALSE
  [14:21:07.874] 
  [14:21:07.874] 
  [14:21:07.875] getGlobalsAndPackages() ... DONE
  [14:21:07.878] Packages needed by the future expression (n = 0): <none>
  [14:21:07.879] Packages needed by future strategies (n = 0): <none>
  [14:21:07.884] {
  [14:21:07.884]     {
  [14:21:07.884]         ...future.startTime <- base::Sys.time()
  [14:21:07.884]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:07.884]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:07.884]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:07.884]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:07.884]             future.resolve.recursive = NULL, width = 80L)
  [14:21:07.884]         {
  [14:21:07.884]             {
  [14:21:07.884]                 has_future <- base::requireNamespace("future", 
  [14:21:07.884]                   quietly = TRUE)
  [14:21:07.884]                 version <- if (has_future) 
  [14:21:07.884]                   utils::packageVersion("future")
  [14:21:07.884]                 else NULL
  [14:21:07.884]                 if (!has_future || version < "1.8.0") {
  [14:21:07.884]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:07.884]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:07.884]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:07.884]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:07.884]                       "release", "version")], collapse = " "), 
  [14:21:07.884]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:07.884]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:07.884]                     info)
  [14:21:07.884]                   info <- base::paste(info, collapse = "; ")
  [14:21:07.884]                   if (!has_future) {
  [14:21:07.884]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:07.884]                       info)
  [14:21:07.884]                   }
  [14:21:07.884]                   else {
  [14:21:07.884]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:07.884]                       info, version)
  [14:21:07.884]                   }
  [14:21:07.884]                   base::stop(msg)
  [14:21:07.884]                 }
  [14:21:07.884]             }
  [14:21:07.884]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:07.884]         }
  [14:21:07.884]     }
  [14:21:07.884]     if (base::is.na(TRUE)) {
  [14:21:07.884]     }
  [14:21:07.884]     else {
  [14:21:07.884]         if (TRUE) {
  [14:21:07.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:07.884]                 open = "w")
  [14:21:07.884]         }
  [14:21:07.884]         else {
  [14:21:07.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:07.884]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:07.884]         }
  [14:21:07.884]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:07.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:07.884]             base::sink(type = "output", split = FALSE)
  [14:21:07.884]             base::close(...future.stdout)
  [14:21:07.884]         }, add = TRUE)
  [14:21:07.884]     }
  [14:21:07.884]     ...future.frame <- base::sys.nframe()
  [14:21:07.884]     ...future.conditions <- base::list()
  [14:21:07.884]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:07.884]     ...future.result <- base::tryCatch({
  [14:21:07.884]         base::withCallingHandlers({
  [14:21:07.884]             ...future.value <- base::withVisible(base::local({
  [14:21:07.884]                 ...future.sendCondition <- local({
  [14:21:07.884]                   sendCondition <- NULL
  [14:21:07.884]                   function(frame = 1L) {
  [14:21:07.884]                     if (is.function(sendCondition)) 
  [14:21:07.884]                       return(sendCondition)
  [14:21:07.884]                     ns <- getNamespace("parallel")
  [14:21:07.884]                     if (exists("sendData", mode = "function", 
  [14:21:07.884]                       envir = ns)) {
  [14:21:07.884]                       parallel_sendData <- get("sendData", mode = "function", 
  [14:21:07.884]                         envir = ns)
  [14:21:07.884]                       envir <- sys.frame(frame)
  [14:21:07.884]                       master <- NULL
  [14:21:07.884]                       while (!identical(envir, .GlobalEnv) && 
  [14:21:07.884]                         !identical(envir, emptyenv())) {
  [14:21:07.884]                         if (exists("master", mode = "list", envir = envir, 
  [14:21:07.884]                           inherits = FALSE)) {
  [14:21:07.884]                           master <- get("master", mode = "list", 
  [14:21:07.884]                             envir = envir, inherits = FALSE)
  [14:21:07.884]                           if (inherits(master, "SOCKnode")) {
  [14:21:07.884]                             sendCondition <<- function(cond) {
  [14:21:07.884]                               data <- list(type = "VALUE", value = cond, 
  [14:21:07.884]                                 success = TRUE)
  [14:21:07.884]                               parallel_sendData(master, data)
  [14:21:07.884]                             }
  [14:21:07.884]                             return(sendCondition)
  [14:21:07.884]                           }
  [14:21:07.884]                         }
  [14:21:07.884]                         frame <- frame + 1L
  [14:21:07.884]                         envir <- sys.frame(frame)
  [14:21:07.884]                       }
  [14:21:07.884]                     }
  [14:21:07.884]                     sendCondition <<- function(cond) NULL
  [14:21:07.884]                   }
  [14:21:07.884]                 })
  [14:21:07.884]                 withCallingHandlers({
  [14:21:07.884]                   {
  [14:21:07.884]                     4
  [14:21:07.884]                   }
  [14:21:07.884]                 }, immediateCondition = function(cond) {
  [14:21:07.884]                   sendCondition <- ...future.sendCondition()
  [14:21:07.884]                   sendCondition(cond)
  [14:21:07.884]                   muffleCondition <- function (cond) 
  [14:21:07.884]                   {
  [14:21:07.884]                     inherits <- base::inherits
  [14:21:07.884]                     invokeRestart <- base::invokeRestart
  [14:21:07.884]                     muffled <- FALSE
  [14:21:07.884]                     if (inherits(cond, "message")) {
  [14:21:07.884]                       invokeRestart("muffleMessage")
  [14:21:07.884]                       muffled <- TRUE
  [14:21:07.884]                     }
  [14:21:07.884]                     else if (inherits(cond, "warning")) {
  [14:21:07.884]                       invokeRestart("muffleWarning")
  [14:21:07.884]                       muffled <- TRUE
  [14:21:07.884]                     }
  [14:21:07.884]                     else if (inherits(cond, "condition")) {
  [14:21:07.884]                       computeRestarts <- base::computeRestarts
  [14:21:07.884]                       grepl <- base::grepl
  [14:21:07.884]                       is.null <- base::is.null
  [14:21:07.884]                       restarts <- computeRestarts(cond)
  [14:21:07.884]                       for (restart in restarts) {
  [14:21:07.884]                         name <- restart$name
  [14:21:07.884]                         if (is.null(name)) 
  [14:21:07.884]                           next
  [14:21:07.884]                         if (!grepl("^muffle", name)) 
  [14:21:07.884]                           next
  [14:21:07.884]                         invokeRestart(restart)
  [14:21:07.884]                         muffled <- TRUE
  [14:21:07.884]                         break
  [14:21:07.884]                       }
  [14:21:07.884]                     }
  [14:21:07.884]                     invisible(muffled)
  [14:21:07.884]                   }
  [14:21:07.884]                   muffleCondition(cond)
  [14:21:07.884]                 })
  [14:21:07.884]             }))
  [14:21:07.884]             future::FutureResult(value = ...future.value$value, 
  [14:21:07.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.884]                   ...future.rng), started = ...future.startTime, 
  [14:21:07.884]                 version = "1.8")
  [14:21:07.884]         }, condition = base::local({
  [14:21:07.884]             c <- base::c
  [14:21:07.884]             inherits <- base::inherits
  [14:21:07.884]             invokeRestart <- base::invokeRestart
  [14:21:07.884]             length <- base::length
  [14:21:07.884]             list <- base::list
  [14:21:07.884]             seq.int <- base::seq.int
  [14:21:07.884]             signalCondition <- base::signalCondition
  [14:21:07.884]             sys.calls <- base::sys.calls
  [14:21:07.884]             Sys.time <- base::Sys.time
  [14:21:07.884]             `[[` <- base::`[[`
  [14:21:07.884]             `+` <- base::`+`
  [14:21:07.884]             `<<-` <- base::`<<-`
  [14:21:07.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:07.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:07.884]                   3L)]
  [14:21:07.884]             }
  [14:21:07.884]             function(cond) {
  [14:21:07.884]                 if (inherits(cond, "error")) {
  [14:21:07.884]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:07.884]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:07.884]                   signalCondition(cond)
  [14:21:07.884]                 }
  [14:21:07.884]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:07.884]                 ))) {
  [14:21:07.884]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:07.884]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:07.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:07.884]                   if (!signal) {
  [14:21:07.884]                     muffleCondition <- function (cond) 
  [14:21:07.884]                     {
  [14:21:07.884]                       inherits <- base::inherits
  [14:21:07.884]                       invokeRestart <- base::invokeRestart
  [14:21:07.884]                       muffled <- FALSE
  [14:21:07.884]                       if (inherits(cond, "message")) {
  [14:21:07.884]                         invokeRestart("muffleMessage")
  [14:21:07.884]                         muffled <- TRUE
  [14:21:07.884]                       }
  [14:21:07.884]                       else if (inherits(cond, "warning")) {
  [14:21:07.884]                         invokeRestart("muffleWarning")
  [14:21:07.884]                         muffled <- TRUE
  [14:21:07.884]                       }
  [14:21:07.884]                       else if (inherits(cond, "condition")) {
  [14:21:07.884]                         computeRestarts <- base::computeRestarts
  [14:21:07.884]                         grepl <- base::grepl
  [14:21:07.884]                         is.null <- base::is.null
  [14:21:07.884]                         restarts <- computeRestarts(cond)
  [14:21:07.884]                         for (restart in restarts) {
  [14:21:07.884]                           name <- restart$name
  [14:21:07.884]                           if (is.null(name)) 
  [14:21:07.884]                             next
  [14:21:07.884]                           if (!grepl("^muffle", name)) 
  [14:21:07.884]                             next
  [14:21:07.884]                           invokeRestart(restart)
  [14:21:07.884]                           muffled <- TRUE
  [14:21:07.884]                           break
  [14:21:07.884]                         }
  [14:21:07.884]                       }
  [14:21:07.884]                       invisible(muffled)
  [14:21:07.884]                     }
  [14:21:07.884]                     muffleCondition(cond)
  [14:21:07.884]                   }
  [14:21:07.884]                 }
  [14:21:07.884]             }
  [14:21:07.884]         }))
  [14:21:07.884]     }, error = function(ex) {
  [14:21:07.884]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:07.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:07.884]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:07.884]     }, finally = {
  [14:21:07.884]         {
  [14:21:07.884]             NULL
  [14:21:07.884]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:07.884]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:07.884]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [14:21:07.884]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [14:21:07.884]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [14:21:07.884]                 ...) 
  [14:21:07.884]             {
  [14:21:07.884]                 if (substitute) 
  [14:21:07.884]                   expr <- substitute(expr)
  [14:21:07.884]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [14:21:07.884]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:07.884]                   globals = globals, persistent = persistent, 
  [14:21:07.884]                   workers = workers, user = user, revtunnel = revtunnel, 
  [14:21:07.884]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [14:21:07.884]                   label = label, ...)
  [14:21:07.884]                 if (!future$lazy) 
  [14:21:07.884]                   future <- run(future)
  [14:21:07.884]                 invisible(future)
  [14:21:07.884]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:07.884]         }
  [14:21:07.884]         base::options(...future.oldOptions)
  [14:21:07.884]     })
  [14:21:07.884]     Sys.time
  [14:21:07.884]     if (base::is.na(TRUE)) {
  [14:21:07.884]     }
  [14:21:07.884]     else {
  [14:21:07.884]         base::sink(type = "output", split = FALSE)
  [14:21:07.884]         if (TRUE) {
  [14:21:07.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:07.884]         }
  [14:21:07.884]         else {
  [14:21:07.884]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:07.884]         }
  [14:21:07.884]         base::close(...future.stdout)
  [14:21:07.884]         ...future.stdout <- NULL
  [14:21:07.884]     }
  [14:21:07.884]     ...future.result$conditions <- ...future.conditions
  [14:21:07.884]     ...future.result
  [14:21:07.884] }
  [14:21:07.899] Poll #1 (0): usedNodes() = 1, workers = 1
  [14:21:07.911] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.911] - Validating connection of ClusterFuture
  [14:21:07.912] - received message: FutureResult
  [14:21:07.912] - Received FutureResult
  [14:21:07.912] - Erased future from FutureRegistry
  [14:21:07.913] result() for ClusterFuture ...
  [14:21:07.913] - result already collected: FutureResult
  [14:21:07.913] result() for ClusterFuture ... done
  [14:21:07.914] receiveMessageFromWorker() for ClusterFuture ... done
  [14:21:07.914] result() for ClusterFuture ...
  [14:21:07.915] - result already collected: FutureResult
  [14:21:07.915] result() for ClusterFuture ... done
  [14:21:07.916] result() for ClusterFuture ...
  [14:21:07.916] - result already collected: FutureResult
  [14:21:07.917] result() for ClusterFuture ... done
  [14:21:07.936] ClusterFuture started
  <environment: 0x5574f9193c18> 
  <environment: 0x5574fa231a38> 
  [14:21:07.984] receiveMessageFromWorker() for ClusterFuture ...
  [14:21:07.985] - Validating connection of ClusterFuture
  [14:21:07.985] - received message: FutureResult
  [14:21:07.986] - Received FutureResult
  [14:21:07.986] - Erased future from FutureRegistry
  [14:21:07.986] result() for ClusterFuture ...
  [14:21:07.987] - result already collected: FutureResult
  [14:21:07.987] result() for ClusterFuture ... done
  [14:21:07.988] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [14:21:07.991] resolve() on environment ...
  [14:21:07.991]  recursive: 0
  [14:21:07.993]  elements: [4] 'a', 'b', 'c', 'd'
  [14:21:07.993] signalConditionsASAP(numeric, pos=1) ...
  [14:21:07.994] - nx: 4
  [14:21:07.994] - relay: TRUE
  [14:21:07.994] - stdout: TRUE
  [14:21:07.995] - signal: TRUE
  [14:21:07.995] - resignal: FALSE
  [14:21:07.995] - force: TRUE
  [14:21:07.996] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.996] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.996]  - until=2
  [14:21:07.997]  - relaying element #2
  [14:21:07.997] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:07.997] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:07.998] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:07.998]  length: 3 (resolved future 1)
  [14:21:07.999] Future #2
  [14:21:07.999] result() for ClusterFuture ...
  [14:21:07.999] - result already collected: FutureResult
  [14:21:08.000] result() for ClusterFuture ... done
  [14:21:08.000] result() for ClusterFuture ...
  [14:21:08.000] - result already collected: FutureResult
  [14:21:08.001] result() for ClusterFuture ... done
  [14:21:08.007] signalConditionsASAP(ClusterFuture, pos=2) ...
  [14:21:08.007] - nx: 4
  [14:21:08.008] - relay: TRUE
  [14:21:08.008] - stdout: TRUE
  [14:21:08.008] - signal: TRUE
  [14:21:08.009] - resignal: FALSE
  [14:21:08.009] - force: TRUE
  [14:21:08.009] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [14:21:08.010] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [14:21:08.010]  - until=2
  [14:21:08.027]  - relaying element #2
  [14:21:08.027] result() for ClusterFuture ...
  [14:21:08.027] - result already collected: FutureResult
  [14:21:08.028] result() for ClusterFuture ... done
  [14:21:08.028] result() for ClusterFuture ...
  [14:21:08.029] - result already collected: FutureResult
  [14:21:08.029] result() for ClusterFuture ... done
  [14:21:08.029] result() for ClusterFuture ...
  [14:21:08.030] - result already collected: FutureResult
  [14:21:08.030] result() for ClusterFuture ... done
  [14:21:08.031] result() for ClusterFuture ...
  [14:21:08.031] - result already collected: FutureResult
  [14:21:08.031] result() for ClusterFuture ... done
  [14:21:08.032] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:08.032] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:08.032] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [14:21:08.033]  length: 2 (resolved future 2)
  [14:21:08.033] Future #3
  [14:21:08.033] result() for ClusterFuture ...
  [14:21:08.034] - result already collected: FutureResult
  [14:21:08.034] result() for ClusterFuture ... done
  [14:21:08.034] result() for ClusterFuture ...
  [14:21:08.035] - result already collected: FutureResult
  [14:21:08.035] result() for ClusterFuture ... done
  [14:21:08.036] signalConditionsASAP(ClusterFuture, pos=3) ...
  [14:21:08.036] - nx: 4
  [14:21:08.036] - relay: TRUE
  [14:21:08.036] - stdout: TRUE
  [14:21:08.037] - signal: TRUE
  [14:21:08.037] - resignal: FALSE
  [14:21:08.037] - force: TRUE
  [14:21:08.038] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [14:21:08.038] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [14:21:08.051]  - until=3
  [14:21:08.051]  - relaying element #3
  [14:21:08.051] result() for ClusterFuture ...
  [14:21:08.052] - result already collected: FutureResult
  [14:21:08.052] result() for ClusterFuture ... done
  [14:21:08.052] result() for ClusterFuture ...
  [14:21:08.053] - result already collected: FutureResult
  [14:21:08.053] result() for ClusterFuture ... done
  [14:21:08.054] result() for ClusterFuture ...
  [14:21:08.054] - result already collected: FutureResult
  [14:21:08.054] result() for ClusterFuture ... done
  [14:21:08.055] result() for ClusterFuture ...
  [14:21:08.071] - result already collected: FutureResult
  [14:21:08.071] result() for ClusterFuture ... done
  [14:21:08.072] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:08.072] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:08.072] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [14:21:08.073]  length: 1 (resolved future 3)
  [14:21:08.073] Future #4
  [14:21:08.073] result() for ClusterFuture ...
  [14:21:08.074] - result already collected: FutureResult
  [14:21:08.074] result() for ClusterFuture ... done
  [14:21:08.074] result() for ClusterFuture ...
  [14:21:08.075] - result already collected: FutureResult
  [14:21:08.075] result() for ClusterFuture ... done
  [14:21:08.075] signalConditionsASAP(ClusterFuture, pos=4) ...
  [14:21:08.076] - nx: 4
  [14:21:08.076] - relay: TRUE
  [14:21:08.076] - stdout: TRUE
  [14:21:08.077] - signal: TRUE
  [14:21:08.077] - resignal: FALSE
  [14:21:08.077] - force: TRUE
  [14:21:08.078] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [14:21:08.078] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [14:21:08.078]  - until=4
  [14:21:08.079]  - relaying element #4
  [14:21:08.079] result() for ClusterFuture ...
  [14:21:08.079] - result already collected: FutureResult
  [14:21:08.080] result() for ClusterFuture ... done
  [14:21:08.080] result() for ClusterFuture ...
  [14:21:08.080] - result already collected: FutureResult
  [14:21:08.081] result() for ClusterFuture ... done
  [14:21:08.081] result() for ClusterFuture ...
  [14:21:08.081] - result already collected: FutureResult
  [14:21:08.082] result() for ClusterFuture ... done
  [14:21:08.082] result() for ClusterFuture ...
  [14:21:08.082] - result already collected: FutureResult
  [14:21:08.083] result() for ClusterFuture ... done
  [14:21:08.083] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:08.083] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:08.084] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [14:21:08.084]  length: 0 (resolved future 4)
  [14:21:08.085] Relaying remaining futures
  [14:21:08.085] signalConditionsASAP(NULL, pos=0) ...
  [14:21:08.085] - nx: 4
  [14:21:08.085] - relay: TRUE
  [14:21:08.086] - stdout: TRUE
  [14:21:08.086] - signal: TRUE
  [14:21:08.102] - resignal: FALSE
  [14:21:08.103] - force: TRUE
  [14:21:08.103] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:08.104] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [14:21:08.104] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [14:21:08.105] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [14:21:08.105] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:08.105] resolve() on environment ... DONE
  [14:21:08.106] result() for ClusterFuture ...
  [14:21:08.106] - result already collected: FutureResult
  [14:21:08.106] result() for ClusterFuture ... done
  [14:21:08.107] result() for ClusterFuture ...
  [14:21:08.107] - result already collected: FutureResult
  [14:21:08.107] result() for ClusterFuture ... done
  [14:21:08.108] result() for ClusterFuture ...
  [14:21:08.108] - result already collected: FutureResult
  [14:21:08.108] result() for ClusterFuture ... done
  [14:21:08.109] result() for ClusterFuture ...
  [14:21:08.109] - result already collected: FutureResult
  [14:21:08.109] result() for ClusterFuture ... done
  [14:21:08.110] result() for ClusterFuture ...
  [14:21:08.110] - result already collected: FutureResult
  [14:21:08.110] result() for ClusterFuture ... done
  [14:21:08.110] result() for ClusterFuture ...
  [14:21:08.111] - result already collected: FutureResult
  [14:21:08.111] result() for ClusterFuture ... done
  <environment: 0x5574fa4908b8> 
  *** futures() - environment ... DONE
  Type of object: listenv
  Type of future: sequential
  [14:21:08.113] plan(): Setting new future strategy stack:
  [14:21:08.113] List of future strategies:
  [14:21:08.113] 1. sequential:
  [14:21:08.113]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.113]    - tweaked: FALSE
  [14:21:08.113]    - call: plan(strategy)
  [14:21:08.114] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [14:21:08.116] getGlobalsAndPackages() ...
  [14:21:08.116] Searching for globals...
  [14:21:08.117] 
  [14:21:08.117] Searching for globals ... DONE
  [14:21:08.117] - globals: [0] <none>
  [14:21:08.118] getGlobalsAndPackages() ... DONE
  [14:21:08.120] Packages needed by the future expression (n = 0): <none>
  [14:21:08.121] Packages needed by future strategies (n = 0): <none>
  [14:21:08.126] {
  [14:21:08.126]     {
  [14:21:08.126]         ...future.startTime <- base::Sys.time()
  [14:21:08.126]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.126]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.126]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.126]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.126]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.126]         {
  [14:21:08.126]             {
  [14:21:08.126]                 has_future <- base::requireNamespace("future", 
  [14:21:08.126]                   quietly = TRUE)
  [14:21:08.126]                 version <- if (has_future) 
  [14:21:08.126]                   utils::packageVersion("future")
  [14:21:08.126]                 else NULL
  [14:21:08.126]                 if (!has_future || version < "1.8.0") {
  [14:21:08.126]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.126]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.126]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.126]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.126]                       "release", "version")], collapse = " "), 
  [14:21:08.126]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.126]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.126]                     info)
  [14:21:08.126]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.126]                   if (!has_future) {
  [14:21:08.126]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.126]                       info)
  [14:21:08.126]                   }
  [14:21:08.126]                   else {
  [14:21:08.126]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.126]                       info, version)
  [14:21:08.126]                   }
  [14:21:08.126]                   base::stop(msg)
  [14:21:08.126]                 }
  [14:21:08.126]             }
  [14:21:08.126]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.126]         }
  [14:21:08.126]     }
  [14:21:08.126]     if (base::is.na(TRUE)) {
  [14:21:08.126]     }
  [14:21:08.126]     else {
  [14:21:08.126]         if (TRUE) {
  [14:21:08.126]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.126]                 open = "w")
  [14:21:08.126]         }
  [14:21:08.126]         else {
  [14:21:08.126]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.126]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.126]         }
  [14:21:08.126]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.126]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.126]             base::sink(type = "output", split = FALSE)
  [14:21:08.126]             base::close(...future.stdout)
  [14:21:08.126]         }, add = TRUE)
  [14:21:08.126]     }
  [14:21:08.126]     ...future.frame <- base::sys.nframe()
  [14:21:08.126]     ...future.conditions <- base::list()
  [14:21:08.126]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.126]     ...future.result <- base::tryCatch({
  [14:21:08.126]         base::withCallingHandlers({
  [14:21:08.126]             ...future.value <- base::withVisible(base::local(2))
  [14:21:08.126]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.126]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.126]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.126]                 version = "1.8")
  [14:21:08.126]         }, condition = base::local({
  [14:21:08.126]             c <- base::c
  [14:21:08.126]             inherits <- base::inherits
  [14:21:08.126]             invokeRestart <- base::invokeRestart
  [14:21:08.126]             length <- base::length
  [14:21:08.126]             list <- base::list
  [14:21:08.126]             seq.int <- base::seq.int
  [14:21:08.126]             signalCondition <- base::signalCondition
  [14:21:08.126]             sys.calls <- base::sys.calls
  [14:21:08.126]             Sys.time <- base::Sys.time
  [14:21:08.126]             `[[` <- base::`[[`
  [14:21:08.126]             `+` <- base::`+`
  [14:21:08.126]             `<<-` <- base::`<<-`
  [14:21:08.126]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.126]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.126]                   3L)]
  [14:21:08.126]             }
  [14:21:08.126]             function(cond) {
  [14:21:08.126]                 if (inherits(cond, "error")) {
  [14:21:08.126]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.126]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.126]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.126]                   signalCondition(cond)
  [14:21:08.126]                 }
  [14:21:08.126]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.126]                 ))) {
  [14:21:08.126]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.126]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.126]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.126]                   if (!signal) {
  [14:21:08.126]                     muffleCondition <- function (cond) 
  [14:21:08.126]                     {
  [14:21:08.126]                       inherits <- base::inherits
  [14:21:08.126]                       invokeRestart <- base::invokeRestart
  [14:21:08.126]                       muffled <- FALSE
  [14:21:08.126]                       if (inherits(cond, "message")) {
  [14:21:08.126]                         invokeRestart("muffleMessage")
  [14:21:08.126]                         muffled <- TRUE
  [14:21:08.126]                       }
  [14:21:08.126]                       else if (inherits(cond, "warning")) {
  [14:21:08.126]                         invokeRestart("muffleWarning")
  [14:21:08.126]                         muffled <- TRUE
  [14:21:08.126]                       }
  [14:21:08.126]                       else if (inherits(cond, "condition")) {
  [14:21:08.126]                         computeRestarts <- base::computeRestarts
  [14:21:08.126]                         grepl <- base::grepl
  [14:21:08.126]                         is.null <- base::is.null
  [14:21:08.126]                         restarts <- computeRestarts(cond)
  [14:21:08.126]                         for (restart in restarts) {
  [14:21:08.126]                           name <- restart$name
  [14:21:08.126]                           if (is.null(name)) 
  [14:21:08.126]                             next
  [14:21:08.126]                           if (!grepl("^muffle", name)) 
  [14:21:08.126]                             next
  [14:21:08.126]                           invokeRestart(restart)
  [14:21:08.126]                           muffled <- TRUE
  [14:21:08.126]                           break
  [14:21:08.126]                         }
  [14:21:08.126]                       }
  [14:21:08.126]                       invisible(muffled)
  [14:21:08.126]                     }
  [14:21:08.126]                     muffleCondition(cond)
  [14:21:08.126]                   }
  [14:21:08.126]                 }
  [14:21:08.126]             }
  [14:21:08.126]         }))
  [14:21:08.126]     }, error = function(ex) {
  [14:21:08.126]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.126]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.126]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.126]     }, finally = {
  [14:21:08.126]         {
  [14:21:08.126]             NULL
  [14:21:08.126]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.126]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.126]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.126]                 label = NULL, ...) 
  [14:21:08.126]             {
  [14:21:08.126]                 if (substitute) 
  [14:21:08.126]                   expr <- substitute(expr)
  [14:21:08.126]                 local <- as.logical(local)
  [14:21:08.126]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.126]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.126]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.126]                   label = label, ...)
  [14:21:08.126]                 if (!future$lazy) 
  [14:21:08.126]                   future <- run(future)
  [14:21:08.126]                 invisible(future)
  [14:21:08.126]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.126]         }
  [14:21:08.126]         base::options(...future.oldOptions)
  [14:21:08.126]     })
  [14:21:08.126]     Sys.time
  [14:21:08.126]     if (base::is.na(TRUE)) {
  [14:21:08.126]     }
  [14:21:08.126]     else {
  [14:21:08.126]         base::sink(type = "output", split = FALSE)
  [14:21:08.126]         if (TRUE) {
  [14:21:08.126]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.126]         }
  [14:21:08.126]         else {
  [14:21:08.126]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.126]         }
  [14:21:08.126]         base::close(...future.stdout)
  [14:21:08.126]         ...future.stdout <- NULL
  [14:21:08.126]     }
  [14:21:08.126]     ...future.result$conditions <- ...future.conditions
  [14:21:08.126]     ...future.result
  [14:21:08.126] }
  [14:21:08.154] plan(): Setting new future strategy stack:
  [14:21:08.154] List of future strategies:
  [14:21:08.154] 1. sequential:
  [14:21:08.154]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.154]    - tweaked: FALSE
  [14:21:08.154]    - call: NULL
  [14:21:08.155] plan(): nbrOfWorkers() = 1
  [14:21:08.157] plan(): Setting new future strategy stack:
  [14:21:08.157] List of future strategies:
  [14:21:08.157] 1. sequential:
  [14:21:08.157]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.157]    - tweaked: FALSE
  [14:21:08.157]    - call: plan(strategy)
  [14:21:08.158] plan(): nbrOfWorkers() = 1
  [14:21:08.175] SequentialFuture started (and completed)
  [14:21:08.176] getGlobalsAndPackages() ...
  [14:21:08.176] Searching for globals...
  [14:21:08.177] 
  [14:21:08.177] Searching for globals ... DONE
  [14:21:08.177] - globals: [0] <none>
  [14:21:08.178] getGlobalsAndPackages() ... DONE
  [14:21:08.180] Packages needed by the future expression (n = 0): <none>
  [14:21:08.180] Packages needed by future strategies (n = 0): <none>
  [14:21:08.186] {
  [14:21:08.186]     {
  [14:21:08.186]         ...future.startTime <- base::Sys.time()
  [14:21:08.186]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.186]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.186]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.186]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.186]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.186]         {
  [14:21:08.186]             {
  [14:21:08.186]                 has_future <- base::requireNamespace("future", 
  [14:21:08.186]                   quietly = TRUE)
  [14:21:08.186]                 version <- if (has_future) 
  [14:21:08.186]                   utils::packageVersion("future")
  [14:21:08.186]                 else NULL
  [14:21:08.186]                 if (!has_future || version < "1.8.0") {
  [14:21:08.186]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.186]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.186]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.186]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.186]                       "release", "version")], collapse = " "), 
  [14:21:08.186]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.186]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.186]                     info)
  [14:21:08.186]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.186]                   if (!has_future) {
  [14:21:08.186]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.186]                       info)
  [14:21:08.186]                   }
  [14:21:08.186]                   else {
  [14:21:08.186]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.186]                       info, version)
  [14:21:08.186]                   }
  [14:21:08.186]                   base::stop(msg)
  [14:21:08.186]                 }
  [14:21:08.186]             }
  [14:21:08.186]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.186]         }
  [14:21:08.186]     }
  [14:21:08.186]     if (base::is.na(TRUE)) {
  [14:21:08.186]     }
  [14:21:08.186]     else {
  [14:21:08.186]         if (TRUE) {
  [14:21:08.186]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.186]                 open = "w")
  [14:21:08.186]         }
  [14:21:08.186]         else {
  [14:21:08.186]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.186]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.186]         }
  [14:21:08.186]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.186]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.186]             base::sink(type = "output", split = FALSE)
  [14:21:08.186]             base::close(...future.stdout)
  [14:21:08.186]         }, add = TRUE)
  [14:21:08.186]     }
  [14:21:08.186]     ...future.frame <- base::sys.nframe()
  [14:21:08.186]     ...future.conditions <- base::list()
  [14:21:08.186]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.186]     ...future.result <- base::tryCatch({
  [14:21:08.186]         base::withCallingHandlers({
  [14:21:08.186]             ...future.value <- base::withVisible(base::local(NULL))
  [14:21:08.186]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.186]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.186]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.186]                 version = "1.8")
  [14:21:08.186]         }, condition = base::local({
  [14:21:08.186]             c <- base::c
  [14:21:08.186]             inherits <- base::inherits
  [14:21:08.186]             invokeRestart <- base::invokeRestart
  [14:21:08.186]             length <- base::length
  [14:21:08.186]             list <- base::list
  [14:21:08.186]             seq.int <- base::seq.int
  [14:21:08.186]             signalCondition <- base::signalCondition
  [14:21:08.186]             sys.calls <- base::sys.calls
  [14:21:08.186]             Sys.time <- base::Sys.time
  [14:21:08.186]             `[[` <- base::`[[`
  [14:21:08.186]             `+` <- base::`+`
  [14:21:08.186]             `<<-` <- base::`<<-`
  [14:21:08.186]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.186]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.186]                   3L)]
  [14:21:08.186]             }
  [14:21:08.186]             function(cond) {
  [14:21:08.186]                 if (inherits(cond, "error")) {
  [14:21:08.186]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.186]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.186]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.186]                   signalCondition(cond)
  [14:21:08.186]                 }
  [14:21:08.186]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.186]                 ))) {
  [14:21:08.186]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.186]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.186]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.186]                   if (!signal) {
  [14:21:08.186]                     muffleCondition <- function (cond) 
  [14:21:08.186]                     {
  [14:21:08.186]                       inherits <- base::inherits
  [14:21:08.186]                       invokeRestart <- base::invokeRestart
  [14:21:08.186]                       muffled <- FALSE
  [14:21:08.186]                       if (inherits(cond, "message")) {
  [14:21:08.186]                         invokeRestart("muffleMessage")
  [14:21:08.186]                         muffled <- TRUE
  [14:21:08.186]                       }
  [14:21:08.186]                       else if (inherits(cond, "warning")) {
  [14:21:08.186]                         invokeRestart("muffleWarning")
  [14:21:08.186]                         muffled <- TRUE
  [14:21:08.186]                       }
  [14:21:08.186]                       else if (inherits(cond, "condition")) {
  [14:21:08.186]                         computeRestarts <- base::computeRestarts
  [14:21:08.186]                         grepl <- base::grepl
  [14:21:08.186]                         is.null <- base::is.null
  [14:21:08.186]                         restarts <- computeRestarts(cond)
  [14:21:08.186]                         for (restart in restarts) {
  [14:21:08.186]                           name <- restart$name
  [14:21:08.186]                           if (is.null(name)) 
  [14:21:08.186]                             next
  [14:21:08.186]                           if (!grepl("^muffle", name)) 
  [14:21:08.186]                             next
  [14:21:08.186]                           invokeRestart(restart)
  [14:21:08.186]                           muffled <- TRUE
  [14:21:08.186]                           break
  [14:21:08.186]                         }
  [14:21:08.186]                       }
  [14:21:08.186]                       invisible(muffled)
  [14:21:08.186]                     }
  [14:21:08.186]                     muffleCondition(cond)
  [14:21:08.186]                   }
  [14:21:08.186]                 }
  [14:21:08.186]             }
  [14:21:08.186]         }))
  [14:21:08.186]     }, error = function(ex) {
  [14:21:08.186]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.186]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.186]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.186]     }, finally = {
  [14:21:08.186]         {
  [14:21:08.186]             NULL
  [14:21:08.186]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.186]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.186]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.186]                 label = NULL, ...) 
  [14:21:08.186]             {
  [14:21:08.186]                 if (substitute) 
  [14:21:08.186]                   expr <- substitute(expr)
  [14:21:08.186]                 local <- as.logical(local)
  [14:21:08.186]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.186]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.186]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.186]                   label = label, ...)
  [14:21:08.186]                 if (!future$lazy) 
  [14:21:08.186]                   future <- run(future)
  [14:21:08.186]                 invisible(future)
  [14:21:08.186]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.186]         }
  [14:21:08.186]         base::options(...future.oldOptions)
  [14:21:08.186]     })
  [14:21:08.186]     Sys.time
  [14:21:08.186]     if (base::is.na(TRUE)) {
  [14:21:08.186]     }
  [14:21:08.186]     else {
  [14:21:08.186]         base::sink(type = "output", split = FALSE)
  [14:21:08.186]         if (TRUE) {
  [14:21:08.186]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.186]         }
  [14:21:08.186]         else {
  [14:21:08.186]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.186]         }
  [14:21:08.186]         base::close(...future.stdout)
  [14:21:08.186]         ...future.stdout <- NULL
  [14:21:08.186]     }
  [14:21:08.186]     ...future.result$conditions <- ...future.conditions
  [14:21:08.186]     ...future.result
  [14:21:08.186] }
  [14:21:08.192] plan(): Setting new future strategy stack:
  [14:21:08.192] List of future strategies:
  [14:21:08.192] 1. sequential:
  [14:21:08.192]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.192]    - tweaked: FALSE
  [14:21:08.192]    - call: NULL
  [14:21:08.193] plan(): nbrOfWorkers() = 1
  [14:21:08.195] plan(): Setting new future strategy stack:
  [14:21:08.195] List of future strategies:
  [14:21:08.195] 1. sequential:
  [14:21:08.195]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.195]    - tweaked: FALSE
  [14:21:08.195]    - call: plan(strategy)
  [14:21:08.196] plan(): nbrOfWorkers() = 1
  [14:21:08.197] SequentialFuture started (and completed)
  [14:21:08.198] getGlobalsAndPackages() ...
  [14:21:08.199] Searching for globals...
  [14:21:08.200] - globals found: [1] '{'
  [14:21:08.200] Searching for globals ... DONE
  [14:21:08.201] Resolving globals: FALSE
  [14:21:08.202] 
  [14:21:08.202] 
  [14:21:08.203] getGlobalsAndPackages() ... DONE
  [14:21:08.205] Packages needed by the future expression (n = 0): <none>
  [14:21:08.205] Packages needed by future strategies (n = 0): <none>
  [14:21:08.211] {
  [14:21:08.211]     {
  [14:21:08.211]         ...future.startTime <- base::Sys.time()
  [14:21:08.211]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.211]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.211]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.211]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.211]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.211]         {
  [14:21:08.211]             {
  [14:21:08.211]                 has_future <- base::requireNamespace("future", 
  [14:21:08.211]                   quietly = TRUE)
  [14:21:08.211]                 version <- if (has_future) 
  [14:21:08.211]                   utils::packageVersion("future")
  [14:21:08.211]                 else NULL
  [14:21:08.211]                 if (!has_future || version < "1.8.0") {
  [14:21:08.211]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.211]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.211]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.211]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.211]                       "release", "version")], collapse = " "), 
  [14:21:08.211]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.211]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.211]                     info)
  [14:21:08.211]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.211]                   if (!has_future) {
  [14:21:08.211]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.211]                       info)
  [14:21:08.211]                   }
  [14:21:08.211]                   else {
  [14:21:08.211]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.211]                       info, version)
  [14:21:08.211]                   }
  [14:21:08.211]                   base::stop(msg)
  [14:21:08.211]                 }
  [14:21:08.211]             }
  [14:21:08.211]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.211]         }
  [14:21:08.211]     }
  [14:21:08.211]     if (base::is.na(TRUE)) {
  [14:21:08.211]     }
  [14:21:08.211]     else {
  [14:21:08.211]         if (TRUE) {
  [14:21:08.211]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.211]                 open = "w")
  [14:21:08.211]         }
  [14:21:08.211]         else {
  [14:21:08.211]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.211]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.211]         }
  [14:21:08.211]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.211]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.211]             base::sink(type = "output", split = FALSE)
  [14:21:08.211]             base::close(...future.stdout)
  [14:21:08.211]         }, add = TRUE)
  [14:21:08.211]     }
  [14:21:08.211]     ...future.frame <- base::sys.nframe()
  [14:21:08.211]     ...future.conditions <- base::list()
  [14:21:08.211]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.211]     ...future.result <- base::tryCatch({
  [14:21:08.211]         base::withCallingHandlers({
  [14:21:08.211]             ...future.value <- base::withVisible(base::local({
  [14:21:08.211]                 4
  [14:21:08.211]             }))
  [14:21:08.211]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.211]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.211]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.211]                 version = "1.8")
  [14:21:08.211]         }, condition = base::local({
  [14:21:08.211]             c <- base::c
  [14:21:08.211]             inherits <- base::inherits
  [14:21:08.211]             invokeRestart <- base::invokeRestart
  [14:21:08.211]             length <- base::length
  [14:21:08.211]             list <- base::list
  [14:21:08.211]             seq.int <- base::seq.int
  [14:21:08.211]             signalCondition <- base::signalCondition
  [14:21:08.211]             sys.calls <- base::sys.calls
  [14:21:08.211]             Sys.time <- base::Sys.time
  [14:21:08.211]             `[[` <- base::`[[`
  [14:21:08.211]             `+` <- base::`+`
  [14:21:08.211]             `<<-` <- base::`<<-`
  [14:21:08.211]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.211]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.211]                   3L)]
  [14:21:08.211]             }
  [14:21:08.211]             function(cond) {
  [14:21:08.211]                 if (inherits(cond, "error")) {
  [14:21:08.211]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.211]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.211]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.211]                   signalCondition(cond)
  [14:21:08.211]                 }
  [14:21:08.211]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.211]                 ))) {
  [14:21:08.211]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.211]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.211]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.211]                   if (!signal) {
  [14:21:08.211]                     muffleCondition <- function (cond) 
  [14:21:08.211]                     {
  [14:21:08.211]                       inherits <- base::inherits
  [14:21:08.211]                       invokeRestart <- base::invokeRestart
  [14:21:08.211]                       muffled <- FALSE
  [14:21:08.211]                       if (inherits(cond, "message")) {
  [14:21:08.211]                         invokeRestart("muffleMessage")
  [14:21:08.211]                         muffled <- TRUE
  [14:21:08.211]                       }
  [14:21:08.211]                       else if (inherits(cond, "warning")) {
  [14:21:08.211]                         invokeRestart("muffleWarning")
  [14:21:08.211]                         muffled <- TRUE
  [14:21:08.211]                       }
  [14:21:08.211]                       else if (inherits(cond, "condition")) {
  [14:21:08.211]                         computeRestarts <- base::computeRestarts
  [14:21:08.211]                         grepl <- base::grepl
  [14:21:08.211]                         is.null <- base::is.null
  [14:21:08.211]                         restarts <- computeRestarts(cond)
  [14:21:08.211]                         for (restart in restarts) {
  [14:21:08.211]                           name <- restart$name
  [14:21:08.211]                           if (is.null(name)) 
  [14:21:08.211]                             next
  [14:21:08.211]                           if (!grepl("^muffle", name)) 
  [14:21:08.211]                             next
  [14:21:08.211]                           invokeRestart(restart)
  [14:21:08.211]                           muffled <- TRUE
  [14:21:08.211]                           break
  [14:21:08.211]                         }
  [14:21:08.211]                       }
  [14:21:08.211]                       invisible(muffled)
  [14:21:08.211]                     }
  [14:21:08.211]                     muffleCondition(cond)
  [14:21:08.211]                   }
  [14:21:08.211]                 }
  [14:21:08.211]             }
  [14:21:08.211]         }))
  [14:21:08.211]     }, error = function(ex) {
  [14:21:08.211]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.211]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.211]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.211]     }, finally = {
  [14:21:08.211]         {
  [14:21:08.211]             NULL
  [14:21:08.211]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.211]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.211]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.211]                 label = NULL, ...) 
  [14:21:08.211]             {
  [14:21:08.211]                 if (substitute) 
  [14:21:08.211]                   expr <- substitute(expr)
  [14:21:08.211]                 local <- as.logical(local)
  [14:21:08.211]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.211]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.211]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.211]                   label = label, ...)
  [14:21:08.211]                 if (!future$lazy) 
  [14:21:08.211]                   future <- run(future)
  [14:21:08.211]                 invisible(future)
  [14:21:08.211]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.211]         }
  [14:21:08.211]         base::options(...future.oldOptions)
  [14:21:08.211]     })
  [14:21:08.211]     Sys.time
  [14:21:08.211]     if (base::is.na(TRUE)) {
  [14:21:08.211]     }
  [14:21:08.211]     else {
  [14:21:08.211]         base::sink(type = "output", split = FALSE)
  [14:21:08.211]         if (TRUE) {
  [14:21:08.211]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.211]         }
  [14:21:08.211]         else {
  [14:21:08.211]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.211]         }
  [14:21:08.211]         base::close(...future.stdout)
  [14:21:08.211]         ...future.stdout <- NULL
  [14:21:08.211]     }
  [14:21:08.211]     ...future.result$conditions <- ...future.conditions
  [14:21:08.211]     ...future.result
  [14:21:08.211] }
  [14:21:08.219] plan(): Setting new future strategy stack:
  [14:21:08.220] List of future strategies:
  [14:21:08.220] 1. sequential:
  [14:21:08.220]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.220]    - tweaked: FALSE
  [14:21:08.220]    - call: NULL
  [14:21:08.221] plan(): nbrOfWorkers() = 1
  [14:21:08.222] plan(): Setting new future strategy stack:
  [14:21:08.223] List of future strategies:
  [14:21:08.223] 1. sequential:
  [14:21:08.223]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.223]    - tweaked: FALSE
  [14:21:08.223]    - call: plan(strategy)
  [14:21:08.224] plan(): nbrOfWorkers() = 1
  [14:21:08.224] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x5574fa2d3900> 
  Classes 'listenv', 'environment' <environment: 0x5574fa50c3f8> 
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [14:21:08.245] resolve() on list environment ...
  [14:21:08.246]  recursive: 0
  [14:21:08.249]  length: 6
  [14:21:08.249]  elements: 'a', 'b', 'c', 'd', '', ''
  [14:21:08.250] signalConditionsASAP(numeric, pos=1) ...
  [14:21:08.250] - nx: 6
  [14:21:08.250] - relay: TRUE
  [14:21:08.251] - stdout: TRUE
  [14:21:08.251] - signal: TRUE
  [14:21:08.251] - resignal: FALSE
  [14:21:08.252] - force: TRUE
  [14:21:08.252] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.252] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.253]  - until=2
  [14:21:08.253]  - relaying element #2
  [14:21:08.253] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.254] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.254] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:08.254]  length: 5 (resolved future 1)
  [14:21:08.255] Future #2
  [14:21:08.255] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:21:08.256] - nx: 6
  [14:21:08.256] - relay: TRUE
  [14:21:08.256] - stdout: TRUE
  [14:21:08.256] - signal: TRUE
  [14:21:08.257] - resignal: FALSE
  [14:21:08.257] - force: TRUE
  [14:21:08.257] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.258] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.258]  - until=2
  [14:21:08.258]  - relaying element #2
  [14:21:08.259] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.259] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.259] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:21:08.260]  length: 4 (resolved future 2)
  [14:21:08.260] Future #3
  [14:21:08.261] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:21:08.261] - nx: 6
  [14:21:08.261] - relay: TRUE
  [14:21:08.262] - stdout: TRUE
  [14:21:08.262] - signal: TRUE
  [14:21:08.262] - resignal: FALSE
  [14:21:08.263] - force: TRUE
  [14:21:08.263] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.263] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.263]  - until=3
  [14:21:08.264]  - relaying element #3
  [14:21:08.264] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.265] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.265] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:21:08.265]  length: 3 (resolved future 3)
  [14:21:08.266] Future #4
  [14:21:08.266] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:21:08.267] - nx: 6
  [14:21:08.267] - relay: TRUE
  [14:21:08.267] - stdout: TRUE
  [14:21:08.267] - signal: TRUE
  [14:21:08.268] - resignal: FALSE
  [14:21:08.268] - force: TRUE
  [14:21:08.268] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.269] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.269]  - until=4
  [14:21:08.269]  - relaying element #4
  [14:21:08.270] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.270] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.271] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:21:08.271]  length: 2 (resolved future 4)
  [14:21:08.271] signalConditionsASAP(NULL, pos=5) ...
  [14:21:08.272] - nx: 6
  [14:21:08.272] - relay: TRUE
  [14:21:08.272] - stdout: TRUE
  [14:21:08.273] - signal: TRUE
  [14:21:08.273] - resignal: FALSE
  [14:21:08.273] - force: TRUE
  [14:21:08.273] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.274] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.274]  - until=6
  [14:21:08.274]  - relaying element #6
  [14:21:08.275] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.275] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.275] signalConditionsASAP(NULL, pos=5) ... done
  [14:21:08.276]  length: 1 (resolved future 5)
  [14:21:08.276] signalConditionsASAP(numeric, pos=6) ...
  [14:21:08.276] - nx: 6
  [14:21:08.277] - relay: TRUE
  [14:21:08.277] - stdout: TRUE
  [14:21:08.277] - signal: TRUE
  [14:21:08.278] - resignal: FALSE
  [14:21:08.278] - force: TRUE
  [14:21:08.278] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.279] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.279]  - until=6
  [14:21:08.279] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.280] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.280] signalConditionsASAP(numeric, pos=6) ... done
  [14:21:08.280]  length: 0 (resolved future 6)
  [14:21:08.280] Relaying remaining futures
  [14:21:08.281] signalConditionsASAP(NULL, pos=0) ...
  [14:21:08.281] - nx: 6
  [14:21:08.281] - relay: TRUE
  [14:21:08.282] - stdout: TRUE
  [14:21:08.282] - signal: TRUE
  [14:21:08.282] - resignal: FALSE
  [14:21:08.283] - force: TRUE
  [14:21:08.283] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.283] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [14:21:08.284] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.284] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.284] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:08.285] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x5574fa20e988> 
  Dimensions: c(1, 6)
  [14:21:08.287] getGlobalsAndPackages() ...
  [14:21:08.287] Searching for globals...
  [14:21:08.288] 
  [14:21:08.288] Searching for globals ... DONE
  [14:21:08.289] - globals: [0] <none>
  [14:21:08.289] getGlobalsAndPackages() ... DONE
  [14:21:08.291] Packages needed by the future expression (n = 0): <none>
  [14:21:08.292] Packages needed by future strategies (n = 0): <none>
  [14:21:08.309] {
  [14:21:08.309]     {
  [14:21:08.309]         ...future.startTime <- base::Sys.time()
  [14:21:08.309]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.309]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.309]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.309]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.309]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.309]         {
  [14:21:08.309]             {
  [14:21:08.309]                 has_future <- base::requireNamespace("future", 
  [14:21:08.309]                   quietly = TRUE)
  [14:21:08.309]                 version <- if (has_future) 
  [14:21:08.309]                   utils::packageVersion("future")
  [14:21:08.309]                 else NULL
  [14:21:08.309]                 if (!has_future || version < "1.8.0") {
  [14:21:08.309]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.309]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.309]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.309]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.309]                       "release", "version")], collapse = " "), 
  [14:21:08.309]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.309]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.309]                     info)
  [14:21:08.309]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.309]                   if (!has_future) {
  [14:21:08.309]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.309]                       info)
  [14:21:08.309]                   }
  [14:21:08.309]                   else {
  [14:21:08.309]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.309]                       info, version)
  [14:21:08.309]                   }
  [14:21:08.309]                   base::stop(msg)
  [14:21:08.309]                 }
  [14:21:08.309]             }
  [14:21:08.309]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.309]         }
  [14:21:08.309]     }
  [14:21:08.309]     if (base::is.na(TRUE)) {
  [14:21:08.309]     }
  [14:21:08.309]     else {
  [14:21:08.309]         if (TRUE) {
  [14:21:08.309]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.309]                 open = "w")
  [14:21:08.309]         }
  [14:21:08.309]         else {
  [14:21:08.309]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.309]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.309]         }
  [14:21:08.309]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.309]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.309]             base::sink(type = "output", split = FALSE)
  [14:21:08.309]             base::close(...future.stdout)
  [14:21:08.309]         }, add = TRUE)
  [14:21:08.309]     }
  [14:21:08.309]     ...future.frame <- base::sys.nframe()
  [14:21:08.309]     ...future.conditions <- base::list()
  [14:21:08.309]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.309]     ...future.result <- base::tryCatch({
  [14:21:08.309]         base::withCallingHandlers({
  [14:21:08.309]             ...future.value <- base::withVisible(base::local(2))
  [14:21:08.309]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.309]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.309]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.309]                 version = "1.8")
  [14:21:08.309]         }, condition = base::local({
  [14:21:08.309]             c <- base::c
  [14:21:08.309]             inherits <- base::inherits
  [14:21:08.309]             invokeRestart <- base::invokeRestart
  [14:21:08.309]             length <- base::length
  [14:21:08.309]             list <- base::list
  [14:21:08.309]             seq.int <- base::seq.int
  [14:21:08.309]             signalCondition <- base::signalCondition
  [14:21:08.309]             sys.calls <- base::sys.calls
  [14:21:08.309]             Sys.time <- base::Sys.time
  [14:21:08.309]             `[[` <- base::`[[`
  [14:21:08.309]             `+` <- base::`+`
  [14:21:08.309]             `<<-` <- base::`<<-`
  [14:21:08.309]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.309]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.309]                   3L)]
  [14:21:08.309]             }
  [14:21:08.309]             function(cond) {
  [14:21:08.309]                 if (inherits(cond, "error")) {
  [14:21:08.309]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.309]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.309]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.309]                   signalCondition(cond)
  [14:21:08.309]                 }
  [14:21:08.309]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.309]                 ))) {
  [14:21:08.309]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.309]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.309]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.309]                   if (!signal) {
  [14:21:08.309]                     muffleCondition <- function (cond) 
  [14:21:08.309]                     {
  [14:21:08.309]                       inherits <- base::inherits
  [14:21:08.309]                       invokeRestart <- base::invokeRestart
  [14:21:08.309]                       muffled <- FALSE
  [14:21:08.309]                       if (inherits(cond, "message")) {
  [14:21:08.309]                         invokeRestart("muffleMessage")
  [14:21:08.309]                         muffled <- TRUE
  [14:21:08.309]                       }
  [14:21:08.309]                       else if (inherits(cond, "warning")) {
  [14:21:08.309]                         invokeRestart("muffleWarning")
  [14:21:08.309]                         muffled <- TRUE
  [14:21:08.309]                       }
  [14:21:08.309]                       else if (inherits(cond, "condition")) {
  [14:21:08.309]                         computeRestarts <- base::computeRestarts
  [14:21:08.309]                         grepl <- base::grepl
  [14:21:08.309]                         is.null <- base::is.null
  [14:21:08.309]                         restarts <- computeRestarts(cond)
  [14:21:08.309]                         for (restart in restarts) {
  [14:21:08.309]                           name <- restart$name
  [14:21:08.309]                           if (is.null(name)) 
  [14:21:08.309]                             next
  [14:21:08.309]                           if (!grepl("^muffle", name)) 
  [14:21:08.309]                             next
  [14:21:08.309]                           invokeRestart(restart)
  [14:21:08.309]                           muffled <- TRUE
  [14:21:08.309]                           break
  [14:21:08.309]                         }
  [14:21:08.309]                       }
  [14:21:08.309]                       invisible(muffled)
  [14:21:08.309]                     }
  [14:21:08.309]                     muffleCondition(cond)
  [14:21:08.309]                   }
  [14:21:08.309]                 }
  [14:21:08.309]             }
  [14:21:08.309]         }))
  [14:21:08.309]     }, error = function(ex) {
  [14:21:08.309]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.309]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.309]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.309]     }, finally = {
  [14:21:08.309]         {
  [14:21:08.309]             NULL
  [14:21:08.309]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.309]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.309]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.309]                 label = NULL, ...) 
  [14:21:08.309]             {
  [14:21:08.309]                 if (substitute) 
  [14:21:08.309]                   expr <- substitute(expr)
  [14:21:08.309]                 local <- as.logical(local)
  [14:21:08.309]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.309]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.309]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.309]                   label = label, ...)
  [14:21:08.309]                 if (!future$lazy) 
  [14:21:08.309]                   future <- run(future)
  [14:21:08.309]                 invisible(future)
  [14:21:08.309]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.309]         }
  [14:21:08.309]         base::options(...future.oldOptions)
  [14:21:08.309]     })
  [14:21:08.309]     Sys.time
  [14:21:08.309]     if (base::is.na(TRUE)) {
  [14:21:08.309]     }
  [14:21:08.309]     else {
  [14:21:08.309]         base::sink(type = "output", split = FALSE)
  [14:21:08.309]         if (TRUE) {
  [14:21:08.309]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.309]         }
  [14:21:08.309]         else {
  [14:21:08.309]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.309]         }
  [14:21:08.309]         base::close(...future.stdout)
  [14:21:08.309]         ...future.stdout <- NULL
  [14:21:08.309]     }
  [14:21:08.309]     ...future.result$conditions <- ...future.conditions
  [14:21:08.309]     ...future.result
  [14:21:08.309] }
  [14:21:08.315] plan(): Setting new future strategy stack:
  [14:21:08.316] List of future strategies:
  [14:21:08.316] 1. sequential:
  [14:21:08.316]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.316]    - tweaked: FALSE
  [14:21:08.316]    - call: NULL
  [14:21:08.317] plan(): nbrOfWorkers() = 1
  [14:21:08.319] plan(): Setting new future strategy stack:
  [14:21:08.319] List of future strategies:
  [14:21:08.319] 1. sequential:
  [14:21:08.319]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.319]    - tweaked: FALSE
  [14:21:08.319]    - call: plan(strategy)
  [14:21:08.320] plan(): nbrOfWorkers() = 1
  [14:21:08.321] SequentialFuture started (and completed)
  [14:21:08.321] getGlobalsAndPackages() ...
  [14:21:08.322] Searching for globals...
  [14:21:08.323] 
  [14:21:08.323] Searching for globals ... DONE
  [14:21:08.323] - globals: [0] <none>
  [14:21:08.324] getGlobalsAndPackages() ... DONE
  [14:21:08.326] Packages needed by the future expression (n = 0): <none>
  [14:21:08.326] Packages needed by future strategies (n = 0): <none>
  [14:21:08.332] {
  [14:21:08.332]     {
  [14:21:08.332]         ...future.startTime <- base::Sys.time()
  [14:21:08.332]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.332]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.332]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.332]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.332]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.332]         {
  [14:21:08.332]             {
  [14:21:08.332]                 has_future <- base::requireNamespace("future", 
  [14:21:08.332]                   quietly = TRUE)
  [14:21:08.332]                 version <- if (has_future) 
  [14:21:08.332]                   utils::packageVersion("future")
  [14:21:08.332]                 else NULL
  [14:21:08.332]                 if (!has_future || version < "1.8.0") {
  [14:21:08.332]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.332]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.332]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.332]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.332]                       "release", "version")], collapse = " "), 
  [14:21:08.332]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.332]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.332]                     info)
  [14:21:08.332]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.332]                   if (!has_future) {
  [14:21:08.332]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.332]                       info)
  [14:21:08.332]                   }
  [14:21:08.332]                   else {
  [14:21:08.332]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.332]                       info, version)
  [14:21:08.332]                   }
  [14:21:08.332]                   base::stop(msg)
  [14:21:08.332]                 }
  [14:21:08.332]             }
  [14:21:08.332]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.332]         }
  [14:21:08.332]     }
  [14:21:08.332]     if (base::is.na(TRUE)) {
  [14:21:08.332]     }
  [14:21:08.332]     else {
  [14:21:08.332]         if (TRUE) {
  [14:21:08.332]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.332]                 open = "w")
  [14:21:08.332]         }
  [14:21:08.332]         else {
  [14:21:08.332]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.332]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.332]         }
  [14:21:08.332]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.332]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.332]             base::sink(type = "output", split = FALSE)
  [14:21:08.332]             base::close(...future.stdout)
  [14:21:08.332]         }, add = TRUE)
  [14:21:08.332]     }
  [14:21:08.332]     ...future.frame <- base::sys.nframe()
  [14:21:08.332]     ...future.conditions <- base::list()
  [14:21:08.332]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.332]     ...future.result <- base::tryCatch({
  [14:21:08.332]         base::withCallingHandlers({
  [14:21:08.332]             ...future.value <- base::withVisible(base::local(NULL))
  [14:21:08.332]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.332]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.332]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.332]                 version = "1.8")
  [14:21:08.332]         }, condition = base::local({
  [14:21:08.332]             c <- base::c
  [14:21:08.332]             inherits <- base::inherits
  [14:21:08.332]             invokeRestart <- base::invokeRestart
  [14:21:08.332]             length <- base::length
  [14:21:08.332]             list <- base::list
  [14:21:08.332]             seq.int <- base::seq.int
  [14:21:08.332]             signalCondition <- base::signalCondition
  [14:21:08.332]             sys.calls <- base::sys.calls
  [14:21:08.332]             Sys.time <- base::Sys.time
  [14:21:08.332]             `[[` <- base::`[[`
  [14:21:08.332]             `+` <- base::`+`
  [14:21:08.332]             `<<-` <- base::`<<-`
  [14:21:08.332]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.332]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.332]                   3L)]
  [14:21:08.332]             }
  [14:21:08.332]             function(cond) {
  [14:21:08.332]                 if (inherits(cond, "error")) {
  [14:21:08.332]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.332]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.332]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.332]                   signalCondition(cond)
  [14:21:08.332]                 }
  [14:21:08.332]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.332]                 ))) {
  [14:21:08.332]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.332]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.332]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.332]                   if (!signal) {
  [14:21:08.332]                     muffleCondition <- function (cond) 
  [14:21:08.332]                     {
  [14:21:08.332]                       inherits <- base::inherits
  [14:21:08.332]                       invokeRestart <- base::invokeRestart
  [14:21:08.332]                       muffled <- FALSE
  [14:21:08.332]                       if (inherits(cond, "message")) {
  [14:21:08.332]                         invokeRestart("muffleMessage")
  [14:21:08.332]                         muffled <- TRUE
  [14:21:08.332]                       }
  [14:21:08.332]                       else if (inherits(cond, "warning")) {
  [14:21:08.332]                         invokeRestart("muffleWarning")
  [14:21:08.332]                         muffled <- TRUE
  [14:21:08.332]                       }
  [14:21:08.332]                       else if (inherits(cond, "condition")) {
  [14:21:08.332]                         computeRestarts <- base::computeRestarts
  [14:21:08.332]                         grepl <- base::grepl
  [14:21:08.332]                         is.null <- base::is.null
  [14:21:08.332]                         restarts <- computeRestarts(cond)
  [14:21:08.332]                         for (restart in restarts) {
  [14:21:08.332]                           name <- restart$name
  [14:21:08.332]                           if (is.null(name)) 
  [14:21:08.332]                             next
  [14:21:08.332]                           if (!grepl("^muffle", name)) 
  [14:21:08.332]                             next
  [14:21:08.332]                           invokeRestart(restart)
  [14:21:08.332]                           muffled <- TRUE
  [14:21:08.332]                           break
  [14:21:08.332]                         }
  [14:21:08.332]                       }
  [14:21:08.332]                       invisible(muffled)
  [14:21:08.332]                     }
  [14:21:08.332]                     muffleCondition(cond)
  [14:21:08.332]                   }
  [14:21:08.332]                 }
  [14:21:08.332]             }
  [14:21:08.332]         }))
  [14:21:08.332]     }, error = function(ex) {
  [14:21:08.332]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.332]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.332]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.332]     }, finally = {
  [14:21:08.332]         {
  [14:21:08.332]             NULL
  [14:21:08.332]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.332]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.332]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.332]                 label = NULL, ...) 
  [14:21:08.332]             {
  [14:21:08.332]                 if (substitute) 
  [14:21:08.332]                   expr <- substitute(expr)
  [14:21:08.332]                 local <- as.logical(local)
  [14:21:08.332]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.332]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.332]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.332]                   label = label, ...)
  [14:21:08.332]                 if (!future$lazy) 
  [14:21:08.332]                   future <- run(future)
  [14:21:08.332]                 invisible(future)
  [14:21:08.332]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.332]         }
  [14:21:08.332]         base::options(...future.oldOptions)
  [14:21:08.332]     })
  [14:21:08.332]     Sys.time
  [14:21:08.332]     if (base::is.na(TRUE)) {
  [14:21:08.332]     }
  [14:21:08.332]     else {
  [14:21:08.332]         base::sink(type = "output", split = FALSE)
  [14:21:08.332]         if (TRUE) {
  [14:21:08.332]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.332]         }
  [14:21:08.332]         else {
  [14:21:08.332]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.332]         }
  [14:21:08.332]         base::close(...future.stdout)
  [14:21:08.332]         ...future.stdout <- NULL
  [14:21:08.332]     }
  [14:21:08.332]     ...future.result$conditions <- ...future.conditions
  [14:21:08.332]     ...future.result
  [14:21:08.332] }
  [14:21:08.338] plan(): Setting new future strategy stack:
  [14:21:08.338] List of future strategies:
  [14:21:08.338] 1. sequential:
  [14:21:08.338]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.338]    - tweaked: FALSE
  [14:21:08.338]    - call: NULL
  [14:21:08.339] plan(): nbrOfWorkers() = 1
  [14:21:08.341] plan(): Setting new future strategy stack:
  [14:21:08.341] List of future strategies:
  [14:21:08.341] 1. sequential:
  [14:21:08.341]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.341]    - tweaked: FALSE
  [14:21:08.341]    - call: plan(strategy)
  [14:21:08.342] plan(): nbrOfWorkers() = 1
  [14:21:08.343] SequentialFuture started (and completed)
  [14:21:08.344] getGlobalsAndPackages() ...
  [14:21:08.344] Searching for globals...
  [14:21:08.346] - globals found: [1] '{'
  [14:21:08.346] Searching for globals ... DONE
  [14:21:08.347] Resolving globals: FALSE
  [14:21:08.347] 
  [14:21:08.348] 
  [14:21:08.348] getGlobalsAndPackages() ... DONE
  [14:21:08.351] Packages needed by the future expression (n = 0): <none>
  [14:21:08.351] Packages needed by future strategies (n = 0): <none>
  [14:21:08.357] {
  [14:21:08.357]     {
  [14:21:08.357]         ...future.startTime <- base::Sys.time()
  [14:21:08.357]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.357]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.357]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.357]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.357]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.357]         {
  [14:21:08.357]             {
  [14:21:08.357]                 has_future <- base::requireNamespace("future", 
  [14:21:08.357]                   quietly = TRUE)
  [14:21:08.357]                 version <- if (has_future) 
  [14:21:08.357]                   utils::packageVersion("future")
  [14:21:08.357]                 else NULL
  [14:21:08.357]                 if (!has_future || version < "1.8.0") {
  [14:21:08.357]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.357]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.357]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.357]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.357]                       "release", "version")], collapse = " "), 
  [14:21:08.357]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.357]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.357]                     info)
  [14:21:08.357]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.357]                   if (!has_future) {
  [14:21:08.357]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.357]                       info)
  [14:21:08.357]                   }
  [14:21:08.357]                   else {
  [14:21:08.357]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.357]                       info, version)
  [14:21:08.357]                   }
  [14:21:08.357]                   base::stop(msg)
  [14:21:08.357]                 }
  [14:21:08.357]             }
  [14:21:08.357]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.357]         }
  [14:21:08.357]     }
  [14:21:08.357]     if (base::is.na(TRUE)) {
  [14:21:08.357]     }
  [14:21:08.357]     else {
  [14:21:08.357]         if (TRUE) {
  [14:21:08.357]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.357]                 open = "w")
  [14:21:08.357]         }
  [14:21:08.357]         else {
  [14:21:08.357]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.357]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.357]         }
  [14:21:08.357]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.357]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.357]             base::sink(type = "output", split = FALSE)
  [14:21:08.357]             base::close(...future.stdout)
  [14:21:08.357]         }, add = TRUE)
  [14:21:08.357]     }
  [14:21:08.357]     ...future.frame <- base::sys.nframe()
  [14:21:08.357]     ...future.conditions <- base::list()
  [14:21:08.357]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.357]     ...future.result <- base::tryCatch({
  [14:21:08.357]         base::withCallingHandlers({
  [14:21:08.357]             ...future.value <- base::withVisible(base::local({
  [14:21:08.357]                 4
  [14:21:08.357]             }))
  [14:21:08.357]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.357]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.357]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.357]                 version = "1.8")
  [14:21:08.357]         }, condition = base::local({
  [14:21:08.357]             c <- base::c
  [14:21:08.357]             inherits <- base::inherits
  [14:21:08.357]             invokeRestart <- base::invokeRestart
  [14:21:08.357]             length <- base::length
  [14:21:08.357]             list <- base::list
  [14:21:08.357]             seq.int <- base::seq.int
  [14:21:08.357]             signalCondition <- base::signalCondition
  [14:21:08.357]             sys.calls <- base::sys.calls
  [14:21:08.357]             Sys.time <- base::Sys.time
  [14:21:08.357]             `[[` <- base::`[[`
  [14:21:08.357]             `+` <- base::`+`
  [14:21:08.357]             `<<-` <- base::`<<-`
  [14:21:08.357]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.357]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.357]                   3L)]
  [14:21:08.357]             }
  [14:21:08.357]             function(cond) {
  [14:21:08.357]                 if (inherits(cond, "error")) {
  [14:21:08.357]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.357]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.357]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.357]                   signalCondition(cond)
  [14:21:08.357]                 }
  [14:21:08.357]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.357]                 ))) {
  [14:21:08.357]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.357]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.357]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.357]                   if (!signal) {
  [14:21:08.357]                     muffleCondition <- function (cond) 
  [14:21:08.357]                     {
  [14:21:08.357]                       inherits <- base::inherits
  [14:21:08.357]                       invokeRestart <- base::invokeRestart
  [14:21:08.357]                       muffled <- FALSE
  [14:21:08.357]                       if (inherits(cond, "message")) {
  [14:21:08.357]                         invokeRestart("muffleMessage")
  [14:21:08.357]                         muffled <- TRUE
  [14:21:08.357]                       }
  [14:21:08.357]                       else if (inherits(cond, "warning")) {
  [14:21:08.357]                         invokeRestart("muffleWarning")
  [14:21:08.357]                         muffled <- TRUE
  [14:21:08.357]                       }
  [14:21:08.357]                       else if (inherits(cond, "condition")) {
  [14:21:08.357]                         computeRestarts <- base::computeRestarts
  [14:21:08.357]                         grepl <- base::grepl
  [14:21:08.357]                         is.null <- base::is.null
  [14:21:08.357]                         restarts <- computeRestarts(cond)
  [14:21:08.357]                         for (restart in restarts) {
  [14:21:08.357]                           name <- restart$name
  [14:21:08.357]                           if (is.null(name)) 
  [14:21:08.357]                             next
  [14:21:08.357]                           if (!grepl("^muffle", name)) 
  [14:21:08.357]                             next
  [14:21:08.357]                           invokeRestart(restart)
  [14:21:08.357]                           muffled <- TRUE
  [14:21:08.357]                           break
  [14:21:08.357]                         }
  [14:21:08.357]                       }
  [14:21:08.357]                       invisible(muffled)
  [14:21:08.357]                     }
  [14:21:08.357]                     muffleCondition(cond)
  [14:21:08.357]                   }
  [14:21:08.357]                 }
  [14:21:08.357]             }
  [14:21:08.357]         }))
  [14:21:08.357]     }, error = function(ex) {
  [14:21:08.357]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.357]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.357]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.357]     }, finally = {
  [14:21:08.357]         {
  [14:21:08.357]             NULL
  [14:21:08.357]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.357]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.357]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.357]                 label = NULL, ...) 
  [14:21:08.357]             {
  [14:21:08.357]                 if (substitute) 
  [14:21:08.357]                   expr <- substitute(expr)
  [14:21:08.357]                 local <- as.logical(local)
  [14:21:08.357]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.357]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.357]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.357]                   label = label, ...)
  [14:21:08.357]                 if (!future$lazy) 
  [14:21:08.357]                   future <- run(future)
  [14:21:08.357]                 invisible(future)
  [14:21:08.357]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.357]         }
  [14:21:08.357]         base::options(...future.oldOptions)
  [14:21:08.357]     })
  [14:21:08.357]     Sys.time
  [14:21:08.357]     if (base::is.na(TRUE)) {
  [14:21:08.357]     }
  [14:21:08.357]     else {
  [14:21:08.357]         base::sink(type = "output", split = FALSE)
  [14:21:08.357]         if (TRUE) {
  [14:21:08.357]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.357]         }
  [14:21:08.357]         else {
  [14:21:08.357]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.357]         }
  [14:21:08.357]         base::close(...future.stdout)
  [14:21:08.357]         ...future.stdout <- NULL
  [14:21:08.357]     }
  [14:21:08.357]     ...future.result$conditions <- ...future.conditions
  [14:21:08.357]     ...future.result
  [14:21:08.357] }
  [14:21:08.363] plan(): Setting new future strategy stack:
  [14:21:08.363] List of future strategies:
  [14:21:08.363] 1. sequential:
  [14:21:08.363]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.363]    - tweaked: FALSE
  [14:21:08.363]    - call: NULL
  [14:21:08.364] plan(): nbrOfWorkers() = 1
  [14:21:08.366] plan(): Setting new future strategy stack:
  [14:21:08.366] List of future strategies:
  [14:21:08.366] 1. sequential:
  [14:21:08.366]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.366]    - tweaked: FALSE
  [14:21:08.366]    - call: plan(strategy)
  [14:21:08.367] plan(): nbrOfWorkers() = 1
  [14:21:08.368] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x5574fa3a5ed8> 
  Classes 'listenv', 'environment' <environment: 0x5574fa75c020> 
   - 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" ...
  [14:21:08.394] resolve() on list environment ...
  [14:21:08.394]  recursive: 0
  [14:21:08.397]  length: 6
  [14:21:08.398]  elements: 'a', 'b', 'c', 'd', '', ''
  [14:21:08.398] signalConditionsASAP(numeric, pos=1) ...
  [14:21:08.398] - nx: 6
  [14:21:08.399] - relay: TRUE
  [14:21:08.399] - stdout: TRUE
  [14:21:08.399] - signal: TRUE
  [14:21:08.400] - resignal: FALSE
  [14:21:08.400] - force: TRUE
  [14:21:08.400] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.401] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.401]  - until=2
  [14:21:08.401]  - relaying element #2
  [14:21:08.402] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.402] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.402] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:08.403]  length: 5 (resolved future 1)
  [14:21:08.403] Future #2
  [14:21:08.404] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:21:08.404] - nx: 6
  [14:21:08.404] - relay: TRUE
  [14:21:08.404] - stdout: TRUE
  [14:21:08.405] - signal: TRUE
  [14:21:08.405] - resignal: FALSE
  [14:21:08.405] - force: TRUE
  [14:21:08.406] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.406] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.406]  - until=2
  [14:21:08.407]  - relaying element #2
  [14:21:08.407] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.408] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.408] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:21:08.408]  length: 4 (resolved future 2)
  [14:21:08.409] Future #3
  [14:21:08.409] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:21:08.410] - nx: 6
  [14:21:08.410] - relay: TRUE
  [14:21:08.410] - stdout: TRUE
  [14:21:08.410] - signal: TRUE
  [14:21:08.411] - resignal: FALSE
  [14:21:08.411] - force: TRUE
  [14:21:08.411] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.412] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.412]  - until=3
  [14:21:08.412]  - relaying element #3
  [14:21:08.413] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.413] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.414] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:21:08.414]  length: 3 (resolved future 3)
  [14:21:08.414] Future #4
  [14:21:08.415] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:21:08.415] - nx: 6
  [14:21:08.416] - relay: TRUE
  [14:21:08.416] - stdout: TRUE
  [14:21:08.416] - signal: TRUE
  [14:21:08.416] - resignal: FALSE
  [14:21:08.417] - force: TRUE
  [14:21:08.417] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.417] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.418]  - until=4
  [14:21:08.418]  - relaying element #4
  [14:21:08.419] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.419] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.419] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:21:08.420]  length: 2 (resolved future 4)
  [14:21:08.420] signalConditionsASAP(NULL, pos=5) ...
  [14:21:08.420] - nx: 6
  [14:21:08.421] - relay: TRUE
  [14:21:08.421] - stdout: TRUE
  [14:21:08.421] - signal: TRUE
  [14:21:08.421] - resignal: FALSE
  [14:21:08.422] - force: TRUE
  [14:21:08.422] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.422] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.423]  - until=6
  [14:21:08.423]  - relaying element #6
  [14:21:08.423] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.424] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.424] signalConditionsASAP(NULL, pos=5) ... done
  [14:21:08.424]  length: 1 (resolved future 5)
  [14:21:08.425] signalConditionsASAP(numeric, pos=6) ...
  [14:21:08.425] - nx: 6
  [14:21:08.425] - relay: TRUE
  [14:21:08.426] - stdout: TRUE
  [14:21:08.426] - signal: TRUE
  [14:21:08.426] - resignal: FALSE
  [14:21:08.427] - force: TRUE
  [14:21:08.427] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.427] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.428]  - until=6
  [14:21:08.428] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.428] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.428] signalConditionsASAP(numeric, pos=6) ... done
  [14:21:08.429]  length: 0 (resolved future 6)
  [14:21:08.429] Relaying remaining futures
  [14:21:08.429] signalConditionsASAP(NULL, pos=0) ...
  [14:21:08.430] - nx: 6
  [14:21:08.430] - relay: TRUE
  [14:21:08.430] - stdout: TRUE
  [14:21:08.431] - signal: TRUE
  [14:21:08.431] - resignal: FALSE
  [14:21:08.431] - force: TRUE
  [14:21:08.432] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.432] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [14:21:08.432] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.433] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.433] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:08.433] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x5574fa4fc6d0> 
   - 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)
  [14:21:08.440] getGlobalsAndPackages() ...
  [14:21:08.440] Searching for globals...
  [14:21:08.441] 
  [14:21:08.441] Searching for globals ... DONE
  [14:21:08.442] - globals: [0] <none>
  [14:21:08.442] getGlobalsAndPackages() ... DONE
  [14:21:08.444] Packages needed by the future expression (n = 0): <none>
  [14:21:08.445] Packages needed by future strategies (n = 0): <none>
  [14:21:08.456] {
  [14:21:08.456]     {
  [14:21:08.456]         ...future.startTime <- base::Sys.time()
  [14:21:08.456]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.456]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.456]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.456]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.456]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.456]         {
  [14:21:08.456]             {
  [14:21:08.456]                 has_future <- base::requireNamespace("future", 
  [14:21:08.456]                   quietly = TRUE)
  [14:21:08.456]                 version <- if (has_future) 
  [14:21:08.456]                   utils::packageVersion("future")
  [14:21:08.456]                 else NULL
  [14:21:08.456]                 if (!has_future || version < "1.8.0") {
  [14:21:08.456]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.456]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.456]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.456]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.456]                       "release", "version")], collapse = " "), 
  [14:21:08.456]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.456]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.456]                     info)
  [14:21:08.456]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.456]                   if (!has_future) {
  [14:21:08.456]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.456]                       info)
  [14:21:08.456]                   }
  [14:21:08.456]                   else {
  [14:21:08.456]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.456]                       info, version)
  [14:21:08.456]                   }
  [14:21:08.456]                   base::stop(msg)
  [14:21:08.456]                 }
  [14:21:08.456]             }
  [14:21:08.456]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.456]         }
  [14:21:08.456]     }
  [14:21:08.456]     if (base::is.na(TRUE)) {
  [14:21:08.456]     }
  [14:21:08.456]     else {
  [14:21:08.456]         if (TRUE) {
  [14:21:08.456]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.456]                 open = "w")
  [14:21:08.456]         }
  [14:21:08.456]         else {
  [14:21:08.456]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.456]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.456]         }
  [14:21:08.456]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.456]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.456]             base::sink(type = "output", split = FALSE)
  [14:21:08.456]             base::close(...future.stdout)
  [14:21:08.456]         }, add = TRUE)
  [14:21:08.456]     }
  [14:21:08.456]     ...future.frame <- base::sys.nframe()
  [14:21:08.456]     ...future.conditions <- base::list()
  [14:21:08.456]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.456]     ...future.result <- base::tryCatch({
  [14:21:08.456]         base::withCallingHandlers({
  [14:21:08.456]             ...future.value <- base::withVisible(base::local(2))
  [14:21:08.456]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.456]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.456]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.456]                 version = "1.8")
  [14:21:08.456]         }, condition = base::local({
  [14:21:08.456]             c <- base::c
  [14:21:08.456]             inherits <- base::inherits
  [14:21:08.456]             invokeRestart <- base::invokeRestart
  [14:21:08.456]             length <- base::length
  [14:21:08.456]             list <- base::list
  [14:21:08.456]             seq.int <- base::seq.int
  [14:21:08.456]             signalCondition <- base::signalCondition
  [14:21:08.456]             sys.calls <- base::sys.calls
  [14:21:08.456]             Sys.time <- base::Sys.time
  [14:21:08.456]             `[[` <- base::`[[`
  [14:21:08.456]             `+` <- base::`+`
  [14:21:08.456]             `<<-` <- base::`<<-`
  [14:21:08.456]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.456]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.456]                   3L)]
  [14:21:08.456]             }
  [14:21:08.456]             function(cond) {
  [14:21:08.456]                 if (inherits(cond, "error")) {
  [14:21:08.456]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.456]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.456]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.456]                   signalCondition(cond)
  [14:21:08.456]                 }
  [14:21:08.456]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.456]                 ))) {
  [14:21:08.456]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.456]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.456]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.456]                   if (!signal) {
  [14:21:08.456]                     muffleCondition <- function (cond) 
  [14:21:08.456]                     {
  [14:21:08.456]                       inherits <- base::inherits
  [14:21:08.456]                       invokeRestart <- base::invokeRestart
  [14:21:08.456]                       muffled <- FALSE
  [14:21:08.456]                       if (inherits(cond, "message")) {
  [14:21:08.456]                         invokeRestart("muffleMessage")
  [14:21:08.456]                         muffled <- TRUE
  [14:21:08.456]                       }
  [14:21:08.456]                       else if (inherits(cond, "warning")) {
  [14:21:08.456]                         invokeRestart("muffleWarning")
  [14:21:08.456]                         muffled <- TRUE
  [14:21:08.456]                       }
  [14:21:08.456]                       else if (inherits(cond, "condition")) {
  [14:21:08.456]                         computeRestarts <- base::computeRestarts
  [14:21:08.456]                         grepl <- base::grepl
  [14:21:08.456]                         is.null <- base::is.null
  [14:21:08.456]                         restarts <- computeRestarts(cond)
  [14:21:08.456]                         for (restart in restarts) {
  [14:21:08.456]                           name <- restart$name
  [14:21:08.456]                           if (is.null(name)) 
  [14:21:08.456]                             next
  [14:21:08.456]                           if (!grepl("^muffle", name)) 
  [14:21:08.456]                             next
  [14:21:08.456]                           invokeRestart(restart)
  [14:21:08.456]                           muffled <- TRUE
  [14:21:08.456]                           break
  [14:21:08.456]                         }
  [14:21:08.456]                       }
  [14:21:08.456]                       invisible(muffled)
  [14:21:08.456]                     }
  [14:21:08.456]                     muffleCondition(cond)
  [14:21:08.456]                   }
  [14:21:08.456]                 }
  [14:21:08.456]             }
  [14:21:08.456]         }))
  [14:21:08.456]     }, error = function(ex) {
  [14:21:08.456]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.456]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.456]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.456]     }, finally = {
  [14:21:08.456]         {
  [14:21:08.456]             NULL
  [14:21:08.456]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.456]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.456]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.456]                 label = NULL, ...) 
  [14:21:08.456]             {
  [14:21:08.456]                 if (substitute) 
  [14:21:08.456]                   expr <- substitute(expr)
  [14:21:08.456]                 local <- as.logical(local)
  [14:21:08.456]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.456]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.456]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.456]                   label = label, ...)
  [14:21:08.456]                 if (!future$lazy) 
  [14:21:08.456]                   future <- run(future)
  [14:21:08.456]                 invisible(future)
  [14:21:08.456]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.456]         }
  [14:21:08.456]         base::options(...future.oldOptions)
  [14:21:08.456]     })
  [14:21:08.456]     Sys.time
  [14:21:08.456]     if (base::is.na(TRUE)) {
  [14:21:08.456]     }
  [14:21:08.456]     else {
  [14:21:08.456]         base::sink(type = "output", split = FALSE)
  [14:21:08.456]         if (TRUE) {
  [14:21:08.456]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.456]         }
  [14:21:08.456]         else {
  [14:21:08.456]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.456]         }
  [14:21:08.456]         base::close(...future.stdout)
  [14:21:08.456]         ...future.stdout <- NULL
  [14:21:08.456]     }
  [14:21:08.456]     ...future.result$conditions <- ...future.conditions
  [14:21:08.456]     ...future.result
  [14:21:08.456] }
  [14:21:08.462] plan(): Setting new future strategy stack:
  [14:21:08.462] List of future strategies:
  [14:21:08.462] 1. sequential:
  [14:21:08.462]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.462]    - tweaked: FALSE
  [14:21:08.462]    - call: NULL
  [14:21:08.463] plan(): nbrOfWorkers() = 1
  [14:21:08.465] plan(): Setting new future strategy stack:
  [14:21:08.465] List of future strategies:
  [14:21:08.465] 1. sequential:
  [14:21:08.465]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.465]    - tweaked: FALSE
  [14:21:08.465]    - call: plan(strategy)
  [14:21:08.466] plan(): nbrOfWorkers() = 1
  [14:21:08.467] SequentialFuture started (and completed)
  [14:21:08.467] getGlobalsAndPackages() ...
  [14:21:08.467] Searching for globals...
  [14:21:08.468] 
  [14:21:08.468] Searching for globals ... DONE
  [14:21:08.469] - globals: [0] <none>
  [14:21:08.469] getGlobalsAndPackages() ... DONE
  [14:21:08.471] Packages needed by the future expression (n = 0): <none>
  [14:21:08.472] Packages needed by future strategies (n = 0): <none>
  [14:21:08.477] {
  [14:21:08.477]     {
  [14:21:08.477]         ...future.startTime <- base::Sys.time()
  [14:21:08.477]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.477]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.477]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.477]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.477]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.477]         {
  [14:21:08.477]             {
  [14:21:08.477]                 has_future <- base::requireNamespace("future", 
  [14:21:08.477]                   quietly = TRUE)
  [14:21:08.477]                 version <- if (has_future) 
  [14:21:08.477]                   utils::packageVersion("future")
  [14:21:08.477]                 else NULL
  [14:21:08.477]                 if (!has_future || version < "1.8.0") {
  [14:21:08.477]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.477]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.477]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.477]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.477]                       "release", "version")], collapse = " "), 
  [14:21:08.477]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.477]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.477]                     info)
  [14:21:08.477]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.477]                   if (!has_future) {
  [14:21:08.477]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.477]                       info)
  [14:21:08.477]                   }
  [14:21:08.477]                   else {
  [14:21:08.477]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.477]                       info, version)
  [14:21:08.477]                   }
  [14:21:08.477]                   base::stop(msg)
  [14:21:08.477]                 }
  [14:21:08.477]             }
  [14:21:08.477]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.477]         }
  [14:21:08.477]     }
  [14:21:08.477]     if (base::is.na(TRUE)) {
  [14:21:08.477]     }
  [14:21:08.477]     else {
  [14:21:08.477]         if (TRUE) {
  [14:21:08.477]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.477]                 open = "w")
  [14:21:08.477]         }
  [14:21:08.477]         else {
  [14:21:08.477]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.477]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.477]         }
  [14:21:08.477]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.477]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.477]             base::sink(type = "output", split = FALSE)
  [14:21:08.477]             base::close(...future.stdout)
  [14:21:08.477]         }, add = TRUE)
  [14:21:08.477]     }
  [14:21:08.477]     ...future.frame <- base::sys.nframe()
  [14:21:08.477]     ...future.conditions <- base::list()
  [14:21:08.477]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.477]     ...future.result <- base::tryCatch({
  [14:21:08.477]         base::withCallingHandlers({
  [14:21:08.477]             ...future.value <- base::withVisible(base::local(NULL))
  [14:21:08.477]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.477]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.477]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.477]                 version = "1.8")
  [14:21:08.477]         }, condition = base::local({
  [14:21:08.477]             c <- base::c
  [14:21:08.477]             inherits <- base::inherits
  [14:21:08.477]             invokeRestart <- base::invokeRestart
  [14:21:08.477]             length <- base::length
  [14:21:08.477]             list <- base::list
  [14:21:08.477]             seq.int <- base::seq.int
  [14:21:08.477]             signalCondition <- base::signalCondition
  [14:21:08.477]             sys.calls <- base::sys.calls
  [14:21:08.477]             Sys.time <- base::Sys.time
  [14:21:08.477]             `[[` <- base::`[[`
  [14:21:08.477]             `+` <- base::`+`
  [14:21:08.477]             `<<-` <- base::`<<-`
  [14:21:08.477]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.477]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.477]                   3L)]
  [14:21:08.477]             }
  [14:21:08.477]             function(cond) {
  [14:21:08.477]                 if (inherits(cond, "error")) {
  [14:21:08.477]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.477]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.477]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.477]                   signalCondition(cond)
  [14:21:08.477]                 }
  [14:21:08.477]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.477]                 ))) {
  [14:21:08.477]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.477]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.477]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.477]                   if (!signal) {
  [14:21:08.477]                     muffleCondition <- function (cond) 
  [14:21:08.477]                     {
  [14:21:08.477]                       inherits <- base::inherits
  [14:21:08.477]                       invokeRestart <- base::invokeRestart
  [14:21:08.477]                       muffled <- FALSE
  [14:21:08.477]                       if (inherits(cond, "message")) {
  [14:21:08.477]                         invokeRestart("muffleMessage")
  [14:21:08.477]                         muffled <- TRUE
  [14:21:08.477]                       }
  [14:21:08.477]                       else if (inherits(cond, "warning")) {
  [14:21:08.477]                         invokeRestart("muffleWarning")
  [14:21:08.477]                         muffled <- TRUE
  [14:21:08.477]                       }
  [14:21:08.477]                       else if (inherits(cond, "condition")) {
  [14:21:08.477]                         computeRestarts <- base::computeRestarts
  [14:21:08.477]                         grepl <- base::grepl
  [14:21:08.477]                         is.null <- base::is.null
  [14:21:08.477]                         restarts <- computeRestarts(cond)
  [14:21:08.477]                         for (restart in restarts) {
  [14:21:08.477]                           name <- restart$name
  [14:21:08.477]                           if (is.null(name)) 
  [14:21:08.477]                             next
  [14:21:08.477]                           if (!grepl("^muffle", name)) 
  [14:21:08.477]                             next
  [14:21:08.477]                           invokeRestart(restart)
  [14:21:08.477]                           muffled <- TRUE
  [14:21:08.477]                           break
  [14:21:08.477]                         }
  [14:21:08.477]                       }
  [14:21:08.477]                       invisible(muffled)
  [14:21:08.477]                     }
  [14:21:08.477]                     muffleCondition(cond)
  [14:21:08.477]                   }
  [14:21:08.477]                 }
  [14:21:08.477]             }
  [14:21:08.477]         }))
  [14:21:08.477]     }, error = function(ex) {
  [14:21:08.477]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.477]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.477]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.477]     }, finally = {
  [14:21:08.477]         {
  [14:21:08.477]             NULL
  [14:21:08.477]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.477]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.477]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.477]                 label = NULL, ...) 
  [14:21:08.477]             {
  [14:21:08.477]                 if (substitute) 
  [14:21:08.477]                   expr <- substitute(expr)
  [14:21:08.477]                 local <- as.logical(local)
  [14:21:08.477]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.477]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.477]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.477]                   label = label, ...)
  [14:21:08.477]                 if (!future$lazy) 
  [14:21:08.477]                   future <- run(future)
  [14:21:08.477]                 invisible(future)
  [14:21:08.477]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.477]         }
  [14:21:08.477]         base::options(...future.oldOptions)
  [14:21:08.477]     })
  [14:21:08.477]     Sys.time
  [14:21:08.477]     if (base::is.na(TRUE)) {
  [14:21:08.477]     }
  [14:21:08.477]     else {
  [14:21:08.477]         base::sink(type = "output", split = FALSE)
  [14:21:08.477]         if (TRUE) {
  [14:21:08.477]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.477]         }
  [14:21:08.477]         else {
  [14:21:08.477]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.477]         }
  [14:21:08.477]         base::close(...future.stdout)
  [14:21:08.477]         ...future.stdout <- NULL
  [14:21:08.477]     }
  [14:21:08.477]     ...future.result$conditions <- ...future.conditions
  [14:21:08.477]     ...future.result
  [14:21:08.477] }
  [14:21:08.483] plan(): Setting new future strategy stack:
  [14:21:08.483] List of future strategies:
  [14:21:08.483] 1. sequential:
  [14:21:08.483]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.483]    - tweaked: FALSE
  [14:21:08.483]    - call: NULL
  [14:21:08.484] plan(): nbrOfWorkers() = 1
  [14:21:08.486] plan(): Setting new future strategy stack:
  [14:21:08.486] List of future strategies:
  [14:21:08.486] 1. sequential:
  [14:21:08.486]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.486]    - tweaked: FALSE
  [14:21:08.486]    - call: plan(strategy)
  [14:21:08.487] plan(): nbrOfWorkers() = 1
  [14:21:08.488] SequentialFuture started (and completed)
  [14:21:08.489] getGlobalsAndPackages() ...
  [14:21:08.489] Searching for globals...
  [14:21:08.491] - globals found: [1] '{'
  [14:21:08.491] Searching for globals ... DONE
  [14:21:08.492] Resolving globals: FALSE
  [14:21:08.492] 
  [14:21:08.493] 
  [14:21:08.493] getGlobalsAndPackages() ... DONE
  [14:21:08.496] Packages needed by the future expression (n = 0): <none>
  [14:21:08.496] Packages needed by future strategies (n = 0): <none>
  [14:21:08.502] {
  [14:21:08.502]     {
  [14:21:08.502]         ...future.startTime <- base::Sys.time()
  [14:21:08.502]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.502]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.502]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.502]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.502]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.502]         {
  [14:21:08.502]             {
  [14:21:08.502]                 has_future <- base::requireNamespace("future", 
  [14:21:08.502]                   quietly = TRUE)
  [14:21:08.502]                 version <- if (has_future) 
  [14:21:08.502]                   utils::packageVersion("future")
  [14:21:08.502]                 else NULL
  [14:21:08.502]                 if (!has_future || version < "1.8.0") {
  [14:21:08.502]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.502]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.502]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.502]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.502]                       "release", "version")], collapse = " "), 
  [14:21:08.502]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.502]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.502]                     info)
  [14:21:08.502]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.502]                   if (!has_future) {
  [14:21:08.502]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.502]                       info)
  [14:21:08.502]                   }
  [14:21:08.502]                   else {
  [14:21:08.502]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.502]                       info, version)
  [14:21:08.502]                   }
  [14:21:08.502]                   base::stop(msg)
  [14:21:08.502]                 }
  [14:21:08.502]             }
  [14:21:08.502]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.502]         }
  [14:21:08.502]     }
  [14:21:08.502]     if (base::is.na(TRUE)) {
  [14:21:08.502]     }
  [14:21:08.502]     else {
  [14:21:08.502]         if (TRUE) {
  [14:21:08.502]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.502]                 open = "w")
  [14:21:08.502]         }
  [14:21:08.502]         else {
  [14:21:08.502]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.502]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.502]         }
  [14:21:08.502]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.502]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.502]             base::sink(type = "output", split = FALSE)
  [14:21:08.502]             base::close(...future.stdout)
  [14:21:08.502]         }, add = TRUE)
  [14:21:08.502]     }
  [14:21:08.502]     ...future.frame <- base::sys.nframe()
  [14:21:08.502]     ...future.conditions <- base::list()
  [14:21:08.502]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.502]     ...future.result <- base::tryCatch({
  [14:21:08.502]         base::withCallingHandlers({
  [14:21:08.502]             ...future.value <- base::withVisible(base::local({
  [14:21:08.502]                 4
  [14:21:08.502]             }))
  [14:21:08.502]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.502]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.502]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.502]                 version = "1.8")
  [14:21:08.502]         }, condition = base::local({
  [14:21:08.502]             c <- base::c
  [14:21:08.502]             inherits <- base::inherits
  [14:21:08.502]             invokeRestart <- base::invokeRestart
  [14:21:08.502]             length <- base::length
  [14:21:08.502]             list <- base::list
  [14:21:08.502]             seq.int <- base::seq.int
  [14:21:08.502]             signalCondition <- base::signalCondition
  [14:21:08.502]             sys.calls <- base::sys.calls
  [14:21:08.502]             Sys.time <- base::Sys.time
  [14:21:08.502]             `[[` <- base::`[[`
  [14:21:08.502]             `+` <- base::`+`
  [14:21:08.502]             `<<-` <- base::`<<-`
  [14:21:08.502]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.502]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.502]                   3L)]
  [14:21:08.502]             }
  [14:21:08.502]             function(cond) {
  [14:21:08.502]                 if (inherits(cond, "error")) {
  [14:21:08.502]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.502]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.502]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.502]                   signalCondition(cond)
  [14:21:08.502]                 }
  [14:21:08.502]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.502]                 ))) {
  [14:21:08.502]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.502]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.502]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.502]                   if (!signal) {
  [14:21:08.502]                     muffleCondition <- function (cond) 
  [14:21:08.502]                     {
  [14:21:08.502]                       inherits <- base::inherits
  [14:21:08.502]                       invokeRestart <- base::invokeRestart
  [14:21:08.502]                       muffled <- FALSE
  [14:21:08.502]                       if (inherits(cond, "message")) {
  [14:21:08.502]                         invokeRestart("muffleMessage")
  [14:21:08.502]                         muffled <- TRUE
  [14:21:08.502]                       }
  [14:21:08.502]                       else if (inherits(cond, "warning")) {
  [14:21:08.502]                         invokeRestart("muffleWarning")
  [14:21:08.502]                         muffled <- TRUE
  [14:21:08.502]                       }
  [14:21:08.502]                       else if (inherits(cond, "condition")) {
  [14:21:08.502]                         computeRestarts <- base::computeRestarts
  [14:21:08.502]                         grepl <- base::grepl
  [14:21:08.502]                         is.null <- base::is.null
  [14:21:08.502]                         restarts <- computeRestarts(cond)
  [14:21:08.502]                         for (restart in restarts) {
  [14:21:08.502]                           name <- restart$name
  [14:21:08.502]                           if (is.null(name)) 
  [14:21:08.502]                             next
  [14:21:08.502]                           if (!grepl("^muffle", name)) 
  [14:21:08.502]                             next
  [14:21:08.502]                           invokeRestart(restart)
  [14:21:08.502]                           muffled <- TRUE
  [14:21:08.502]                           break
  [14:21:08.502]                         }
  [14:21:08.502]                       }
  [14:21:08.502]                       invisible(muffled)
  [14:21:08.502]                     }
  [14:21:08.502]                     muffleCondition(cond)
  [14:21:08.502]                   }
  [14:21:08.502]                 }
  [14:21:08.502]             }
  [14:21:08.502]         }))
  [14:21:08.502]     }, error = function(ex) {
  [14:21:08.502]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.502]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.502]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.502]     }, finally = {
  [14:21:08.502]         {
  [14:21:08.502]             NULL
  [14:21:08.502]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.502]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.502]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.502]                 label = NULL, ...) 
  [14:21:08.502]             {
  [14:21:08.502]                 if (substitute) 
  [14:21:08.502]                   expr <- substitute(expr)
  [14:21:08.502]                 local <- as.logical(local)
  [14:21:08.502]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.502]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.502]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.502]                   label = label, ...)
  [14:21:08.502]                 if (!future$lazy) 
  [14:21:08.502]                   future <- run(future)
  [14:21:08.502]                 invisible(future)
  [14:21:08.502]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.502]         }
  [14:21:08.502]         base::options(...future.oldOptions)
  [14:21:08.502]     })
  [14:21:08.502]     Sys.time
  [14:21:08.502]     if (base::is.na(TRUE)) {
  [14:21:08.502]     }
  [14:21:08.502]     else {
  [14:21:08.502]         base::sink(type = "output", split = FALSE)
  [14:21:08.502]         if (TRUE) {
  [14:21:08.502]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.502]         }
  [14:21:08.502]         else {
  [14:21:08.502]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.502]         }
  [14:21:08.502]         base::close(...future.stdout)
  [14:21:08.502]         ...future.stdout <- NULL
  [14:21:08.502]     }
  [14:21:08.502]     ...future.result$conditions <- ...future.conditions
  [14:21:08.502]     ...future.result
  [14:21:08.502] }
  [14:21:08.508] plan(): Setting new future strategy stack:
  [14:21:08.508] List of future strategies:
  [14:21:08.508] 1. sequential:
  [14:21:08.508]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.508]    - tweaked: FALSE
  [14:21:08.508]    - call: NULL
  [14:21:08.509] plan(): nbrOfWorkers() = 1
  [14:21:08.511] plan(): Setting new future strategy stack:
  [14:21:08.511] List of future strategies:
  [14:21:08.511] 1. sequential:
  [14:21:08.511]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.511]    - tweaked: FALSE
  [14:21:08.511]    - call: plan(strategy)
  [14:21:08.512] plan(): nbrOfWorkers() = 1
  [14:21:08.513] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x5574fa831318> 
  Classes 'listenv', 'environment' <environment: 0x5574fab1de98> 
   - 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" ...
  [14:21:08.537] resolve() on list environment ...
  [14:21:08.537]  recursive: 0
  [14:21:08.540]  length: 6
  [14:21:08.541]  elements: 'a', 'b', 'c', 'd', '', ''
  [14:21:08.541] signalConditionsASAP(numeric, pos=1) ...
  [14:21:08.541] - nx: 6
  [14:21:08.542] - relay: TRUE
  [14:21:08.542] - stdout: TRUE
  [14:21:08.542] - signal: TRUE
  [14:21:08.543] - resignal: FALSE
  [14:21:08.543] - force: TRUE
  [14:21:08.543] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.544] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.544]  - until=2
  [14:21:08.544]  - relaying element #2
  [14:21:08.545] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.545] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.545] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:08.546]  length: 5 (resolved future 1)
  [14:21:08.546] Future #2
  [14:21:08.547] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:21:08.547] - nx: 6
  [14:21:08.547] - relay: TRUE
  [14:21:08.547] - stdout: TRUE
  [14:21:08.548] - signal: TRUE
  [14:21:08.548] - resignal: FALSE
  [14:21:08.548] - force: TRUE
  [14:21:08.549] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.549] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.549]  - until=2
  [14:21:08.550]  - relaying element #2
  [14:21:08.550] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.551] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.551] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:21:08.551]  length: 4 (resolved future 2)
  [14:21:08.552] Future #3
  [14:21:08.552] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:21:08.552] - nx: 6
  [14:21:08.553] - relay: TRUE
  [14:21:08.553] - stdout: TRUE
  [14:21:08.553] - signal: TRUE
  [14:21:08.554] - resignal: FALSE
  [14:21:08.554] - force: TRUE
  [14:21:08.554] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.555] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.555]  - until=3
  [14:21:08.555]  - relaying element #3
  [14:21:08.556] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.556] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.557] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:21:08.557]  length: 3 (resolved future 3)
  [14:21:08.557] Future #4
  [14:21:08.558] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:21:08.558] - nx: 6
  [14:21:08.558] - relay: TRUE
  [14:21:08.559] - stdout: TRUE
  [14:21:08.559] - signal: TRUE
  [14:21:08.559] - resignal: FALSE
  [14:21:08.560] - force: TRUE
  [14:21:08.560] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.560] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.561]  - until=4
  [14:21:08.561]  - relaying element #4
  [14:21:08.561] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.562] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.562] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:21:08.562]  length: 2 (resolved future 4)
  [14:21:08.563] signalConditionsASAP(NULL, pos=5) ...
  [14:21:08.563] - nx: 6
  [14:21:08.563] - relay: TRUE
  [14:21:08.564] - stdout: TRUE
  [14:21:08.564] - signal: TRUE
  [14:21:08.564] - resignal: FALSE
  [14:21:08.565] - force: TRUE
  [14:21:08.565] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.565] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.566]  - until=6
  [14:21:08.566]  - relaying element #6
  [14:21:08.566] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.567] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.567] signalConditionsASAP(NULL, pos=5) ... done
  [14:21:08.567]  length: 1 (resolved future 5)
  [14:21:08.568] signalConditionsASAP(numeric, pos=6) ...
  [14:21:08.568] - nx: 6
  [14:21:08.568] - relay: TRUE
  [14:21:08.569] - stdout: TRUE
  [14:21:08.569] - signal: TRUE
  [14:21:08.569] - resignal: FALSE
  [14:21:08.569] - force: TRUE
  [14:21:08.570] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.570] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.570]  - until=6
  [14:21:08.571] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.571] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.571] signalConditionsASAP(numeric, pos=6) ... done
  [14:21:08.572]  length: 0 (resolved future 6)
  [14:21:08.572] Relaying remaining futures
  [14:21:08.572] signalConditionsASAP(NULL, pos=0) ...
  [14:21:08.573] - nx: 6
  [14:21:08.573] - relay: TRUE
  [14:21:08.573] - stdout: TRUE
  [14:21:08.574] - signal: TRUE
  [14:21:08.574] - resignal: FALSE
  [14:21:08.574] - force: TRUE
  [14:21:08.574] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.575] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [14:21:08.575] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.576] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.576] signalConditionsASAP(NULL, pos=0) ... done
  [14:21:08.576] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x5574f8d93ec8> 
   - 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)
  [14:21:08.582] getGlobalsAndPackages() ...
  [14:21:08.583] Searching for globals...
  [14:21:08.589] 
  [14:21:08.589] Searching for globals ... DONE
  [14:21:08.590] - globals: [0] <none>
  [14:21:08.590] getGlobalsAndPackages() ... DONE
  [14:21:08.592] Packages needed by the future expression (n = 0): <none>
  [14:21:08.593] Packages needed by future strategies (n = 0): <none>
  [14:21:08.599] {
  [14:21:08.599]     {
  [14:21:08.599]         ...future.startTime <- base::Sys.time()
  [14:21:08.599]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.599]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.599]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.599]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.599]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.599]         {
  [14:21:08.599]             {
  [14:21:08.599]                 has_future <- base::requireNamespace("future", 
  [14:21:08.599]                   quietly = TRUE)
  [14:21:08.599]                 version <- if (has_future) 
  [14:21:08.599]                   utils::packageVersion("future")
  [14:21:08.599]                 else NULL
  [14:21:08.599]                 if (!has_future || version < "1.8.0") {
  [14:21:08.599]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.599]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.599]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.599]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.599]                       "release", "version")], collapse = " "), 
  [14:21:08.599]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.599]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.599]                     info)
  [14:21:08.599]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.599]                   if (!has_future) {
  [14:21:08.599]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.599]                       info)
  [14:21:08.599]                   }
  [14:21:08.599]                   else {
  [14:21:08.599]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.599]                       info, version)
  [14:21:08.599]                   }
  [14:21:08.599]                   base::stop(msg)
  [14:21:08.599]                 }
  [14:21:08.599]             }
  [14:21:08.599]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.599]         }
  [14:21:08.599]     }
  [14:21:08.599]     if (base::is.na(TRUE)) {
  [14:21:08.599]     }
  [14:21:08.599]     else {
  [14:21:08.599]         if (TRUE) {
  [14:21:08.599]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.599]                 open = "w")
  [14:21:08.599]         }
  [14:21:08.599]         else {
  [14:21:08.599]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.599]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.599]         }
  [14:21:08.599]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.599]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.599]             base::sink(type = "output", split = FALSE)
  [14:21:08.599]             base::close(...future.stdout)
  [14:21:08.599]         }, add = TRUE)
  [14:21:08.599]     }
  [14:21:08.599]     ...future.frame <- base::sys.nframe()
  [14:21:08.599]     ...future.conditions <- base::list()
  [14:21:08.599]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.599]     ...future.result <- base::tryCatch({
  [14:21:08.599]         base::withCallingHandlers({
  [14:21:08.599]             ...future.value <- base::withVisible(base::local(2))
  [14:21:08.599]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.599]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.599]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.599]                 version = "1.8")
  [14:21:08.599]         }, condition = base::local({
  [14:21:08.599]             c <- base::c
  [14:21:08.599]             inherits <- base::inherits
  [14:21:08.599]             invokeRestart <- base::invokeRestart
  [14:21:08.599]             length <- base::length
  [14:21:08.599]             list <- base::list
  [14:21:08.599]             seq.int <- base::seq.int
  [14:21:08.599]             signalCondition <- base::signalCondition
  [14:21:08.599]             sys.calls <- base::sys.calls
  [14:21:08.599]             Sys.time <- base::Sys.time
  [14:21:08.599]             `[[` <- base::`[[`
  [14:21:08.599]             `+` <- base::`+`
  [14:21:08.599]             `<<-` <- base::`<<-`
  [14:21:08.599]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.599]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.599]                   3L)]
  [14:21:08.599]             }
  [14:21:08.599]             function(cond) {
  [14:21:08.599]                 if (inherits(cond, "error")) {
  [14:21:08.599]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.599]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.599]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.599]                   signalCondition(cond)
  [14:21:08.599]                 }
  [14:21:08.599]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.599]                 ))) {
  [14:21:08.599]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.599]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.599]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.599]                   if (!signal) {
  [14:21:08.599]                     muffleCondition <- function (cond) 
  [14:21:08.599]                     {
  [14:21:08.599]                       inherits <- base::inherits
  [14:21:08.599]                       invokeRestart <- base::invokeRestart
  [14:21:08.599]                       muffled <- FALSE
  [14:21:08.599]                       if (inherits(cond, "message")) {
  [14:21:08.599]                         invokeRestart("muffleMessage")
  [14:21:08.599]                         muffled <- TRUE
  [14:21:08.599]                       }
  [14:21:08.599]                       else if (inherits(cond, "warning")) {
  [14:21:08.599]                         invokeRestart("muffleWarning")
  [14:21:08.599]                         muffled <- TRUE
  [14:21:08.599]                       }
  [14:21:08.599]                       else if (inherits(cond, "condition")) {
  [14:21:08.599]                         computeRestarts <- base::computeRestarts
  [14:21:08.599]                         grepl <- base::grepl
  [14:21:08.599]                         is.null <- base::is.null
  [14:21:08.599]                         restarts <- computeRestarts(cond)
  [14:21:08.599]                         for (restart in restarts) {
  [14:21:08.599]                           name <- restart$name
  [14:21:08.599]                           if (is.null(name)) 
  [14:21:08.599]                             next
  [14:21:08.599]                           if (!grepl("^muffle", name)) 
  [14:21:08.599]                             next
  [14:21:08.599]                           invokeRestart(restart)
  [14:21:08.599]                           muffled <- TRUE
  [14:21:08.599]                           break
  [14:21:08.599]                         }
  [14:21:08.599]                       }
  [14:21:08.599]                       invisible(muffled)
  [14:21:08.599]                     }
  [14:21:08.599]                     muffleCondition(cond)
  [14:21:08.599]                   }
  [14:21:08.599]                 }
  [14:21:08.599]             }
  [14:21:08.599]         }))
  [14:21:08.599]     }, error = function(ex) {
  [14:21:08.599]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.599]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.599]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.599]     }, finally = {
  [14:21:08.599]         {
  [14:21:08.599]             NULL
  [14:21:08.599]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.599]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.599]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.599]                 label = NULL, ...) 
  [14:21:08.599]             {
  [14:21:08.599]                 if (substitute) 
  [14:21:08.599]                   expr <- substitute(expr)
  [14:21:08.599]                 local <- as.logical(local)
  [14:21:08.599]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.599]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.599]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.599]                   label = label, ...)
  [14:21:08.599]                 if (!future$lazy) 
  [14:21:08.599]                   future <- run(future)
  [14:21:08.599]                 invisible(future)
  [14:21:08.599]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.599]         }
  [14:21:08.599]         base::options(...future.oldOptions)
  [14:21:08.599]     })
  [14:21:08.599]     Sys.time
  [14:21:08.599]     if (base::is.na(TRUE)) {
  [14:21:08.599]     }
  [14:21:08.599]     else {
  [14:21:08.599]         base::sink(type = "output", split = FALSE)
  [14:21:08.599]         if (TRUE) {
  [14:21:08.599]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.599]         }
  [14:21:08.599]         else {
  [14:21:08.599]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.599]         }
  [14:21:08.599]         base::close(...future.stdout)
  [14:21:08.599]         ...future.stdout <- NULL
  [14:21:08.599]     }
  [14:21:08.599]     ...future.result$conditions <- ...future.conditions
  [14:21:08.599]     ...future.result
  [14:21:08.599] }
  [14:21:08.605] plan(): Setting new future strategy stack:
  [14:21:08.605] List of future strategies:
  [14:21:08.605] 1. sequential:
  [14:21:08.605]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.605]    - tweaked: FALSE
  [14:21:08.605]    - call: NULL
  [14:21:08.606] plan(): nbrOfWorkers() = 1
  [14:21:08.608] plan(): Setting new future strategy stack:
  [14:21:08.608] List of future strategies:
  [14:21:08.608] 1. sequential:
  [14:21:08.608]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.608]    - tweaked: FALSE
  [14:21:08.608]    - call: plan(strategy)
  [14:21:08.609] plan(): nbrOfWorkers() = 1
  [14:21:08.610] SequentialFuture started (and completed)
  [14:21:08.611] getGlobalsAndPackages() ...
  [14:21:08.611] Searching for globals...
  [14:21:08.612] 
  [14:21:08.612] Searching for globals ... DONE
  [14:21:08.612] - globals: [0] <none>
  [14:21:08.613] getGlobalsAndPackages() ... DONE
  [14:21:08.615] Packages needed by the future expression (n = 0): <none>
  [14:21:08.615] Packages needed by future strategies (n = 0): <none>
  [14:21:08.621] {
  [14:21:08.621]     {
  [14:21:08.621]         ...future.startTime <- base::Sys.time()
  [14:21:08.621]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.621]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.621]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.621]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.621]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.621]         {
  [14:21:08.621]             {
  [14:21:08.621]                 has_future <- base::requireNamespace("future", 
  [14:21:08.621]                   quietly = TRUE)
  [14:21:08.621]                 version <- if (has_future) 
  [14:21:08.621]                   utils::packageVersion("future")
  [14:21:08.621]                 else NULL
  [14:21:08.621]                 if (!has_future || version < "1.8.0") {
  [14:21:08.621]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.621]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.621]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.621]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.621]                       "release", "version")], collapse = " "), 
  [14:21:08.621]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.621]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.621]                     info)
  [14:21:08.621]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.621]                   if (!has_future) {
  [14:21:08.621]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.621]                       info)
  [14:21:08.621]                   }
  [14:21:08.621]                   else {
  [14:21:08.621]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.621]                       info, version)
  [14:21:08.621]                   }
  [14:21:08.621]                   base::stop(msg)
  [14:21:08.621]                 }
  [14:21:08.621]             }
  [14:21:08.621]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.621]         }
  [14:21:08.621]     }
  [14:21:08.621]     if (base::is.na(TRUE)) {
  [14:21:08.621]     }
  [14:21:08.621]     else {
  [14:21:08.621]         if (TRUE) {
  [14:21:08.621]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.621]                 open = "w")
  [14:21:08.621]         }
  [14:21:08.621]         else {
  [14:21:08.621]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.621]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.621]         }
  [14:21:08.621]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.621]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.621]             base::sink(type = "output", split = FALSE)
  [14:21:08.621]             base::close(...future.stdout)
  [14:21:08.621]         }, add = TRUE)
  [14:21:08.621]     }
  [14:21:08.621]     ...future.frame <- base::sys.nframe()
  [14:21:08.621]     ...future.conditions <- base::list()
  [14:21:08.621]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.621]     ...future.result <- base::tryCatch({
  [14:21:08.621]         base::withCallingHandlers({
  [14:21:08.621]             ...future.value <- base::withVisible(base::local(NULL))
  [14:21:08.621]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.621]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.621]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.621]                 version = "1.8")
  [14:21:08.621]         }, condition = base::local({
  [14:21:08.621]             c <- base::c
  [14:21:08.621]             inherits <- base::inherits
  [14:21:08.621]             invokeRestart <- base::invokeRestart
  [14:21:08.621]             length <- base::length
  [14:21:08.621]             list <- base::list
  [14:21:08.621]             seq.int <- base::seq.int
  [14:21:08.621]             signalCondition <- base::signalCondition
  [14:21:08.621]             sys.calls <- base::sys.calls
  [14:21:08.621]             Sys.time <- base::Sys.time
  [14:21:08.621]             `[[` <- base::`[[`
  [14:21:08.621]             `+` <- base::`+`
  [14:21:08.621]             `<<-` <- base::`<<-`
  [14:21:08.621]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.621]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.621]                   3L)]
  [14:21:08.621]             }
  [14:21:08.621]             function(cond) {
  [14:21:08.621]                 if (inherits(cond, "error")) {
  [14:21:08.621]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.621]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.621]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.621]                   signalCondition(cond)
  [14:21:08.621]                 }
  [14:21:08.621]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.621]                 ))) {
  [14:21:08.621]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.621]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.621]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.621]                   if (!signal) {
  [14:21:08.621]                     muffleCondition <- function (cond) 
  [14:21:08.621]                     {
  [14:21:08.621]                       inherits <- base::inherits
  [14:21:08.621]                       invokeRestart <- base::invokeRestart
  [14:21:08.621]                       muffled <- FALSE
  [14:21:08.621]                       if (inherits(cond, "message")) {
  [14:21:08.621]                         invokeRestart("muffleMessage")
  [14:21:08.621]                         muffled <- TRUE
  [14:21:08.621]                       }
  [14:21:08.621]                       else if (inherits(cond, "warning")) {
  [14:21:08.621]                         invokeRestart("muffleWarning")
  [14:21:08.621]                         muffled <- TRUE
  [14:21:08.621]                       }
  [14:21:08.621]                       else if (inherits(cond, "condition")) {
  [14:21:08.621]                         computeRestarts <- base::computeRestarts
  [14:21:08.621]                         grepl <- base::grepl
  [14:21:08.621]                         is.null <- base::is.null
  [14:21:08.621]                         restarts <- computeRestarts(cond)
  [14:21:08.621]                         for (restart in restarts) {
  [14:21:08.621]                           name <- restart$name
  [14:21:08.621]                           if (is.null(name)) 
  [14:21:08.621]                             next
  [14:21:08.621]                           if (!grepl("^muffle", name)) 
  [14:21:08.621]                             next
  [14:21:08.621]                           invokeRestart(restart)
  [14:21:08.621]                           muffled <- TRUE
  [14:21:08.621]                           break
  [14:21:08.621]                         }
  [14:21:08.621]                       }
  [14:21:08.621]                       invisible(muffled)
  [14:21:08.621]                     }
  [14:21:08.621]                     muffleCondition(cond)
  [14:21:08.621]                   }
  [14:21:08.621]                 }
  [14:21:08.621]             }
  [14:21:08.621]         }))
  [14:21:08.621]     }, error = function(ex) {
  [14:21:08.621]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.621]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.621]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.621]     }, finally = {
  [14:21:08.621]         {
  [14:21:08.621]             NULL
  [14:21:08.621]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.621]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.621]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.621]                 label = NULL, ...) 
  [14:21:08.621]             {
  [14:21:08.621]                 if (substitute) 
  [14:21:08.621]                   expr <- substitute(expr)
  [14:21:08.621]                 local <- as.logical(local)
  [14:21:08.621]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.621]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.621]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.621]                   label = label, ...)
  [14:21:08.621]                 if (!future$lazy) 
  [14:21:08.621]                   future <- run(future)
  [14:21:08.621]                 invisible(future)
  [14:21:08.621]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.621]         }
  [14:21:08.621]         base::options(...future.oldOptions)
  [14:21:08.621]     })
  [14:21:08.621]     Sys.time
  [14:21:08.621]     if (base::is.na(TRUE)) {
  [14:21:08.621]     }
  [14:21:08.621]     else {
  [14:21:08.621]         base::sink(type = "output", split = FALSE)
  [14:21:08.621]         if (TRUE) {
  [14:21:08.621]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.621]         }
  [14:21:08.621]         else {
  [14:21:08.621]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.621]         }
  [14:21:08.621]         base::close(...future.stdout)
  [14:21:08.621]         ...future.stdout <- NULL
  [14:21:08.621]     }
  [14:21:08.621]     ...future.result$conditions <- ...future.conditions
  [14:21:08.621]     ...future.result
  [14:21:08.621] }
  [14:21:08.627] plan(): Setting new future strategy stack:
  [14:21:08.627] List of future strategies:
  [14:21:08.627] 1. sequential:
  [14:21:08.627]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.627]    - tweaked: FALSE
  [14:21:08.627]    - call: NULL
  [14:21:08.629] plan(): nbrOfWorkers() = 1
  [14:21:08.630] plan(): Setting new future strategy stack:
  [14:21:08.630] List of future strategies:
  [14:21:08.630] 1. sequential:
  [14:21:08.630]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.630]    - tweaked: FALSE
  [14:21:08.630]    - call: plan(strategy)
  [14:21:08.631] plan(): nbrOfWorkers() = 1
  [14:21:08.632] SequentialFuture started (and completed)
  [14:21:08.633] getGlobalsAndPackages() ...
  [14:21:08.633] Searching for globals...
  [14:21:08.635] - globals found: [1] '{'
  [14:21:08.635] Searching for globals ... DONE
  [14:21:08.636] Resolving globals: FALSE
  [14:21:08.636] 
  [14:21:08.637] 
  [14:21:08.637] getGlobalsAndPackages() ... DONE
  [14:21:08.640] Packages needed by the future expression (n = 0): <none>
  [14:21:08.640] Packages needed by future strategies (n = 0): <none>
  [14:21:08.646] {
  [14:21:08.646]     {
  [14:21:08.646]         ...future.startTime <- base::Sys.time()
  [14:21:08.646]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [14:21:08.646]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [14:21:08.646]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [14:21:08.646]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [14:21:08.646]             future.resolve.recursive = NULL, width = 80L)
  [14:21:08.646]         {
  [14:21:08.646]             {
  [14:21:08.646]                 has_future <- base::requireNamespace("future", 
  [14:21:08.646]                   quietly = TRUE)
  [14:21:08.646]                 version <- if (has_future) 
  [14:21:08.646]                   utils::packageVersion("future")
  [14:21:08.646]                 else NULL
  [14:21:08.646]                 if (!has_future || version < "1.8.0") {
  [14:21:08.646]                   info <- base::c(r_version = base::gsub("R version ", 
  [14:21:08.646]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [14:21:08.646]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [14:21:08.646]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [14:21:08.646]                       "release", "version")], collapse = " "), 
  [14:21:08.646]                     hostname = base::Sys.info()[["nodename"]])
  [14:21:08.646]                   info <- base::sprintf("%s: %s", base::names(info), 
  [14:21:08.646]                     info)
  [14:21:08.646]                   info <- base::paste(info, collapse = "; ")
  [14:21:08.646]                   if (!has_future) {
  [14:21:08.646]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [14:21:08.646]                       info)
  [14:21:08.646]                   }
  [14:21:08.646]                   else {
  [14:21:08.646]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [14:21:08.646]                       info, version)
  [14:21:08.646]                   }
  [14:21:08.646]                   base::stop(msg)
  [14:21:08.646]                 }
  [14:21:08.646]             }
  [14:21:08.646]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [14:21:08.646]         }
  [14:21:08.646]     }
  [14:21:08.646]     if (base::is.na(TRUE)) {
  [14:21:08.646]     }
  [14:21:08.646]     else {
  [14:21:08.646]         if (TRUE) {
  [14:21:08.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [14:21:08.646]                 open = "w")
  [14:21:08.646]         }
  [14:21:08.646]         else {
  [14:21:08.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [14:21:08.646]                 windows = "NUL", "/dev/null"), open = "w")
  [14:21:08.646]         }
  [14:21:08.646]         base::sink(...future.stdout, type = "output", split = FALSE)
  [14:21:08.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [14:21:08.646]             base::sink(type = "output", split = FALSE)
  [14:21:08.646]             base::close(...future.stdout)
  [14:21:08.646]         }, add = TRUE)
  [14:21:08.646]     }
  [14:21:08.646]     ...future.frame <- base::sys.nframe()
  [14:21:08.646]     ...future.conditions <- base::list()
  [14:21:08.646]     ...future.rng <- base::globalenv()$.Random.seed
  [14:21:08.646]     ...future.result <- base::tryCatch({
  [14:21:08.646]         base::withCallingHandlers({
  [14:21:08.646]             ...future.value <- base::withVisible(base::local({
  [14:21:08.646]                 4
  [14:21:08.646]             }))
  [14:21:08.646]             future::FutureResult(value = ...future.value$value, 
  [14:21:08.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.646]                   ...future.rng), started = ...future.startTime, 
  [14:21:08.646]                 version = "1.8")
  [14:21:08.646]         }, condition = base::local({
  [14:21:08.646]             c <- base::c
  [14:21:08.646]             inherits <- base::inherits
  [14:21:08.646]             invokeRestart <- base::invokeRestart
  [14:21:08.646]             length <- base::length
  [14:21:08.646]             list <- base::list
  [14:21:08.646]             seq.int <- base::seq.int
  [14:21:08.646]             signalCondition <- base::signalCondition
  [14:21:08.646]             sys.calls <- base::sys.calls
  [14:21:08.646]             Sys.time <- base::Sys.time
  [14:21:08.646]             `[[` <- base::`[[`
  [14:21:08.646]             `+` <- base::`+`
  [14:21:08.646]             `<<-` <- base::`<<-`
  [14:21:08.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [14:21:08.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [14:21:08.646]                   3L)]
  [14:21:08.646]             }
  [14:21:08.646]             function(cond) {
  [14:21:08.646]                 if (inherits(cond, "error")) {
  [14:21:08.646]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [14:21:08.646]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [14:21:08.646]                   signalCondition(cond)
  [14:21:08.646]                 }
  [14:21:08.646]                 else if (inherits(cond, c("condition", "immediateCondition"
  [14:21:08.646]                 ))) {
  [14:21:08.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [14:21:08.646]                   ...future.conditions[[length(...future.conditions) + 
  [14:21:08.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [14:21:08.646]                   if (!signal) {
  [14:21:08.646]                     muffleCondition <- function (cond) 
  [14:21:08.646]                     {
  [14:21:08.646]                       inherits <- base::inherits
  [14:21:08.646]                       invokeRestart <- base::invokeRestart
  [14:21:08.646]                       muffled <- FALSE
  [14:21:08.646]                       if (inherits(cond, "message")) {
  [14:21:08.646]                         invokeRestart("muffleMessage")
  [14:21:08.646]                         muffled <- TRUE
  [14:21:08.646]                       }
  [14:21:08.646]                       else if (inherits(cond, "warning")) {
  [14:21:08.646]                         invokeRestart("muffleWarning")
  [14:21:08.646]                         muffled <- TRUE
  [14:21:08.646]                       }
  [14:21:08.646]                       else if (inherits(cond, "condition")) {
  [14:21:08.646]                         computeRestarts <- base::computeRestarts
  [14:21:08.646]                         grepl <- base::grepl
  [14:21:08.646]                         is.null <- base::is.null
  [14:21:08.646]                         restarts <- computeRestarts(cond)
  [14:21:08.646]                         for (restart in restarts) {
  [14:21:08.646]                           name <- restart$name
  [14:21:08.646]                           if (is.null(name)) 
  [14:21:08.646]                             next
  [14:21:08.646]                           if (!grepl("^muffle", name)) 
  [14:21:08.646]                             next
  [14:21:08.646]                           invokeRestart(restart)
  [14:21:08.646]                           muffled <- TRUE
  [14:21:08.646]                           break
  [14:21:08.646]                         }
  [14:21:08.646]                       }
  [14:21:08.646]                       invisible(muffled)
  [14:21:08.646]                     }
  [14:21:08.646]                     muffleCondition(cond)
  [14:21:08.646]                   }
  [14:21:08.646]                 }
  [14:21:08.646]             }
  [14:21:08.646]         }))
  [14:21:08.646]     }, error = function(ex) {
  [14:21:08.646]         base::structure(base::list(value = NULL, visible = NULL, 
  [14:21:08.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [14:21:08.646]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [14:21:08.646]     }, finally = {
  [14:21:08.646]         {
  [14:21:08.646]             NULL
  [14:21:08.646]             future::plan(list(function (expr, envir = parent.frame(), 
  [14:21:08.646]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [14:21:08.646]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [14:21:08.646]                 label = NULL, ...) 
  [14:21:08.646]             {
  [14:21:08.646]                 if (substitute) 
  [14:21:08.646]                   expr <- substitute(expr)
  [14:21:08.646]                 local <- as.logical(local)
  [14:21:08.646]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [14:21:08.646]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [14:21:08.646]                   globals = globals, local = local, earlySignal = earlySignal, 
  [14:21:08.646]                   label = label, ...)
  [14:21:08.646]                 if (!future$lazy) 
  [14:21:08.646]                   future <- run(future)
  [14:21:08.646]                 invisible(future)
  [14:21:08.646]             }), .cleanup = FALSE, .init = FALSE)
  [14:21:08.646]         }
  [14:21:08.646]         base::options(...future.oldOptions)
  [14:21:08.646]     })
  [14:21:08.646]     Sys.time
  [14:21:08.646]     if (base::is.na(TRUE)) {
  [14:21:08.646]     }
  [14:21:08.646]     else {
  [14:21:08.646]         base::sink(type = "output", split = FALSE)
  [14:21:08.646]         if (TRUE) {
  [14:21:08.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [14:21:08.646]         }
  [14:21:08.646]         else {
  [14:21:08.646]             ...future.result["stdout"] <- base::list(NULL)
  [14:21:08.646]         }
  [14:21:08.646]         base::close(...future.stdout)
  [14:21:08.646]         ...future.stdout <- NULL
  [14:21:08.646]     }
  [14:21:08.646]     ...future.result$conditions <- ...future.conditions
  [14:21:08.646]     ...future.result
  [14:21:08.646] }
  [14:21:08.652] plan(): Setting new future strategy stack:
  [14:21:08.652] List of future strategies:
  [14:21:08.652] 1. sequential:
  [14:21:08.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.652]    - tweaked: FALSE
  [14:21:08.652]    - call: NULL
  [14:21:08.653] plan(): nbrOfWorkers() = 1
  [14:21:08.655] plan(): Setting new future strategy stack:
  [14:21:08.655] List of future strategies:
  [14:21:08.655] 1. sequential:
  [14:21:08.655]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [14:21:08.655]    - tweaked: FALSE
  [14:21:08.655]    - call: plan(strategy)
  [14:21:08.656] plan(): nbrOfWorkers() = 1
  [14:21:08.663] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x5574fabe2d40> 
  Classes 'listenv', 'environment' <environment: 0x5574fa4c05a8> 
   - 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" ...
  [14:21:08.683] resolve() on list environment ...
  [14:21:08.683]  recursive: 0
  [14:21:08.687]  length: 6
  [14:21:08.687]  elements: 'a', 'b', 'c', 'd', '', ''
  [14:21:08.687] signalConditionsASAP(numeric, pos=1) ...
  [14:21:08.688] - nx: 6
  [14:21:08.688] - relay: TRUE
  [14:21:08.688] - stdout: TRUE
  [14:21:08.689] - signal: TRUE
  [14:21:08.689] - resignal: FALSE
  [14:21:08.689] - force: TRUE
  [14:21:08.690] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.690] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.690]  - until=2
  [14:21:08.691]  - relaying element #2
  [14:21:08.691] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.691] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.691] signalConditionsASAP(NULL, pos=1) ... done
  [14:21:08.692]  length: 5 (resolved future 1)
  [14:21:08.692] Future #2
  [14:21:08.693] signalConditionsASAP(SequentialFuture, pos=2) ...
  [14:21:08.693] - nx: 6
  [14:21:08.693] - relay: TRUE
  [14:21:08.694] - stdout: TRUE
  [14:21:08.694] - signal: TRUE
  [14:21:08.694] - resignal: FALSE
  [14:21:08.695] - force: TRUE
  [14:21:08.695] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.695] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.695]  - until=2
  [14:21:08.696]  - relaying element #2
  [14:21:08.696] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.697] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.697] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [14:21:08.697]  length: 4 (resolved future 2)
  [14:21:08.698] Future #3
  [14:21:08.698] signalConditionsASAP(SequentialFuture, pos=3) ...
  [14:21:08.699] - nx: 6
  [14:21:08.699] - relay: TRUE
  [14:21:08.699] - stdout: TRUE
  [14:21:08.699] - signal: TRUE
  [14:21:08.700] - resignal: FALSE
  [14:21:08.700] - force: TRUE
  [14:21:08.700] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.701] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [14:21:08.701]  - until=3
  [14:21:08.701]  - relaying element #3
  [14:21:08.702] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.702] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.703] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [14:21:08.703]  length: 3 (resolved future 3)
  [14:21:08.704] Future #4
  [14:21:08.704] signalConditionsASAP(SequentialFuture, pos=4) ...
  [14:21:08.704] - nx: 6
  [14:21:08.705] - relay: TRUE
  [14:21:08.705] - stdout: TRUE
  [14:21:08.705] - signal: TRUE
  [14:21:08.705] - resignal: FALSE
  [14:21:08.706] - force: TRUE
  [14:21:08.706] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.706] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [14:21:08.707]  - until=4
  [14:21:08.707]  - relaying element #4
  [14:21:08.707] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.708] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.708] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [14:21:08.708]  length: 2 (resolved future 4)
  [14:21:08.709] signalConditionsASAP(NULL, pos=5) ...
  [14:21:08.709] - nx: 6
  [14:21:08.709] - relay: TRUE
  [14:21:08.709] - stdout: TRUE
  [14:21:08.710] - signal: TRUE
  [14:21:08.710] - resignal: FALSE
  [14:21:08.710] - force: TRUE
  [14:21:08.711] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.711] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.711]  - until=6
  [14:21:08.712]  - relaying element #6
  [14:21:08.712] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.712] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.712] signalConditionsASAP(NULL, pos=5) ... done
  [14:21:08.713]  length: 1 (resolved future 5)
  [14:21:08.713] signalConditionsASAP(numeric, pos=6) ...
  [14:21:08.713] - nx: 6
  [14:21:08.714] - relay: TRUE
  [14:21:08.714] - stdout: TRUE
  [14:21:08.714] - signal: TRUE
  [14:21:08.715] - resignal: FALSE
  [14:21:08.715] - force: TRUE
  [14:21:08.715] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [14:21:08.716] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.716]  - until=6
  [14:21:08.716] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.717] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [14:21:08.717] signalConditionsASAP(numeric, pos=6) ... done
  [14:21:08.717]  length: 0 (resolved future 6)
  [14:21:08.718] Relaying remaining futures
  [14:21:08.718] signalConditionsASAP(NULL, pos=0) ...
  [14:21:08.718] - nx: 6
  [14:21:08.718] - relay: TRUE
  [14:21:08.719] - stdout: TRUE
  [14:21:08.719] - signal: TRUE
  [14:21:08.719] - resignal: FALSE
  [14:21:08.725] - force: TRUE
  [14:21:08.725] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [14:21:08.