Running ‘000.sessionDetails.R’ [0s/1s]
  Running ‘ClusterRegistry.R’ [3s/9s]
  Running ‘Future-class.R’ [2s/4s]
  Running ‘FutureError.R’ [1s/1s]
  Running ‘FutureGlobals.R’ [1s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/3s]
  Running ‘availableCores.R’ [1s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/1s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [7s/32s]
  Running ‘constant.R’ [1s/1s]
  Running ‘demo.R’ [10s/14s]
  Running ‘dotdotdot.R’ [2s/5s]
  Running ‘early-signaling.R’ [2s/11s]
  Running ‘future,labels.R’ [1s/1s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/6s]
  Running ‘futureAssign_OP.R’ [3s/7s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [4s/10s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [12s/27s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [4s/8s]
  Running ‘globals,manual.R’ [2s/3s]
  Running ‘globals,resolve.R’ [2s/5s]
  Running ‘globals,subassignment.R’ [3s/8s]
  Running ‘globals,toolarge.R’ [1s/4s]
  Running ‘globals,tricky.R’ [8s/14s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [2s/5s]
  Running ‘makeClusterPSOCK.R’ [1s/2s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [1s/1s]
  Running ‘multicore,multithreading.R’ [1s/1s]
  Running ‘multicore.R’ [1s/2s]
  Running ‘multiprocess.R’ [2s/3s]
  Running ‘multisession.R’ [4s/13s]
  Running ‘nbrOfWorkers.R’ [3s/13s]
  Running ‘nested_futures,mc.cores.R’ [5s/24s]
  Running ‘nested_futures.R’ [1s/1s]
  Running ‘non-exportable,connections.R’ [1s/4s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [2s/5s]
  Running ‘relaying.R’ [1s/2s]
  Running ‘remote.R’ [1s/4s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [2s/10s]
  Running ‘reserved-keyword-functions.R’ [1s/1s]
  Running ‘resolve.R’ [2s/4s]
  Running ‘resolved-non-blocking-test.R’ [3s/34s]
  Running ‘rng.R’ [12s/18s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/7s]
  Running ‘stdout.R’ [2s/5s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [1s/2s]
  Running ‘uuid.R’ [1s/1s]
  Running ‘whichIndex.R’ [1s/1s]
Running the tests in ‘tests/futures.R’ failed.
Complete output:
  > source("incl/start.R")
  [15:45:51.281] plan(): Setting new future strategy stack:
  [15:45:51.283] List of future strategies:
  [15:45:51.283] 1. sequential:
  [15:45:51.283]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.283]    - tweaked: FALSE
  [15:45:51.283]    - call: future::plan("sequential")
  [15:45:51.285] 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
  [15:45:51.523] plan(): Setting new future strategy stack:
  [15:45:51.523] List of future strategies:
  [15:45:51.523] 1. sequential:
  [15:45:51.523]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.523]    - tweaked: FALSE
  [15:45:51.523]    - call: plan(strategy)
  [15:45:51.609] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [15:45:51.612] getGlobalsAndPackages() ...
  [15:45:51.612] Searching for globals...
  [15:45:51.617] 
  [15:45:51.617] Searching for globals ... DONE
  [15:45:51.618] - globals: [0] <none>
  [15:45:51.618] getGlobalsAndPackages() ... DONE
  [15:45:51.639] Packages needed by the future expression (n = 0): <none>
  [15:45:51.639] Packages needed by future strategies (n = 0): <none>
  [15:45:51.646] {
  [15:45:51.646]     {
  [15:45:51.646]         ...future.startTime <- base::Sys.time()
  [15:45:51.646]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.646]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.646]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.646]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.646]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.646]         {
  [15:45:51.646]             {
  [15:45:51.646]                 base::local({
  [15:45:51.646]                   has_future <- base::requireNamespace("future", 
  [15:45:51.646]                     quietly = TRUE)
  [15:45:51.646]                   version <- if (has_future) 
  [15:45:51.646]                     utils::packageVersion("future")
  [15:45:51.646]                   else NULL
  [15:45:51.646]                   if (!has_future || version < "1.8.0") {
  [15:45:51.646]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.646]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.646]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.646]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.646]                         "release", "version")], collapse = " "), 
  [15:45:51.646]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.646]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.646]                       info)
  [15:45:51.646]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.646]                     if (!has_future) {
  [15:45:51.646]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.646]                         info)
  [15:45:51.646]                     }
  [15:45:51.646]                     else {
  [15:45:51.646]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.646]                         info, version)
  [15:45:51.646]                     }
  [15:45:51.646]                     base::stop(msg)
  [15:45:51.646]                   }
  [15:45:51.646]                 })
  [15:45:51.646]             }
  [15:45:51.646]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.646]         }
  [15:45:51.646]     }
  [15:45:51.646]     if (base::is.na(TRUE)) {
  [15:45:51.646]     }
  [15:45:51.646]     else {
  [15:45:51.646]         if (TRUE) {
  [15:45:51.646]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.646]                 open = "w")
  [15:45:51.646]         }
  [15:45:51.646]         else {
  [15:45:51.646]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.646]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.646]         }
  [15:45:51.646]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.646]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.646]             base::sink(type = "output", split = FALSE)
  [15:45:51.646]             base::close(...future.stdout)
  [15:45:51.646]         }, add = TRUE)
  [15:45:51.646]     }
  [15:45:51.646]     ...future.frame <- base::sys.nframe()
  [15:45:51.646]     ...future.conditions <- base::list()
  [15:45:51.646]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.646]     ...future.result <- base::tryCatch({
  [15:45:51.646]         base::withCallingHandlers({
  [15:45:51.646]             ...future.value <- base::withVisible(base::local(2))
  [15:45:51.646]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.646]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.646]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.646]                 version = "1.8")
  [15:45:51.646]         }, condition = base::local({
  [15:45:51.646]             c <- base::c
  [15:45:51.646]             inherits <- base::inherits
  [15:45:51.646]             invokeRestart <- base::invokeRestart
  [15:45:51.646]             length <- base::length
  [15:45:51.646]             list <- base::list
  [15:45:51.646]             seq.int <- base::seq.int
  [15:45:51.646]             signalCondition <- base::signalCondition
  [15:45:51.646]             sys.calls <- base::sys.calls
  [15:45:51.646]             Sys.time <- base::Sys.time
  [15:45:51.646]             `[[` <- base::`[[`
  [15:45:51.646]             `+` <- base::`+`
  [15:45:51.646]             `<<-` <- base::`<<-`
  [15:45:51.646]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.646]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.646]                   3L)]
  [15:45:51.646]             }
  [15:45:51.646]             function(cond) {
  [15:45:51.646]                 if (inherits(cond, "error")) {
  [15:45:51.646]                   sessionInformation <- function() {
  [15:45:51.646]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.646]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.646]                       search = base::search(), system = base::Sys.info())
  [15:45:51.646]                   }
  [15:45:51.646]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.646]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.646]                     cond$call), session = sessionInformation(), 
  [15:45:51.646]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.646]                   signalCondition(cond)
  [15:45:51.646]                 }
  [15:45:51.646]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.646]                 ))) {
  [15:45:51.646]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.646]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.646]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.646]                   if (!signal) {
  [15:45:51.646]                     muffleCondition <- function (cond) 
  [15:45:51.646]                     {
  [15:45:51.646]                       inherits <- base::inherits
  [15:45:51.646]                       invokeRestart <- base::invokeRestart
  [15:45:51.646]                       muffled <- FALSE
  [15:45:51.646]                       if (inherits(cond, "message")) {
  [15:45:51.646]                         invokeRestart("muffleMessage")
  [15:45:51.646]                         muffled <- TRUE
  [15:45:51.646]                       }
  [15:45:51.646]                       else if (inherits(cond, "warning")) {
  [15:45:51.646]                         invokeRestart("muffleWarning")
  [15:45:51.646]                         muffled <- TRUE
  [15:45:51.646]                       }
  [15:45:51.646]                       else if (inherits(cond, "condition")) {
  [15:45:51.646]                         computeRestarts <- base::computeRestarts
  [15:45:51.646]                         grepl <- base::grepl
  [15:45:51.646]                         is.null <- base::is.null
  [15:45:51.646]                         restarts <- computeRestarts(cond)
  [15:45:51.646]                         for (restart in restarts) {
  [15:45:51.646]                           name <- restart$name
  [15:45:51.646]                           if (is.null(name)) 
  [15:45:51.646]                             next
  [15:45:51.646]                           if (!grepl("^muffle", name)) 
  [15:45:51.646]                             next
  [15:45:51.646]                           invokeRestart(restart)
  [15:45:51.646]                           muffled <- TRUE
  [15:45:51.646]                           break
  [15:45:51.646]                         }
  [15:45:51.646]                       }
  [15:45:51.646]                       invisible(muffled)
  [15:45:51.646]                     }
  [15:45:51.646]                     muffleCondition(cond)
  [15:45:51.646]                   }
  [15:45:51.646]                 }
  [15:45:51.646]             }
  [15:45:51.646]         }))
  [15:45:51.646]     }, error = function(ex) {
  [15:45:51.646]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.646]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.646]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.646]     }, finally = {
  [15:45:51.646]         {
  [15:45:51.646]             NULL
  [15:45:51.646]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.646]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.646]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.646]                 label = NULL, ...) 
  [15:45:51.646]             {
  [15:45:51.646]                 if (substitute) 
  [15:45:51.646]                   expr <- substitute(expr)
  [15:45:51.646]                 local <- as.logical(local)
  [15:45:51.646]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.646]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.646]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.646]                   label = label, ...)
  [15:45:51.646]                 if (!future$lazy) 
  [15:45:51.646]                   future <- run(future)
  [15:45:51.646]                 invisible(future)
  [15:45:51.646]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.646]         }
  [15:45:51.646]         base::options(...future.oldOptions)
  [15:45:51.646]     })
  [15:45:51.646]     Sys.time
  [15:45:51.646]     if (base::is.na(TRUE)) {
  [15:45:51.646]     }
  [15:45:51.646]     else {
  [15:45:51.646]         base::sink(type = "output", split = FALSE)
  [15:45:51.646]         if (TRUE) {
  [15:45:51.646]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.646]         }
  [15:45:51.646]         else {
  [15:45:51.646]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.646]         }
  [15:45:51.646]         base::close(...future.stdout)
  [15:45:51.646]         ...future.stdout <- NULL
  [15:45:51.646]     }
  [15:45:51.646]     ...future.result$conditions <- ...future.conditions
  [15:45:51.646]     ...future.result
  [15:45:51.646] }
  [15:45:51.653] plan(): Setting new future strategy stack:
  [15:45:51.653] List of future strategies:
  [15:45:51.653] 1. sequential:
  [15:45:51.653]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.653]    - tweaked: FALSE
  [15:45:51.653]    - call: NULL
  [15:45:51.654] plan(): nbrOfWorkers() = 1
  [15:45:51.656] plan(): Setting new future strategy stack:
  [15:45:51.656] List of future strategies:
  [15:45:51.656] 1. sequential:
  [15:45:51.656]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.656]    - tweaked: FALSE
  [15:45:51.656]    - call: plan(strategy)
  [15:45:51.657] plan(): nbrOfWorkers() = 1
  [15:45:51.658] SequentialFuture started (and completed)
  [15:45:51.660] getGlobalsAndPackages() ...
  [15:45:51.660] Searching for globals...
  [15:45:51.661] 
  [15:45:51.661] Searching for globals ... DONE
  [15:45:51.662] - globals: [0] <none>
  [15:45:51.662] getGlobalsAndPackages() ... DONE
  [15:45:51.664] Packages needed by the future expression (n = 0): <none>
  [15:45:51.665] Packages needed by future strategies (n = 0): <none>
  [15:45:51.671] {
  [15:45:51.671]     {
  [15:45:51.671]         ...future.startTime <- base::Sys.time()
  [15:45:51.671]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.671]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.671]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.671]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.671]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.671]         {
  [15:45:51.671]             {
  [15:45:51.671]                 base::local({
  [15:45:51.671]                   has_future <- base::requireNamespace("future", 
  [15:45:51.671]                     quietly = TRUE)
  [15:45:51.671]                   version <- if (has_future) 
  [15:45:51.671]                     utils::packageVersion("future")
  [15:45:51.671]                   else NULL
  [15:45:51.671]                   if (!has_future || version < "1.8.0") {
  [15:45:51.671]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.671]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.671]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.671]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.671]                         "release", "version")], collapse = " "), 
  [15:45:51.671]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.671]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.671]                       info)
  [15:45:51.671]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.671]                     if (!has_future) {
  [15:45:51.671]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.671]                         info)
  [15:45:51.671]                     }
  [15:45:51.671]                     else {
  [15:45:51.671]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.671]                         info, version)
  [15:45:51.671]                     }
  [15:45:51.671]                     base::stop(msg)
  [15:45:51.671]                   }
  [15:45:51.671]                 })
  [15:45:51.671]             }
  [15:45:51.671]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.671]         }
  [15:45:51.671]     }
  [15:45:51.671]     if (base::is.na(TRUE)) {
  [15:45:51.671]     }
  [15:45:51.671]     else {
  [15:45:51.671]         if (TRUE) {
  [15:45:51.671]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.671]                 open = "w")
  [15:45:51.671]         }
  [15:45:51.671]         else {
  [15:45:51.671]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.671]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.671]         }
  [15:45:51.671]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.671]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.671]             base::sink(type = "output", split = FALSE)
  [15:45:51.671]             base::close(...future.stdout)
  [15:45:51.671]         }, add = TRUE)
  [15:45:51.671]     }
  [15:45:51.671]     ...future.frame <- base::sys.nframe()
  [15:45:51.671]     ...future.conditions <- base::list()
  [15:45:51.671]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.671]     ...future.result <- base::tryCatch({
  [15:45:51.671]         base::withCallingHandlers({
  [15:45:51.671]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:51.671]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.671]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.671]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.671]                 version = "1.8")
  [15:45:51.671]         }, condition = base::local({
  [15:45:51.671]             c <- base::c
  [15:45:51.671]             inherits <- base::inherits
  [15:45:51.671]             invokeRestart <- base::invokeRestart
  [15:45:51.671]             length <- base::length
  [15:45:51.671]             list <- base::list
  [15:45:51.671]             seq.int <- base::seq.int
  [15:45:51.671]             signalCondition <- base::signalCondition
  [15:45:51.671]             sys.calls <- base::sys.calls
  [15:45:51.671]             Sys.time <- base::Sys.time
  [15:45:51.671]             `[[` <- base::`[[`
  [15:45:51.671]             `+` <- base::`+`
  [15:45:51.671]             `<<-` <- base::`<<-`
  [15:45:51.671]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.671]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.671]                   3L)]
  [15:45:51.671]             }
  [15:45:51.671]             function(cond) {
  [15:45:51.671]                 if (inherits(cond, "error")) {
  [15:45:51.671]                   sessionInformation <- function() {
  [15:45:51.671]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.671]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.671]                       search = base::search(), system = base::Sys.info())
  [15:45:51.671]                   }
  [15:45:51.671]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.671]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.671]                     cond$call), session = sessionInformation(), 
  [15:45:51.671]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.671]                   signalCondition(cond)
  [15:45:51.671]                 }
  [15:45:51.671]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.671]                 ))) {
  [15:45:51.671]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.671]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.671]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.671]                   if (!signal) {
  [15:45:51.671]                     muffleCondition <- function (cond) 
  [15:45:51.671]                     {
  [15:45:51.671]                       inherits <- base::inherits
  [15:45:51.671]                       invokeRestart <- base::invokeRestart
  [15:45:51.671]                       muffled <- FALSE
  [15:45:51.671]                       if (inherits(cond, "message")) {
  [15:45:51.671]                         invokeRestart("muffleMessage")
  [15:45:51.671]                         muffled <- TRUE
  [15:45:51.671]                       }
  [15:45:51.671]                       else if (inherits(cond, "warning")) {
  [15:45:51.671]                         invokeRestart("muffleWarning")
  [15:45:51.671]                         muffled <- TRUE
  [15:45:51.671]                       }
  [15:45:51.671]                       else if (inherits(cond, "condition")) {
  [15:45:51.671]                         computeRestarts <- base::computeRestarts
  [15:45:51.671]                         grepl <- base::grepl
  [15:45:51.671]                         is.null <- base::is.null
  [15:45:51.671]                         restarts <- computeRestarts(cond)
  [15:45:51.671]                         for (restart in restarts) {
  [15:45:51.671]                           name <- restart$name
  [15:45:51.671]                           if (is.null(name)) 
  [15:45:51.671]                             next
  [15:45:51.671]                           if (!grepl("^muffle", name)) 
  [15:45:51.671]                             next
  [15:45:51.671]                           invokeRestart(restart)
  [15:45:51.671]                           muffled <- TRUE
  [15:45:51.671]                           break
  [15:45:51.671]                         }
  [15:45:51.671]                       }
  [15:45:51.671]                       invisible(muffled)
  [15:45:51.671]                     }
  [15:45:51.671]                     muffleCondition(cond)
  [15:45:51.671]                   }
  [15:45:51.671]                 }
  [15:45:51.671]             }
  [15:45:51.671]         }))
  [15:45:51.671]     }, error = function(ex) {
  [15:45:51.671]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.671]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.671]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.671]     }, finally = {
  [15:45:51.671]         {
  [15:45:51.671]             NULL
  [15:45:51.671]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.671]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.671]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.671]                 label = NULL, ...) 
  [15:45:51.671]             {
  [15:45:51.671]                 if (substitute) 
  [15:45:51.671]                   expr <- substitute(expr)
  [15:45:51.671]                 local <- as.logical(local)
  [15:45:51.671]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.671]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.671]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.671]                   label = label, ...)
  [15:45:51.671]                 if (!future$lazy) 
  [15:45:51.671]                   future <- run(future)
  [15:45:51.671]                 invisible(future)
  [15:45:51.671]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.671]         }
  [15:45:51.671]         base::options(...future.oldOptions)
  [15:45:51.671]     })
  [15:45:51.671]     Sys.time
  [15:45:51.671]     if (base::is.na(TRUE)) {
  [15:45:51.671]     }
  [15:45:51.671]     else {
  [15:45:51.671]         base::sink(type = "output", split = FALSE)
  [15:45:51.671]         if (TRUE) {
  [15:45:51.671]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.671]         }
  [15:45:51.671]         else {
  [15:45:51.671]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.671]         }
  [15:45:51.671]         base::close(...future.stdout)
  [15:45:51.671]         ...future.stdout <- NULL
  [15:45:51.671]     }
  [15:45:51.671]     ...future.result$conditions <- ...future.conditions
  [15:45:51.671]     ...future.result
  [15:45:51.671] }
  [15:45:51.676] plan(): Setting new future strategy stack:
  [15:45:51.677] List of future strategies:
  [15:45:51.677] 1. sequential:
  [15:45:51.677]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.677]    - tweaked: FALSE
  [15:45:51.677]    - call: NULL
  [15:45:51.678] plan(): nbrOfWorkers() = 1
  [15:45:51.679] plan(): Setting new future strategy stack:
  [15:45:51.680] List of future strategies:
  [15:45:51.680] 1. sequential:
  [15:45:51.680]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.680]    - tweaked: FALSE
  [15:45:51.680]    - call: plan(strategy)
  [15:45:51.681] plan(): nbrOfWorkers() = 1
  [15:45:51.682] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2a6c3528> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2aadd8d8> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2a6c3528> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2aadd8d8> 
   $  : NULL
   $  : NULL
   $  : num 6
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [15:45:51.709] resolve() on list ...
  [15:45:51.709]  recursive: 0
  [15:45:51.710]  length: 6
  [15:45:51.710]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:51.711] signalConditionsASAP(numeric, pos=1) ...
  [15:45:51.711] - nx: 6
  [15:45:51.711] - relay: TRUE
  [15:45:51.712] - stdout: TRUE
  [15:45:51.712] - signal: TRUE
  [15:45:51.712] - resignal: FALSE
  [15:45:51.713] - force: TRUE
  [15:45:51.713] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.713] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.714]  - until=2
  [15:45:51.714]  - relaying element #2
  [15:45:51.715] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.715] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.715] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:51.716]  length: 5 (resolved future 1)
  [15:45:51.716] Future #2
  [15:45:51.717] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:51.717] - nx: 6
  [15:45:51.718] - relay: TRUE
  [15:45:51.718] - stdout: TRUE
  [15:45:51.718] - signal: TRUE
  [15:45:51.719] - resignal: FALSE
  [15:45:51.719] - force: TRUE
  [15:45:51.719] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.720] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.720]  - until=2
  [15:45:51.720]  - relaying element #2
  [15:45:51.721] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.721] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.722] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:51.722]  length: 4 (resolved future 2)
  [15:45:51.723] Future #3
  [15:45:51.723] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:51.724] - nx: 6
  [15:45:51.724] - relay: TRUE
  [15:45:51.724] - stdout: TRUE
  [15:45:51.725] - signal: TRUE
  [15:45:51.725] - resignal: FALSE
  [15:45:51.725] - force: TRUE
  [15:45:51.726] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.726] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.726]  - until=3
  [15:45:51.727]  - relaying element #3
  [15:45:51.727] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.728] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.728] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:51.729]  length: 3 (resolved future 3)
  [15:45:51.729] signalConditionsASAP(NULL, pos=4) ...
  [15:45:51.729] - nx: 6
  [15:45:51.730] - relay: TRUE
  [15:45:51.730] - stdout: TRUE
  [15:45:51.730] - signal: TRUE
  [15:45:51.731] - resignal: FALSE
  [15:45:51.731] - force: TRUE
  [15:45:51.731] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.732] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.732]  - until=5
  [15:45:51.733]  - relaying element #5
  [15:45:51.733] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:51.733] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.734] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:51.734]  length: 2 (resolved future 4)
  [15:45:51.734] signalConditionsASAP(NULL, pos=5) ...
  [15:45:51.735] - nx: 6
  [15:45:51.735] - relay: TRUE
  [15:45:51.735] - stdout: TRUE
  [15:45:51.736] - signal: TRUE
  [15:45:51.736] - resignal: FALSE
  [15:45:51.736] - force: TRUE
  [15:45:51.737] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:51.737] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.737]  - until=6
  [15:45:51.738]  - relaying element #6
  [15:45:51.738] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:51.738] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.739] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:51.739]  length: 1 (resolved future 5)
  [15:45:51.739] signalConditionsASAP(numeric, pos=6) ...
  [15:45:51.740] - nx: 6
  [15:45:51.740] - relay: TRUE
  [15:45:51.740] - stdout: TRUE
  [15:45:51.741] - signal: TRUE
  [15:45:51.741] - resignal: FALSE
  [15:45:51.741] - force: TRUE
  [15:45:51.742] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:51.742] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.742]  - until=6
  [15:45:51.743] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.743] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.743] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:51.744]  length: 0 (resolved future 6)
  [15:45:51.744] Relaying remaining futures
  [15:45:51.744] signalConditionsASAP(NULL, pos=0) ...
  [15:45:51.745] - nx: 6
  [15:45:51.745] - relay: TRUE
  [15:45:51.745] - stdout: TRUE
  [15:45:51.745] - signal: TRUE
  [15:45:51.746] - resignal: FALSE
  [15:45:51.746] - force: TRUE
  [15:45:51.746] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.747] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:51.747] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.748] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.748] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:51.748] resolve() on list ... DONE
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [15:45:51.755] getGlobalsAndPackages() ...
  [15:45:51.756] Searching for globals...
  [15:45:51.757] 
  [15:45:51.757] Searching for globals ... DONE
  [15:45:51.757] - globals: [0] <none>
  [15:45:51.758] getGlobalsAndPackages() ... DONE
  [15:45:51.760] Packages needed by the future expression (n = 0): <none>
  [15:45:51.760] Packages needed by future strategies (n = 0): <none>
  [15:45:51.766] {
  [15:45:51.766]     {
  [15:45:51.766]         ...future.startTime <- base::Sys.time()
  [15:45:51.766]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.766]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.766]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.766]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.766]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.766]         {
  [15:45:51.766]             {
  [15:45:51.766]                 base::local({
  [15:45:51.766]                   has_future <- base::requireNamespace("future", 
  [15:45:51.766]                     quietly = TRUE)
  [15:45:51.766]                   version <- if (has_future) 
  [15:45:51.766]                     utils::packageVersion("future")
  [15:45:51.766]                   else NULL
  [15:45:51.766]                   if (!has_future || version < "1.8.0") {
  [15:45:51.766]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.766]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.766]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.766]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.766]                         "release", "version")], collapse = " "), 
  [15:45:51.766]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.766]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.766]                       info)
  [15:45:51.766]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.766]                     if (!has_future) {
  [15:45:51.766]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.766]                         info)
  [15:45:51.766]                     }
  [15:45:51.766]                     else {
  [15:45:51.766]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.766]                         info, version)
  [15:45:51.766]                     }
  [15:45:51.766]                     base::stop(msg)
  [15:45:51.766]                   }
  [15:45:51.766]                 })
  [15:45:51.766]             }
  [15:45:51.766]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.766]         }
  [15:45:51.766]     }
  [15:45:51.766]     if (base::is.na(TRUE)) {
  [15:45:51.766]     }
  [15:45:51.766]     else {
  [15:45:51.766]         if (TRUE) {
  [15:45:51.766]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.766]                 open = "w")
  [15:45:51.766]         }
  [15:45:51.766]         else {
  [15:45:51.766]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.766]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.766]         }
  [15:45:51.766]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.766]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.766]             base::sink(type = "output", split = FALSE)
  [15:45:51.766]             base::close(...future.stdout)
  [15:45:51.766]         }, add = TRUE)
  [15:45:51.766]     }
  [15:45:51.766]     ...future.frame <- base::sys.nframe()
  [15:45:51.766]     ...future.conditions <- base::list()
  [15:45:51.766]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.766]     ...future.result <- base::tryCatch({
  [15:45:51.766]         base::withCallingHandlers({
  [15:45:51.766]             ...future.value <- base::withVisible(base::local(2))
  [15:45:51.766]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.766]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.766]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.766]                 version = "1.8")
  [15:45:51.766]         }, condition = base::local({
  [15:45:51.766]             c <- base::c
  [15:45:51.766]             inherits <- base::inherits
  [15:45:51.766]             invokeRestart <- base::invokeRestart
  [15:45:51.766]             length <- base::length
  [15:45:51.766]             list <- base::list
  [15:45:51.766]             seq.int <- base::seq.int
  [15:45:51.766]             signalCondition <- base::signalCondition
  [15:45:51.766]             sys.calls <- base::sys.calls
  [15:45:51.766]             Sys.time <- base::Sys.time
  [15:45:51.766]             `[[` <- base::`[[`
  [15:45:51.766]             `+` <- base::`+`
  [15:45:51.766]             `<<-` <- base::`<<-`
  [15:45:51.766]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.766]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.766]                   3L)]
  [15:45:51.766]             }
  [15:45:51.766]             function(cond) {
  [15:45:51.766]                 if (inherits(cond, "error")) {
  [15:45:51.766]                   sessionInformation <- function() {
  [15:45:51.766]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.766]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.766]                       search = base::search(), system = base::Sys.info())
  [15:45:51.766]                   }
  [15:45:51.766]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.766]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.766]                     cond$call), session = sessionInformation(), 
  [15:45:51.766]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.766]                   signalCondition(cond)
  [15:45:51.766]                 }
  [15:45:51.766]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.766]                 ))) {
  [15:45:51.766]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.766]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.766]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.766]                   if (!signal) {
  [15:45:51.766]                     muffleCondition <- function (cond) 
  [15:45:51.766]                     {
  [15:45:51.766]                       inherits <- base::inherits
  [15:45:51.766]                       invokeRestart <- base::invokeRestart
  [15:45:51.766]                       muffled <- FALSE
  [15:45:51.766]                       if (inherits(cond, "message")) {
  [15:45:51.766]                         invokeRestart("muffleMessage")
  [15:45:51.766]                         muffled <- TRUE
  [15:45:51.766]                       }
  [15:45:51.766]                       else if (inherits(cond, "warning")) {
  [15:45:51.766]                         invokeRestart("muffleWarning")
  [15:45:51.766]                         muffled <- TRUE
  [15:45:51.766]                       }
  [15:45:51.766]                       else if (inherits(cond, "condition")) {
  [15:45:51.766]                         computeRestarts <- base::computeRestarts
  [15:45:51.766]                         grepl <- base::grepl
  [15:45:51.766]                         is.null <- base::is.null
  [15:45:51.766]                         restarts <- computeRestarts(cond)
  [15:45:51.766]                         for (restart in restarts) {
  [15:45:51.766]                           name <- restart$name
  [15:45:51.766]                           if (is.null(name)) 
  [15:45:51.766]                             next
  [15:45:51.766]                           if (!grepl("^muffle", name)) 
  [15:45:51.766]                             next
  [15:45:51.766]                           invokeRestart(restart)
  [15:45:51.766]                           muffled <- TRUE
  [15:45:51.766]                           break
  [15:45:51.766]                         }
  [15:45:51.766]                       }
  [15:45:51.766]                       invisible(muffled)
  [15:45:51.766]                     }
  [15:45:51.766]                     muffleCondition(cond)
  [15:45:51.766]                   }
  [15:45:51.766]                 }
  [15:45:51.766]             }
  [15:45:51.766]         }))
  [15:45:51.766]     }, error = function(ex) {
  [15:45:51.766]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.766]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.766]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.766]     }, finally = {
  [15:45:51.766]         {
  [15:45:51.766]             NULL
  [15:45:51.766]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.766]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.766]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.766]                 label = NULL, ...) 
  [15:45:51.766]             {
  [15:45:51.766]                 if (substitute) 
  [15:45:51.766]                   expr <- substitute(expr)
  [15:45:51.766]                 local <- as.logical(local)
  [15:45:51.766]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.766]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.766]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.766]                   label = label, ...)
  [15:45:51.766]                 if (!future$lazy) 
  [15:45:51.766]                   future <- run(future)
  [15:45:51.766]                 invisible(future)
  [15:45:51.766]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.766]         }
  [15:45:51.766]         base::options(...future.oldOptions)
  [15:45:51.766]     })
  [15:45:51.766]     Sys.time
  [15:45:51.766]     if (base::is.na(TRUE)) {
  [15:45:51.766]     }
  [15:45:51.766]     else {
  [15:45:51.766]         base::sink(type = "output", split = FALSE)
  [15:45:51.766]         if (TRUE) {
  [15:45:51.766]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.766]         }
  [15:45:51.766]         else {
  [15:45:51.766]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.766]         }
  [15:45:51.766]         base::close(...future.stdout)
  [15:45:51.766]         ...future.stdout <- NULL
  [15:45:51.766]     }
  [15:45:51.766]     ...future.result$conditions <- ...future.conditions
  [15:45:51.766]     ...future.result
  [15:45:51.766] }
  [15:45:51.772] plan(): Setting new future strategy stack:
  [15:45:51.772] List of future strategies:
  [15:45:51.772] 1. sequential:
  [15:45:51.772]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.772]    - tweaked: FALSE
  [15:45:51.772]    - call: NULL
  [15:45:51.773] plan(): nbrOfWorkers() = 1
  [15:45:51.775] plan(): Setting new future strategy stack:
  [15:45:51.775] List of future strategies:
  [15:45:51.775] 1. sequential:
  [15:45:51.775]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.775]    - tweaked: FALSE
  [15:45:51.775]    - call: plan(strategy)
  [15:45:51.776] plan(): nbrOfWorkers() = 1
  [15:45:51.777] SequentialFuture started (and completed)
  [15:45:51.778] getGlobalsAndPackages() ...
  [15:45:51.778] Searching for globals...
  [15:45:51.779] 
  [15:45:51.779] Searching for globals ... DONE
  [15:45:51.780] - globals: [0] <none>
  [15:45:51.780] getGlobalsAndPackages() ... DONE
  [15:45:51.782] Packages needed by the future expression (n = 0): <none>
  [15:45:51.783] Packages needed by future strategies (n = 0): <none>
  [15:45:51.793] {
  [15:45:51.793]     {
  [15:45:51.793]         ...future.startTime <- base::Sys.time()
  [15:45:51.793]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.793]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.793]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.793]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.793]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.793]         {
  [15:45:51.793]             {
  [15:45:51.793]                 base::local({
  [15:45:51.793]                   has_future <- base::requireNamespace("future", 
  [15:45:51.793]                     quietly = TRUE)
  [15:45:51.793]                   version <- if (has_future) 
  [15:45:51.793]                     utils::packageVersion("future")
  [15:45:51.793]                   else NULL
  [15:45:51.793]                   if (!has_future || version < "1.8.0") {
  [15:45:51.793]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.793]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.793]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.793]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.793]                         "release", "version")], collapse = " "), 
  [15:45:51.793]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.793]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.793]                       info)
  [15:45:51.793]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.793]                     if (!has_future) {
  [15:45:51.793]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.793]                         info)
  [15:45:51.793]                     }
  [15:45:51.793]                     else {
  [15:45:51.793]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.793]                         info, version)
  [15:45:51.793]                     }
  [15:45:51.793]                     base::stop(msg)
  [15:45:51.793]                   }
  [15:45:51.793]                 })
  [15:45:51.793]             }
  [15:45:51.793]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.793]         }
  [15:45:51.793]     }
  [15:45:51.793]     if (base::is.na(TRUE)) {
  [15:45:51.793]     }
  [15:45:51.793]     else {
  [15:45:51.793]         if (TRUE) {
  [15:45:51.793]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.793]                 open = "w")
  [15:45:51.793]         }
  [15:45:51.793]         else {
  [15:45:51.793]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.793]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.793]         }
  [15:45:51.793]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.793]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.793]             base::sink(type = "output", split = FALSE)
  [15:45:51.793]             base::close(...future.stdout)
  [15:45:51.793]         }, add = TRUE)
  [15:45:51.793]     }
  [15:45:51.793]     ...future.frame <- base::sys.nframe()
  [15:45:51.793]     ...future.conditions <- base::list()
  [15:45:51.793]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.793]     ...future.result <- base::tryCatch({
  [15:45:51.793]         base::withCallingHandlers({
  [15:45:51.793]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:51.793]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.793]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.793]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.793]                 version = "1.8")
  [15:45:51.793]         }, condition = base::local({
  [15:45:51.793]             c <- base::c
  [15:45:51.793]             inherits <- base::inherits
  [15:45:51.793]             invokeRestart <- base::invokeRestart
  [15:45:51.793]             length <- base::length
  [15:45:51.793]             list <- base::list
  [15:45:51.793]             seq.int <- base::seq.int
  [15:45:51.793]             signalCondition <- base::signalCondition
  [15:45:51.793]             sys.calls <- base::sys.calls
  [15:45:51.793]             Sys.time <- base::Sys.time
  [15:45:51.793]             `[[` <- base::`[[`
  [15:45:51.793]             `+` <- base::`+`
  [15:45:51.793]             `<<-` <- base::`<<-`
  [15:45:51.793]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.793]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.793]                   3L)]
  [15:45:51.793]             }
  [15:45:51.793]             function(cond) {
  [15:45:51.793]                 if (inherits(cond, "error")) {
  [15:45:51.793]                   sessionInformation <- function() {
  [15:45:51.793]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.793]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.793]                       search = base::search(), system = base::Sys.info())
  [15:45:51.793]                   }
  [15:45:51.793]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.793]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.793]                     cond$call), session = sessionInformation(), 
  [15:45:51.793]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.793]                   signalCondition(cond)
  [15:45:51.793]                 }
  [15:45:51.793]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.793]                 ))) {
  [15:45:51.793]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.793]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.793]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.793]                   if (!signal) {
  [15:45:51.793]                     muffleCondition <- function (cond) 
  [15:45:51.793]                     {
  [15:45:51.793]                       inherits <- base::inherits
  [15:45:51.793]                       invokeRestart <- base::invokeRestart
  [15:45:51.793]                       muffled <- FALSE
  [15:45:51.793]                       if (inherits(cond, "message")) {
  [15:45:51.793]                         invokeRestart("muffleMessage")
  [15:45:51.793]                         muffled <- TRUE
  [15:45:51.793]                       }
  [15:45:51.793]                       else if (inherits(cond, "warning")) {
  [15:45:51.793]                         invokeRestart("muffleWarning")
  [15:45:51.793]                         muffled <- TRUE
  [15:45:51.793]                       }
  [15:45:51.793]                       else if (inherits(cond, "condition")) {
  [15:45:51.793]                         computeRestarts <- base::computeRestarts
  [15:45:51.793]                         grepl <- base::grepl
  [15:45:51.793]                         is.null <- base::is.null
  [15:45:51.793]                         restarts <- computeRestarts(cond)
  [15:45:51.793]                         for (restart in restarts) {
  [15:45:51.793]                           name <- restart$name
  [15:45:51.793]                           if (is.null(name)) 
  [15:45:51.793]                             next
  [15:45:51.793]                           if (!grepl("^muffle", name)) 
  [15:45:51.793]                             next
  [15:45:51.793]                           invokeRestart(restart)
  [15:45:51.793]                           muffled <- TRUE
  [15:45:51.793]                           break
  [15:45:51.793]                         }
  [15:45:51.793]                       }
  [15:45:51.793]                       invisible(muffled)
  [15:45:51.793]                     }
  [15:45:51.793]                     muffleCondition(cond)
  [15:45:51.793]                   }
  [15:45:51.793]                 }
  [15:45:51.793]             }
  [15:45:51.793]         }))
  [15:45:51.793]     }, error = function(ex) {
  [15:45:51.793]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.793]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.793]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.793]     }, finally = {
  [15:45:51.793]         {
  [15:45:51.793]             NULL
  [15:45:51.793]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.793]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.793]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.793]                 label = NULL, ...) 
  [15:45:51.793]             {
  [15:45:51.793]                 if (substitute) 
  [15:45:51.793]                   expr <- substitute(expr)
  [15:45:51.793]                 local <- as.logical(local)
  [15:45:51.793]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.793]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.793]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.793]                   label = label, ...)
  [15:45:51.793]                 if (!future$lazy) 
  [15:45:51.793]                   future <- run(future)
  [15:45:51.793]                 invisible(future)
  [15:45:51.793]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.793]         }
  [15:45:51.793]         base::options(...future.oldOptions)
  [15:45:51.793]     })
  [15:45:51.793]     Sys.time
  [15:45:51.793]     if (base::is.na(TRUE)) {
  [15:45:51.793]     }
  [15:45:51.793]     else {
  [15:45:51.793]         base::sink(type = "output", split = FALSE)
  [15:45:51.793]         if (TRUE) {
  [15:45:51.793]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.793]         }
  [15:45:51.793]         else {
  [15:45:51.793]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.793]         }
  [15:45:51.793]         base::close(...future.stdout)
  [15:45:51.793]         ...future.stdout <- NULL
  [15:45:51.793]     }
  [15:45:51.793]     ...future.result$conditions <- ...future.conditions
  [15:45:51.793]     ...future.result
  [15:45:51.793] }
  [15:45:51.799] plan(): Setting new future strategy stack:
  [15:45:51.799] List of future strategies:
  [15:45:51.799] 1. sequential:
  [15:45:51.799]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.799]    - tweaked: FALSE
  [15:45:51.799]    - call: NULL
  [15:45:51.800] plan(): nbrOfWorkers() = 1
  [15:45:51.802] plan(): Setting new future strategy stack:
  [15:45:51.802] List of future strategies:
  [15:45:51.802] 1. sequential:
  [15:45:51.802]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.802]    - tweaked: FALSE
  [15:45:51.802]    - call: plan(strategy)
  [15:45:51.803] plan(): nbrOfWorkers() = 1
  [15:45:51.804] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa25cd8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2ad68c30> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa25cd8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2ad68c30> 
   $  : 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" "" ...
  [15:45:51.830] resolve() on list ...
  [15:45:51.830]  recursive: 0
  [15:45:51.831]  length: 6
  [15:45:51.831]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:51.831] signalConditionsASAP(numeric, pos=1) ...
  [15:45:51.832] - nx: 6
  [15:45:51.832] - relay: TRUE
  [15:45:51.832] - stdout: TRUE
  [15:45:51.833] - signal: TRUE
  [15:45:51.833] - resignal: FALSE
  [15:45:51.833] - force: TRUE
  [15:45:51.834] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.834] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.834]  - until=2
  [15:45:51.835]  - relaying element #2
  [15:45:51.835] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.835] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.836] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:51.836]  length: 5 (resolved future 1)
  [15:45:51.837] Future #2
  [15:45:51.837] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:51.838] - nx: 6
  [15:45:51.838] - relay: TRUE
  [15:45:51.838] - stdout: TRUE
  [15:45:51.855] - signal: TRUE
  [15:45:51.855] - resignal: FALSE
  [15:45:51.855] - force: TRUE
  [15:45:51.856] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.856] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.857]  - until=2
  [15:45:51.857]  - relaying element #2
  [15:45:51.858] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.858] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.858] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:51.859]  length: 4 (resolved future 2)
  [15:45:51.859] Future #3
  [15:45:51.860] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:51.860] - nx: 6
  [15:45:51.860] - relay: TRUE
  [15:45:51.861] - stdout: TRUE
  [15:45:51.861] - signal: TRUE
  [15:45:51.861] - resignal: FALSE
  [15:45:51.862] - force: TRUE
  [15:45:51.862] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.862] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:51.863]  - until=3
  [15:45:51.863]  - relaying element #3
  [15:45:51.864] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.864] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.864] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:51.865]  length: 3 (resolved future 3)
  [15:45:51.865] signalConditionsASAP(NULL, pos=4) ...
  [15:45:51.866] - nx: 6
  [15:45:51.866] - relay: TRUE
  [15:45:51.866] - stdout: TRUE
  [15:45:51.867] - signal: TRUE
  [15:45:51.867] - resignal: FALSE
  [15:45:51.867] - force: TRUE
  [15:45:51.868] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.868] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.868]  - until=5
  [15:45:51.869]  - relaying element #5
  [15:45:51.869] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:51.869] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.870] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:51.870]  length: 2 (resolved future 4)
  [15:45:51.887] signalConditionsASAP(NULL, pos=5) ...
  [15:45:51.887] - nx: 6
  [15:45:51.887] - relay: TRUE
  [15:45:51.888] - stdout: TRUE
  [15:45:51.888] - signal: TRUE
  [15:45:51.888] - resignal: FALSE
  [15:45:51.889] - force: TRUE
  [15:45:51.889] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:51.889] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.890]  - until=6
  [15:45:51.890]  - relaying element #6
  [15:45:51.890] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:51.891] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.891] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:51.892]  length: 1 (resolved future 5)
  [15:45:51.892] signalConditionsASAP(numeric, pos=6) ...
  [15:45:51.892] - nx: 6
  [15:45:51.893] - relay: TRUE
  [15:45:51.893] - stdout: TRUE
  [15:45:51.893] - signal: TRUE
  [15:45:51.894] - resignal: FALSE
  [15:45:51.894] - force: TRUE
  [15:45:51.894] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:51.895] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.895]  - until=6
  [15:45:51.895] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.896] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.896] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:51.896]  length: 0 (resolved future 6)
  [15:45:51.897] Relaying remaining futures
  [15:45:51.897] signalConditionsASAP(NULL, pos=0) ...
  [15:45:51.897] - nx: 6
  [15:45:51.898] - relay: TRUE
  [15:45:51.898] - stdout: TRUE
  [15:45:51.898] - signal: TRUE
  [15:45:51.899] - resignal: FALSE
  [15:45:51.899] - force: TRUE
  [15:45:51.899] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.900] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:51.900] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:51.901] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:51.901] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:51.901] 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)
  [15:45:51.930] getGlobalsAndPackages() ...
  [15:45:51.930] Searching for globals...
  [15:45:51.931] 
  [15:45:51.932] Searching for globals ... DONE
  [15:45:51.932] - globals: [0] <none>
  [15:45:51.932] getGlobalsAndPackages() ... DONE
  [15:45:51.938] Packages needed by the future expression (n = 0): <none>
  [15:45:51.938] Packages needed by future strategies (n = 0): <none>
  [15:45:51.944] {
  [15:45:51.944]     {
  [15:45:51.944]         ...future.startTime <- base::Sys.time()
  [15:45:51.944]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.944]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.944]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.944]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.944]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.944]         {
  [15:45:51.944]             {
  [15:45:51.944]                 base::local({
  [15:45:51.944]                   has_future <- base::requireNamespace("future", 
  [15:45:51.944]                     quietly = TRUE)
  [15:45:51.944]                   version <- if (has_future) 
  [15:45:51.944]                     utils::packageVersion("future")
  [15:45:51.944]                   else NULL
  [15:45:51.944]                   if (!has_future || version < "1.8.0") {
  [15:45:51.944]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.944]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.944]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.944]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.944]                         "release", "version")], collapse = " "), 
  [15:45:51.944]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.944]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.944]                       info)
  [15:45:51.944]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.944]                     if (!has_future) {
  [15:45:51.944]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.944]                         info)
  [15:45:51.944]                     }
  [15:45:51.944]                     else {
  [15:45:51.944]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.944]                         info, version)
  [15:45:51.944]                     }
  [15:45:51.944]                     base::stop(msg)
  [15:45:51.944]                   }
  [15:45:51.944]                 })
  [15:45:51.944]             }
  [15:45:51.944]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.944]         }
  [15:45:51.944]     }
  [15:45:51.944]     if (base::is.na(TRUE)) {
  [15:45:51.944]     }
  [15:45:51.944]     else {
  [15:45:51.944]         if (TRUE) {
  [15:45:51.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.944]                 open = "w")
  [15:45:51.944]         }
  [15:45:51.944]         else {
  [15:45:51.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.944]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.944]         }
  [15:45:51.944]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.944]             base::sink(type = "output", split = FALSE)
  [15:45:51.944]             base::close(...future.stdout)
  [15:45:51.944]         }, add = TRUE)
  [15:45:51.944]     }
  [15:45:51.944]     ...future.frame <- base::sys.nframe()
  [15:45:51.944]     ...future.conditions <- base::list()
  [15:45:51.944]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.944]     ...future.result <- base::tryCatch({
  [15:45:51.944]         base::withCallingHandlers({
  [15:45:51.944]             ...future.value <- base::withVisible(base::local(2))
  [15:45:51.944]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.944]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.944]                 version = "1.8")
  [15:45:51.944]         }, condition = base::local({
  [15:45:51.944]             c <- base::c
  [15:45:51.944]             inherits <- base::inherits
  [15:45:51.944]             invokeRestart <- base::invokeRestart
  [15:45:51.944]             length <- base::length
  [15:45:51.944]             list <- base::list
  [15:45:51.944]             seq.int <- base::seq.int
  [15:45:51.944]             signalCondition <- base::signalCondition
  [15:45:51.944]             sys.calls <- base::sys.calls
  [15:45:51.944]             Sys.time <- base::Sys.time
  [15:45:51.944]             `[[` <- base::`[[`
  [15:45:51.944]             `+` <- base::`+`
  [15:45:51.944]             `<<-` <- base::`<<-`
  [15:45:51.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.944]                   3L)]
  [15:45:51.944]             }
  [15:45:51.944]             function(cond) {
  [15:45:51.944]                 if (inherits(cond, "error")) {
  [15:45:51.944]                   sessionInformation <- function() {
  [15:45:51.944]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.944]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.944]                       search = base::search(), system = base::Sys.info())
  [15:45:51.944]                   }
  [15:45:51.944]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.944]                     cond$call), session = sessionInformation(), 
  [15:45:51.944]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.944]                   signalCondition(cond)
  [15:45:51.944]                 }
  [15:45:51.944]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.944]                 ))) {
  [15:45:51.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.944]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.944]                   if (!signal) {
  [15:45:51.944]                     muffleCondition <- function (cond) 
  [15:45:51.944]                     {
  [15:45:51.944]                       inherits <- base::inherits
  [15:45:51.944]                       invokeRestart <- base::invokeRestart
  [15:45:51.944]                       muffled <- FALSE
  [15:45:51.944]                       if (inherits(cond, "message")) {
  [15:45:51.944]                         invokeRestart("muffleMessage")
  [15:45:51.944]                         muffled <- TRUE
  [15:45:51.944]                       }
  [15:45:51.944]                       else if (inherits(cond, "warning")) {
  [15:45:51.944]                         invokeRestart("muffleWarning")
  [15:45:51.944]                         muffled <- TRUE
  [15:45:51.944]                       }
  [15:45:51.944]                       else if (inherits(cond, "condition")) {
  [15:45:51.944]                         computeRestarts <- base::computeRestarts
  [15:45:51.944]                         grepl <- base::grepl
  [15:45:51.944]                         is.null <- base::is.null
  [15:45:51.944]                         restarts <- computeRestarts(cond)
  [15:45:51.944]                         for (restart in restarts) {
  [15:45:51.944]                           name <- restart$name
  [15:45:51.944]                           if (is.null(name)) 
  [15:45:51.944]                             next
  [15:45:51.944]                           if (!grepl("^muffle", name)) 
  [15:45:51.944]                             next
  [15:45:51.944]                           invokeRestart(restart)
  [15:45:51.944]                           muffled <- TRUE
  [15:45:51.944]                           break
  [15:45:51.944]                         }
  [15:45:51.944]                       }
  [15:45:51.944]                       invisible(muffled)
  [15:45:51.944]                     }
  [15:45:51.944]                     muffleCondition(cond)
  [15:45:51.944]                   }
  [15:45:51.944]                 }
  [15:45:51.944]             }
  [15:45:51.944]         }))
  [15:45:51.944]     }, error = function(ex) {
  [15:45:51.944]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.944]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.944]     }, finally = {
  [15:45:51.944]         {
  [15:45:51.944]             NULL
  [15:45:51.944]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.944]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.944]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.944]                 label = NULL, ...) 
  [15:45:51.944]             {
  [15:45:51.944]                 if (substitute) 
  [15:45:51.944]                   expr <- substitute(expr)
  [15:45:51.944]                 local <- as.logical(local)
  [15:45:51.944]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.944]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.944]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.944]                   label = label, ...)
  [15:45:51.944]                 if (!future$lazy) 
  [15:45:51.944]                   future <- run(future)
  [15:45:51.944]                 invisible(future)
  [15:45:51.944]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.944]         }
  [15:45:51.944]         base::options(...future.oldOptions)
  [15:45:51.944]     })
  [15:45:51.944]     Sys.time
  [15:45:51.944]     if (base::is.na(TRUE)) {
  [15:45:51.944]     }
  [15:45:51.944]     else {
  [15:45:51.944]         base::sink(type = "output", split = FALSE)
  [15:45:51.944]         if (TRUE) {
  [15:45:51.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.944]         }
  [15:45:51.944]         else {
  [15:45:51.944]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.944]         }
  [15:45:51.944]         base::close(...future.stdout)
  [15:45:51.944]         ...future.stdout <- NULL
  [15:45:51.944]     }
  [15:45:51.944]     ...future.result$conditions <- ...future.conditions
  [15:45:51.944]     ...future.result
  [15:45:51.944] }
  [15:45:51.950] plan(): Setting new future strategy stack:
  [15:45:51.950] List of future strategies:
  [15:45:51.950] 1. sequential:
  [15:45:51.950]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.950]    - tweaked: FALSE
  [15:45:51.950]    - call: NULL
  [15:45:51.951] plan(): nbrOfWorkers() = 1
  [15:45:51.952] plan(): Setting new future strategy stack:
  [15:45:51.953] List of future strategies:
  [15:45:51.953] 1. sequential:
  [15:45:51.953]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.953]    - tweaked: FALSE
  [15:45:51.953]    - call: plan(strategy)
  [15:45:51.954] plan(): nbrOfWorkers() = 1
  [15:45:51.954] SequentialFuture started (and completed)
  [15:45:51.955] getGlobalsAndPackages() ...
  [15:45:51.955] Searching for globals...
  [15:45:51.956] 
  [15:45:51.956] Searching for globals ... DONE
  [15:45:51.957] - globals: [0] <none>
  [15:45:51.957] getGlobalsAndPackages() ... DONE
  [15:45:51.959] Packages needed by the future expression (n = 0): <none>
  [15:45:51.960] Packages needed by future strategies (n = 0): <none>
  [15:45:51.965] {
  [15:45:51.965]     {
  [15:45:51.965]         ...future.startTime <- base::Sys.time()
  [15:45:51.965]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:51.965]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:51.965]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:51.965]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:51.965]             future.resolve.recursive = NULL, width = 80L)
  [15:45:51.965]         {
  [15:45:51.965]             {
  [15:45:51.965]                 base::local({
  [15:45:51.965]                   has_future <- base::requireNamespace("future", 
  [15:45:51.965]                     quietly = TRUE)
  [15:45:51.965]                   version <- if (has_future) 
  [15:45:51.965]                     utils::packageVersion("future")
  [15:45:51.965]                   else NULL
  [15:45:51.965]                   if (!has_future || version < "1.8.0") {
  [15:45:51.965]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:51.965]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:51.965]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:51.965]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:51.965]                         "release", "version")], collapse = " "), 
  [15:45:51.965]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:51.965]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:51.965]                       info)
  [15:45:51.965]                     info <- base::paste(info, collapse = "; ")
  [15:45:51.965]                     if (!has_future) {
  [15:45:51.965]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:51.965]                         info)
  [15:45:51.965]                     }
  [15:45:51.965]                     else {
  [15:45:51.965]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:51.965]                         info, version)
  [15:45:51.965]                     }
  [15:45:51.965]                     base::stop(msg)
  [15:45:51.965]                   }
  [15:45:51.965]                 })
  [15:45:51.965]             }
  [15:45:51.965]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:51.965]         }
  [15:45:51.965]     }
  [15:45:51.965]     if (base::is.na(TRUE)) {
  [15:45:51.965]     }
  [15:45:51.965]     else {
  [15:45:51.965]         if (TRUE) {
  [15:45:51.965]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:51.965]                 open = "w")
  [15:45:51.965]         }
  [15:45:51.965]         else {
  [15:45:51.965]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:51.965]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:51.965]         }
  [15:45:51.965]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:51.965]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:51.965]             base::sink(type = "output", split = FALSE)
  [15:45:51.965]             base::close(...future.stdout)
  [15:45:51.965]         }, add = TRUE)
  [15:45:51.965]     }
  [15:45:51.965]     ...future.frame <- base::sys.nframe()
  [15:45:51.965]     ...future.conditions <- base::list()
  [15:45:51.965]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:51.965]     ...future.result <- base::tryCatch({
  [15:45:51.965]         base::withCallingHandlers({
  [15:45:51.965]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:51.965]             future::FutureResult(value = ...future.value$value, 
  [15:45:51.965]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.965]                   ...future.rng), started = ...future.startTime, 
  [15:45:51.965]                 version = "1.8")
  [15:45:51.965]         }, condition = base::local({
  [15:45:51.965]             c <- base::c
  [15:45:51.965]             inherits <- base::inherits
  [15:45:51.965]             invokeRestart <- base::invokeRestart
  [15:45:51.965]             length <- base::length
  [15:45:51.965]             list <- base::list
  [15:45:51.965]             seq.int <- base::seq.int
  [15:45:51.965]             signalCondition <- base::signalCondition
  [15:45:51.965]             sys.calls <- base::sys.calls
  [15:45:51.965]             Sys.time <- base::Sys.time
  [15:45:51.965]             `[[` <- base::`[[`
  [15:45:51.965]             `+` <- base::`+`
  [15:45:51.965]             `<<-` <- base::`<<-`
  [15:45:51.965]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:51.965]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:51.965]                   3L)]
  [15:45:51.965]             }
  [15:45:51.965]             function(cond) {
  [15:45:51.965]                 if (inherits(cond, "error")) {
  [15:45:51.965]                   sessionInformation <- function() {
  [15:45:51.965]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:51.965]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:51.965]                       search = base::search(), system = base::Sys.info())
  [15:45:51.965]                   }
  [15:45:51.965]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.965]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:51.965]                     cond$call), session = sessionInformation(), 
  [15:45:51.965]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:51.965]                   signalCondition(cond)
  [15:45:51.965]                 }
  [15:45:51.965]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:51.965]                 ))) {
  [15:45:51.965]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:51.965]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:51.965]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:51.965]                   if (!signal) {
  [15:45:51.965]                     muffleCondition <- function (cond) 
  [15:45:51.965]                     {
  [15:45:51.965]                       inherits <- base::inherits
  [15:45:51.965]                       invokeRestart <- base::invokeRestart
  [15:45:51.965]                       muffled <- FALSE
  [15:45:51.965]                       if (inherits(cond, "message")) {
  [15:45:51.965]                         invokeRestart("muffleMessage")
  [15:45:51.965]                         muffled <- TRUE
  [15:45:51.965]                       }
  [15:45:51.965]                       else if (inherits(cond, "warning")) {
  [15:45:51.965]                         invokeRestart("muffleWarning")
  [15:45:51.965]                         muffled <- TRUE
  [15:45:51.965]                       }
  [15:45:51.965]                       else if (inherits(cond, "condition")) {
  [15:45:51.965]                         computeRestarts <- base::computeRestarts
  [15:45:51.965]                         grepl <- base::grepl
  [15:45:51.965]                         is.null <- base::is.null
  [15:45:51.965]                         restarts <- computeRestarts(cond)
  [15:45:51.965]                         for (restart in restarts) {
  [15:45:51.965]                           name <- restart$name
  [15:45:51.965]                           if (is.null(name)) 
  [15:45:51.965]                             next
  [15:45:51.965]                           if (!grepl("^muffle", name)) 
  [15:45:51.965]                             next
  [15:45:51.965]                           invokeRestart(restart)
  [15:45:51.965]                           muffled <- TRUE
  [15:45:51.965]                           break
  [15:45:51.965]                         }
  [15:45:51.965]                       }
  [15:45:51.965]                       invisible(muffled)
  [15:45:51.965]                     }
  [15:45:51.965]                     muffleCondition(cond)
  [15:45:51.965]                   }
  [15:45:51.965]                 }
  [15:45:51.965]             }
  [15:45:51.965]         }))
  [15:45:51.965]     }, error = function(ex) {
  [15:45:51.965]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:51.965]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:51.965]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:51.965]     }, finally = {
  [15:45:51.965]         {
  [15:45:51.965]             NULL
  [15:45:51.965]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:51.965]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:51.965]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:51.965]                 label = NULL, ...) 
  [15:45:51.965]             {
  [15:45:51.965]                 if (substitute) 
  [15:45:51.965]                   expr <- substitute(expr)
  [15:45:51.965]                 local <- as.logical(local)
  [15:45:51.965]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:51.965]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:51.965]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:51.965]                   label = label, ...)
  [15:45:51.965]                 if (!future$lazy) 
  [15:45:51.965]                   future <- run(future)
  [15:45:51.965]                 invisible(future)
  [15:45:51.965]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:51.965]         }
  [15:45:51.965]         base::options(...future.oldOptions)
  [15:45:51.965]     })
  [15:45:51.965]     Sys.time
  [15:45:51.965]     if (base::is.na(TRUE)) {
  [15:45:51.965]     }
  [15:45:51.965]     else {
  [15:45:51.965]         base::sink(type = "output", split = FALSE)
  [15:45:51.965]         if (TRUE) {
  [15:45:51.965]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:51.965]         }
  [15:45:51.965]         else {
  [15:45:51.965]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:51.965]         }
  [15:45:51.965]         base::close(...future.stdout)
  [15:45:51.965]         ...future.stdout <- NULL
  [15:45:51.965]     }
  [15:45:51.965]     ...future.result$conditions <- ...future.conditions
  [15:45:51.965]     ...future.result
  [15:45:51.965] }
  [15:45:51.970] plan(): Setting new future strategy stack:
  [15:45:51.971] List of future strategies:
  [15:45:51.971] 1. sequential:
  [15:45:51.971]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.971]    - tweaked: FALSE
  [15:45:51.971]    - call: NULL
  [15:45:51.972] plan(): nbrOfWorkers() = 1
  [15:45:51.973] plan(): Setting new future strategy stack:
  [15:45:51.973] List of future strategies:
  [15:45:51.973] 1. sequential:
  [15:45:51.973]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:51.973]    - tweaked: FALSE
  [15:45:51.973]    - call: plan(strategy)
  [15:45:51.974] plan(): nbrOfWorkers() = 1
  [15:45:51.975] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2b21a010> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca29adb5a0> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2b21a010> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca29adb5a0> 
   $  : 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" "" ...
  [15:45:51.999] resolve() on list ...
  [15:45:51.999]  recursive: 0
  [15:45:51.999]  length: 6
  [15:45:52.000]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:52.000] signalConditionsASAP(numeric, pos=1) ...
  [15:45:52.000] - nx: 6
  [15:45:52.001] - relay: TRUE
  [15:45:52.001] - stdout: TRUE
  [15:45:52.001] - signal: TRUE
  [15:45:52.001] - resignal: FALSE
  [15:45:52.002] - force: TRUE
  [15:45:52.002] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.002] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.003]  - until=2
  [15:45:52.003]  - relaying element #2
  [15:45:52.003] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.004] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.004] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:52.005]  length: 5 (resolved future 1)
  [15:45:52.005] Future #2
  [15:45:52.006] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:52.006] - nx: 6
  [15:45:52.006] - relay: TRUE
  [15:45:52.007] - stdout: TRUE
  [15:45:52.007] - signal: TRUE
  [15:45:52.007] - resignal: FALSE
  [15:45:52.008] - force: TRUE
  [15:45:52.008] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.008] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.009]  - until=2
  [15:45:52.009]  - relaying element #2
  [15:45:52.010] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.010] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.010] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:52.011]  length: 4 (resolved future 2)
  [15:45:52.011] Future #3
  [15:45:52.012] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:52.012] - nx: 6
  [15:45:52.012] - relay: TRUE
  [15:45:52.013] - stdout: TRUE
  [15:45:52.013] - signal: TRUE
  [15:45:52.013] - resignal: FALSE
  [15:45:52.014] - force: TRUE
  [15:45:52.014] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.014] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.015]  - until=3
  [15:45:52.015]  - relaying element #3
  [15:45:52.016] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.016] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.016] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:52.017]  length: 3 (resolved future 3)
  [15:45:52.017] signalConditionsASAP(NULL, pos=4) ...
  [15:45:52.017] - nx: 6
  [15:45:52.018] - relay: TRUE
  [15:45:52.018] - stdout: TRUE
  [15:45:52.018] - signal: TRUE
  [15:45:52.019] - resignal: FALSE
  [15:45:52.019] - force: TRUE
  [15:45:52.019] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.020] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.020]  - until=5
  [15:45:52.021]  - relaying element #5
  [15:45:52.024] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.024] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.025] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:52.025]  length: 2 (resolved future 4)
  [15:45:52.025] signalConditionsASAP(NULL, pos=5) ...
  [15:45:52.026] - nx: 6
  [15:45:52.026] - relay: TRUE
  [15:45:52.026] - stdout: TRUE
  [15:45:52.027] - signal: TRUE
  [15:45:52.027] - resignal: FALSE
  [15:45:52.027] - force: TRUE
  [15:45:52.028] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.028] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.029]  - until=6
  [15:45:52.029]  - relaying element #6
  [15:45:52.029] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.030] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.030] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:52.030]  length: 1 (resolved future 5)
  [15:45:52.031] signalConditionsASAP(numeric, pos=6) ...
  [15:45:52.031] - nx: 6
  [15:45:52.031] - relay: TRUE
  [15:45:52.032] - stdout: TRUE
  [15:45:52.032] - signal: TRUE
  [15:45:52.032] - resignal: FALSE
  [15:45:52.032] - force: TRUE
  [15:45:52.033] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.033] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.034]  - until=6
  [15:45:52.034] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.034] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.035] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:52.035]  length: 0 (resolved future 6)
  [15:45:52.035] Relaying remaining futures
  [15:45:52.036] signalConditionsASAP(NULL, pos=0) ...
  [15:45:52.036] - nx: 6
  [15:45:52.036] - relay: TRUE
  [15:45:52.037] - stdout: TRUE
  [15:45:52.037] - signal: TRUE
  [15:45:52.037] - resignal: FALSE
  [15:45:52.038] - force: TRUE
  [15:45:52.038] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.038] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:52.039] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.039] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.039] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:52.040] 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)
  [15:45:52.052] getGlobalsAndPackages() ...
  [15:45:52.052] Searching for globals...
  [15:45:52.053] 
  [15:45:52.053] Searching for globals ... DONE
  [15:45:52.054] - globals: [0] <none>
  [15:45:52.054] getGlobalsAndPackages() ... DONE
  [15:45:52.056] Packages needed by the future expression (n = 0): <none>
  [15:45:52.057] Packages needed by future strategies (n = 0): <none>
  [15:45:52.063] {
  [15:45:52.063]     {
  [15:45:52.063]         ...future.startTime <- base::Sys.time()
  [15:45:52.063]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:52.063]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:52.063]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:52.063]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:52.063]             future.resolve.recursive = NULL, width = 80L)
  [15:45:52.063]         {
  [15:45:52.063]             {
  [15:45:52.063]                 base::local({
  [15:45:52.063]                   has_future <- base::requireNamespace("future", 
  [15:45:52.063]                     quietly = TRUE)
  [15:45:52.063]                   version <- if (has_future) 
  [15:45:52.063]                     utils::packageVersion("future")
  [15:45:52.063]                   else NULL
  [15:45:52.063]                   if (!has_future || version < "1.8.0") {
  [15:45:52.063]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:52.063]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:52.063]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:52.063]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:52.063]                         "release", "version")], collapse = " "), 
  [15:45:52.063]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:52.063]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:52.063]                       info)
  [15:45:52.063]                     info <- base::paste(info, collapse = "; ")
  [15:45:52.063]                     if (!has_future) {
  [15:45:52.063]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:52.063]                         info)
  [15:45:52.063]                     }
  [15:45:52.063]                     else {
  [15:45:52.063]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:52.063]                         info, version)
  [15:45:52.063]                     }
  [15:45:52.063]                     base::stop(msg)
  [15:45:52.063]                   }
  [15:45:52.063]                 })
  [15:45:52.063]             }
  [15:45:52.063]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:52.063]         }
  [15:45:52.063]     }
  [15:45:52.063]     if (base::is.na(TRUE)) {
  [15:45:52.063]     }
  [15:45:52.063]     else {
  [15:45:52.063]         if (TRUE) {
  [15:45:52.063]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:52.063]                 open = "w")
  [15:45:52.063]         }
  [15:45:52.063]         else {
  [15:45:52.063]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:52.063]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:52.063]         }
  [15:45:52.063]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:52.063]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:52.063]             base::sink(type = "output", split = FALSE)
  [15:45:52.063]             base::close(...future.stdout)
  [15:45:52.063]         }, add = TRUE)
  [15:45:52.063]     }
  [15:45:52.063]     ...future.frame <- base::sys.nframe()
  [15:45:52.063]     ...future.conditions <- base::list()
  [15:45:52.063]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:52.063]     ...future.result <- base::tryCatch({
  [15:45:52.063]         base::withCallingHandlers({
  [15:45:52.063]             ...future.value <- base::withVisible(base::local(2))
  [15:45:52.063]             future::FutureResult(value = ...future.value$value, 
  [15:45:52.063]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.063]                   ...future.rng), started = ...future.startTime, 
  [15:45:52.063]                 version = "1.8")
  [15:45:52.063]         }, condition = base::local({
  [15:45:52.063]             c <- base::c
  [15:45:52.063]             inherits <- base::inherits
  [15:45:52.063]             invokeRestart <- base::invokeRestart
  [15:45:52.063]             length <- base::length
  [15:45:52.063]             list <- base::list
  [15:45:52.063]             seq.int <- base::seq.int
  [15:45:52.063]             signalCondition <- base::signalCondition
  [15:45:52.063]             sys.calls <- base::sys.calls
  [15:45:52.063]             Sys.time <- base::Sys.time
  [15:45:52.063]             `[[` <- base::`[[`
  [15:45:52.063]             `+` <- base::`+`
  [15:45:52.063]             `<<-` <- base::`<<-`
  [15:45:52.063]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:52.063]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:52.063]                   3L)]
  [15:45:52.063]             }
  [15:45:52.063]             function(cond) {
  [15:45:52.063]                 if (inherits(cond, "error")) {
  [15:45:52.063]                   sessionInformation <- function() {
  [15:45:52.063]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:52.063]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:52.063]                       search = base::search(), system = base::Sys.info())
  [15:45:52.063]                   }
  [15:45:52.063]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.063]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:52.063]                     cond$call), session = sessionInformation(), 
  [15:45:52.063]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:52.063]                   signalCondition(cond)
  [15:45:52.063]                 }
  [15:45:52.063]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:52.063]                 ))) {
  [15:45:52.063]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:52.063]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.063]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:52.063]                   if (!signal) {
  [15:45:52.063]                     muffleCondition <- function (cond) 
  [15:45:52.063]                     {
  [15:45:52.063]                       inherits <- base::inherits
  [15:45:52.063]                       invokeRestart <- base::invokeRestart
  [15:45:52.063]                       muffled <- FALSE
  [15:45:52.063]                       if (inherits(cond, "message")) {
  [15:45:52.063]                         invokeRestart("muffleMessage")
  [15:45:52.063]                         muffled <- TRUE
  [15:45:52.063]                       }
  [15:45:52.063]                       else if (inherits(cond, "warning")) {
  [15:45:52.063]                         invokeRestart("muffleWarning")
  [15:45:52.063]                         muffled <- TRUE
  [15:45:52.063]                       }
  [15:45:52.063]                       else if (inherits(cond, "condition")) {
  [15:45:52.063]                         computeRestarts <- base::computeRestarts
  [15:45:52.063]                         grepl <- base::grepl
  [15:45:52.063]                         is.null <- base::is.null
  [15:45:52.063]                         restarts <- computeRestarts(cond)
  [15:45:52.063]                         for (restart in restarts) {
  [15:45:52.063]                           name <- restart$name
  [15:45:52.063]                           if (is.null(name)) 
  [15:45:52.063]                             next
  [15:45:52.063]                           if (!grepl("^muffle", name)) 
  [15:45:52.063]                             next
  [15:45:52.063]                           invokeRestart(restart)
  [15:45:52.063]                           muffled <- TRUE
  [15:45:52.063]                           break
  [15:45:52.063]                         }
  [15:45:52.063]                       }
  [15:45:52.063]                       invisible(muffled)
  [15:45:52.063]                     }
  [15:45:52.063]                     muffleCondition(cond)
  [15:45:52.063]                   }
  [15:45:52.063]                 }
  [15:45:52.063]             }
  [15:45:52.063]         }))
  [15:45:52.063]     }, error = function(ex) {
  [15:45:52.063]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:52.063]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.063]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:52.063]     }, finally = {
  [15:45:52.063]         {
  [15:45:52.063]             NULL
  [15:45:52.063]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:52.063]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:52.063]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:52.063]                 label = NULL, ...) 
  [15:45:52.063]             {
  [15:45:52.063]                 if (substitute) 
  [15:45:52.063]                   expr <- substitute(expr)
  [15:45:52.063]                 local <- as.logical(local)
  [15:45:52.063]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:52.063]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:52.063]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:52.063]                   label = label, ...)
  [15:45:52.063]                 if (!future$lazy) 
  [15:45:52.063]                   future <- run(future)
  [15:45:52.063]                 invisible(future)
  [15:45:52.063]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:52.063]         }
  [15:45:52.063]         base::options(...future.oldOptions)
  [15:45:52.063]     })
  [15:45:52.063]     Sys.time
  [15:45:52.063]     if (base::is.na(TRUE)) {
  [15:45:52.063]     }
  [15:45:52.063]     else {
  [15:45:52.063]         base::sink(type = "output", split = FALSE)
  [15:45:52.063]         if (TRUE) {
  [15:45:52.063]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:52.063]         }
  [15:45:52.063]         else {
  [15:45:52.063]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:52.063]         }
  [15:45:52.063]         base::close(...future.stdout)
  [15:45:52.063]         ...future.stdout <- NULL
  [15:45:52.063]     }
  [15:45:52.063]     ...future.result$conditions <- ...future.conditions
  [15:45:52.063]     ...future.result
  [15:45:52.063] }
  [15:45:52.068] plan(): Setting new future strategy stack:
  [15:45:52.069] List of future strategies:
  [15:45:52.069] 1. sequential:
  [15:45:52.069]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.069]    - tweaked: FALSE
  [15:45:52.069]    - call: NULL
  [15:45:52.070] plan(): nbrOfWorkers() = 1
  [15:45:52.071] plan(): Setting new future strategy stack:
  [15:45:52.071] List of future strategies:
  [15:45:52.071] 1. sequential:
  [15:45:52.071]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.071]    - tweaked: FALSE
  [15:45:52.071]    - call: plan(strategy)
  [15:45:52.072] plan(): nbrOfWorkers() = 1
  [15:45:52.073] SequentialFuture started (and completed)
  [15:45:52.074] getGlobalsAndPackages() ...
  [15:45:52.074] Searching for globals...
  [15:45:52.075] 
  [15:45:52.075] Searching for globals ... DONE
  [15:45:52.076] - globals: [0] <none>
  [15:45:52.076] getGlobalsAndPackages() ... DONE
  [15:45:52.078] Packages needed by the future expression (n = 0): <none>
  [15:45:52.081] Packages needed by future strategies (n = 0): <none>
  [15:45:52.087] {
  [15:45:52.087]     {
  [15:45:52.087]         ...future.startTime <- base::Sys.time()
  [15:45:52.087]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:52.087]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:52.087]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:52.087]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:52.087]             future.resolve.recursive = NULL, width = 80L)
  [15:45:52.087]         {
  [15:45:52.087]             {
  [15:45:52.087]                 base::local({
  [15:45:52.087]                   has_future <- base::requireNamespace("future", 
  [15:45:52.087]                     quietly = TRUE)
  [15:45:52.087]                   version <- if (has_future) 
  [15:45:52.087]                     utils::packageVersion("future")
  [15:45:52.087]                   else NULL
  [15:45:52.087]                   if (!has_future || version < "1.8.0") {
  [15:45:52.087]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:52.087]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:52.087]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:52.087]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:52.087]                         "release", "version")], collapse = " "), 
  [15:45:52.087]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:52.087]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:52.087]                       info)
  [15:45:52.087]                     info <- base::paste(info, collapse = "; ")
  [15:45:52.087]                     if (!has_future) {
  [15:45:52.087]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:52.087]                         info)
  [15:45:52.087]                     }
  [15:45:52.087]                     else {
  [15:45:52.087]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:52.087]                         info, version)
  [15:45:52.087]                     }
  [15:45:52.087]                     base::stop(msg)
  [15:45:52.087]                   }
  [15:45:52.087]                 })
  [15:45:52.087]             }
  [15:45:52.087]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:52.087]         }
  [15:45:52.087]     }
  [15:45:52.087]     if (base::is.na(TRUE)) {
  [15:45:52.087]     }
  [15:45:52.087]     else {
  [15:45:52.087]         if (TRUE) {
  [15:45:52.087]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:52.087]                 open = "w")
  [15:45:52.087]         }
  [15:45:52.087]         else {
  [15:45:52.087]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:52.087]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:52.087]         }
  [15:45:52.087]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:52.087]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:52.087]             base::sink(type = "output", split = FALSE)
  [15:45:52.087]             base::close(...future.stdout)
  [15:45:52.087]         }, add = TRUE)
  [15:45:52.087]     }
  [15:45:52.087]     ...future.frame <- base::sys.nframe()
  [15:45:52.087]     ...future.conditions <- base::list()
  [15:45:52.087]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:52.087]     ...future.result <- base::tryCatch({
  [15:45:52.087]         base::withCallingHandlers({
  [15:45:52.087]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:52.087]             future::FutureResult(value = ...future.value$value, 
  [15:45:52.087]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.087]                   ...future.rng), started = ...future.startTime, 
  [15:45:52.087]                 version = "1.8")
  [15:45:52.087]         }, condition = base::local({
  [15:45:52.087]             c <- base::c
  [15:45:52.087]             inherits <- base::inherits
  [15:45:52.087]             invokeRestart <- base::invokeRestart
  [15:45:52.087]             length <- base::length
  [15:45:52.087]             list <- base::list
  [15:45:52.087]             seq.int <- base::seq.int
  [15:45:52.087]             signalCondition <- base::signalCondition
  [15:45:52.087]             sys.calls <- base::sys.calls
  [15:45:52.087]             Sys.time <- base::Sys.time
  [15:45:52.087]             `[[` <- base::`[[`
  [15:45:52.087]             `+` <- base::`+`
  [15:45:52.087]             `<<-` <- base::`<<-`
  [15:45:52.087]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:52.087]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:52.087]                   3L)]
  [15:45:52.087]             }
  [15:45:52.087]             function(cond) {
  [15:45:52.087]                 if (inherits(cond, "error")) {
  [15:45:52.087]                   sessionInformation <- function() {
  [15:45:52.087]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:52.087]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:52.087]                       search = base::search(), system = base::Sys.info())
  [15:45:52.087]                   }
  [15:45:52.087]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.087]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:52.087]                     cond$call), session = sessionInformation(), 
  [15:45:52.087]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:52.087]                   signalCondition(cond)
  [15:45:52.087]                 }
  [15:45:52.087]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:52.087]                 ))) {
  [15:45:52.087]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:52.087]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.087]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:52.087]                   if (!signal) {
  [15:45:52.087]                     muffleCondition <- function (cond) 
  [15:45:52.087]                     {
  [15:45:52.087]                       inherits <- base::inherits
  [15:45:52.087]                       invokeRestart <- base::invokeRestart
  [15:45:52.087]                       muffled <- FALSE
  [15:45:52.087]                       if (inherits(cond, "message")) {
  [15:45:52.087]                         invokeRestart("muffleMessage")
  [15:45:52.087]                         muffled <- TRUE
  [15:45:52.087]                       }
  [15:45:52.087]                       else if (inherits(cond, "warning")) {
  [15:45:52.087]                         invokeRestart("muffleWarning")
  [15:45:52.087]                         muffled <- TRUE
  [15:45:52.087]                       }
  [15:45:52.087]                       else if (inherits(cond, "condition")) {
  [15:45:52.087]                         computeRestarts <- base::computeRestarts
  [15:45:52.087]                         grepl <- base::grepl
  [15:45:52.087]                         is.null <- base::is.null
  [15:45:52.087]                         restarts <- computeRestarts(cond)
  [15:45:52.087]                         for (restart in restarts) {
  [15:45:52.087]                           name <- restart$name
  [15:45:52.087]                           if (is.null(name)) 
  [15:45:52.087]                             next
  [15:45:52.087]                           if (!grepl("^muffle", name)) 
  [15:45:52.087]                             next
  [15:45:52.087]                           invokeRestart(restart)
  [15:45:52.087]                           muffled <- TRUE
  [15:45:52.087]                           break
  [15:45:52.087]                         }
  [15:45:52.087]                       }
  [15:45:52.087]                       invisible(muffled)
  [15:45:52.087]                     }
  [15:45:52.087]                     muffleCondition(cond)
  [15:45:52.087]                   }
  [15:45:52.087]                 }
  [15:45:52.087]             }
  [15:45:52.087]         }))
  [15:45:52.087]     }, error = function(ex) {
  [15:45:52.087]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:52.087]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.087]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:52.087]     }, finally = {
  [15:45:52.087]         {
  [15:45:52.087]             NULL
  [15:45:52.087]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:52.087]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:52.087]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:52.087]                 label = NULL, ...) 
  [15:45:52.087]             {
  [15:45:52.087]                 if (substitute) 
  [15:45:52.087]                   expr <- substitute(expr)
  [15:45:52.087]                 local <- as.logical(local)
  [15:45:52.087]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:52.087]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:52.087]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:52.087]                   label = label, ...)
  [15:45:52.087]                 if (!future$lazy) 
  [15:45:52.087]                   future <- run(future)
  [15:45:52.087]                 invisible(future)
  [15:45:52.087]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:52.087]         }
  [15:45:52.087]         base::options(...future.oldOptions)
  [15:45:52.087]     })
  [15:45:52.087]     Sys.time
  [15:45:52.087]     if (base::is.na(TRUE)) {
  [15:45:52.087]     }
  [15:45:52.087]     else {
  [15:45:52.087]         base::sink(type = "output", split = FALSE)
  [15:45:52.087]         if (TRUE) {
  [15:45:52.087]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:52.087]         }
  [15:45:52.087]         else {
  [15:45:52.087]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:52.087]         }
  [15:45:52.087]         base::close(...future.stdout)
  [15:45:52.087]         ...future.stdout <- NULL
  [15:45:52.087]     }
  [15:45:52.087]     ...future.result$conditions <- ...future.conditions
  [15:45:52.087]     ...future.result
  [15:45:52.087] }
  [15:45:52.092] plan(): Setting new future strategy stack:
  [15:45:52.092] List of future strategies:
  [15:45:52.092] 1. sequential:
  [15:45:52.092]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.092]    - tweaked: FALSE
  [15:45:52.092]    - call: NULL
  [15:45:52.093] plan(): nbrOfWorkers() = 1
  [15:45:52.111] plan(): Setting new future strategy stack:
  [15:45:52.111] List of future strategies:
  [15:45:52.111] 1. sequential:
  [15:45:52.111]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.111]    - tweaked: FALSE
  [15:45:52.111]    - call: plan(strategy)
  [15:45:52.112] plan(): nbrOfWorkers() = 1
  [15:45:52.113] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca28e6a158> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2a987fa8> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca28e6a158> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2a987fa8> 
   $  : 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" "" ...
  [15:45:52.156] resolve() on list ...
  [15:45:52.157]  recursive: 0
  [15:45:52.157]  length: 6
  [15:45:52.158]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:52.158] signalConditionsASAP(numeric, pos=1) ...
  [15:45:52.158] - nx: 6
  [15:45:52.159] - relay: TRUE
  [15:45:52.159] - stdout: TRUE
  [15:45:52.159] - signal: TRUE
  [15:45:52.159] - resignal: FALSE
  [15:45:52.160] - force: TRUE
  [15:45:52.160] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.160] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.161]  - until=2
  [15:45:52.161]  - relaying element #2
  [15:45:52.161] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.162] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.162] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:52.163]  length: 5 (resolved future 1)
  [15:45:52.163] Future #2
  [15:45:52.163] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:52.164] - nx: 6
  [15:45:52.164] - relay: TRUE
  [15:45:52.164] - stdout: TRUE
  [15:45:52.165] - signal: TRUE
  [15:45:52.165] - resignal: FALSE
  [15:45:52.165] - force: TRUE
  [15:45:52.166] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.166] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.166]  - until=2
  [15:45:52.167]  - relaying element #2
  [15:45:52.167] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.168] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.168] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:52.168]  length: 4 (resolved future 2)
  [15:45:52.169] Future #3
  [15:45:52.169] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:52.170] - nx: 6
  [15:45:52.170] - relay: TRUE
  [15:45:52.170] - stdout: TRUE
  [15:45:52.171] - signal: TRUE
  [15:45:52.171] - resignal: FALSE
  [15:45:52.171] - force: TRUE
  [15:45:52.172] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.172] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.172]  - until=3
  [15:45:52.173]  - relaying element #3
  [15:45:52.173] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.174] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.174] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:52.174]  length: 3 (resolved future 3)
  [15:45:52.175] signalConditionsASAP(NULL, pos=4) ...
  [15:45:52.175] - nx: 6
  [15:45:52.175] - relay: TRUE
  [15:45:52.176] - stdout: TRUE
  [15:45:52.176] - signal: TRUE
  [15:45:52.176] - resignal: FALSE
  [15:45:52.176] - force: TRUE
  [15:45:52.177] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.177] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.177]  - until=5
  [15:45:52.178]  - relaying element #5
  [15:45:52.178] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.178] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.179] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:52.179]  length: 2 (resolved future 4)
  [15:45:52.179] signalConditionsASAP(NULL, pos=5) ...
  [15:45:52.180] - nx: 6
  [15:45:52.180] - relay: TRUE
  [15:45:52.180] - stdout: TRUE
  [15:45:52.181] - signal: TRUE
  [15:45:52.181] - resignal: FALSE
  [15:45:52.181] - force: TRUE
  [15:45:52.182] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.182] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.182]  - until=6
  [15:45:52.183]  - relaying element #6
  [15:45:52.183] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.183] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.184] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:52.184]  length: 1 (resolved future 5)
  [15:45:52.184] signalConditionsASAP(numeric, pos=6) ...
  [15:45:52.185] - nx: 6
  [15:45:52.185] - relay: TRUE
  [15:45:52.185] - stdout: TRUE
  [15:45:52.185] - signal: TRUE
  [15:45:52.186] - resignal: FALSE
  [15:45:52.186] - force: TRUE
  [15:45:52.186] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.187] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.187]  - until=6
  [15:45:52.187] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.188] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.188] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:52.189]  length: 0 (resolved future 6)
  [15:45:52.189] Relaying remaining futures
  [15:45:52.189] signalConditionsASAP(NULL, pos=0) ...
  [15:45:52.189] - nx: 6
  [15:45:52.190] - relay: TRUE
  [15:45:52.190] - stdout: TRUE
  [15:45:52.190] - signal: TRUE
  [15:45:52.191] - resignal: FALSE
  [15:45:52.191] - force: TRUE
  [15:45:52.191] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.192] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:52.192] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.193] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.193] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:52.193] 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)
  [15:45:52.206] getGlobalsAndPackages() ...
  [15:45:52.207] Searching for globals...
  [15:45:52.207] 
  [15:45:52.208] Searching for globals ... DONE
  [15:45:52.208] - globals: [0] <none>
  [15:45:52.208] getGlobalsAndPackages() ... DONE
  [15:45:52.211] Packages needed by the future expression (n = 0): <none>
  [15:45:52.211] Packages needed by future strategies (n = 0): <none>
  [15:45:52.218] {
  [15:45:52.218]     {
  [15:45:52.218]         ...future.startTime <- base::Sys.time()
  [15:45:52.218]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:52.218]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:52.218]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:52.218]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:52.218]             future.resolve.recursive = NULL, width = 80L)
  [15:45:52.218]         {
  [15:45:52.218]             {
  [15:45:52.218]                 base::local({
  [15:45:52.218]                   has_future <- base::requireNamespace("future", 
  [15:45:52.218]                     quietly = TRUE)
  [15:45:52.218]                   version <- if (has_future) 
  [15:45:52.218]                     utils::packageVersion("future")
  [15:45:52.218]                   else NULL
  [15:45:52.218]                   if (!has_future || version < "1.8.0") {
  [15:45:52.218]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:52.218]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:52.218]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:52.218]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:52.218]                         "release", "version")], collapse = " "), 
  [15:45:52.218]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:52.218]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:52.218]                       info)
  [15:45:52.218]                     info <- base::paste(info, collapse = "; ")
  [15:45:52.218]                     if (!has_future) {
  [15:45:52.218]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:52.218]                         info)
  [15:45:52.218]                     }
  [15:45:52.218]                     else {
  [15:45:52.218]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:52.218]                         info, version)
  [15:45:52.218]                     }
  [15:45:52.218]                     base::stop(msg)
  [15:45:52.218]                   }
  [15:45:52.218]                 })
  [15:45:52.218]             }
  [15:45:52.218]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:52.218]         }
  [15:45:52.218]     }
  [15:45:52.218]     if (base::is.na(TRUE)) {
  [15:45:52.218]     }
  [15:45:52.218]     else {
  [15:45:52.218]         if (TRUE) {
  [15:45:52.218]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:52.218]                 open = "w")
  [15:45:52.218]         }
  [15:45:52.218]         else {
  [15:45:52.218]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:52.218]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:52.218]         }
  [15:45:52.218]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:52.218]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:52.218]             base::sink(type = "output", split = FALSE)
  [15:45:52.218]             base::close(...future.stdout)
  [15:45:52.218]         }, add = TRUE)
  [15:45:52.218]     }
  [15:45:52.218]     ...future.frame <- base::sys.nframe()
  [15:45:52.218]     ...future.conditions <- base::list()
  [15:45:52.218]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:52.218]     ...future.result <- base::tryCatch({
  [15:45:52.218]         base::withCallingHandlers({
  [15:45:52.218]             ...future.value <- base::withVisible(base::local(2))
  [15:45:52.218]             future::FutureResult(value = ...future.value$value, 
  [15:45:52.218]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.218]                   ...future.rng), started = ...future.startTime, 
  [15:45:52.218]                 version = "1.8")
  [15:45:52.218]         }, condition = base::local({
  [15:45:52.218]             c <- base::c
  [15:45:52.218]             inherits <- base::inherits
  [15:45:52.218]             invokeRestart <- base::invokeRestart
  [15:45:52.218]             length <- base::length
  [15:45:52.218]             list <- base::list
  [15:45:52.218]             seq.int <- base::seq.int
  [15:45:52.218]             signalCondition <- base::signalCondition
  [15:45:52.218]             sys.calls <- base::sys.calls
  [15:45:52.218]             Sys.time <- base::Sys.time
  [15:45:52.218]             `[[` <- base::`[[`
  [15:45:52.218]             `+` <- base::`+`
  [15:45:52.218]             `<<-` <- base::`<<-`
  [15:45:52.218]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:52.218]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:52.218]                   3L)]
  [15:45:52.218]             }
  [15:45:52.218]             function(cond) {
  [15:45:52.218]                 if (inherits(cond, "error")) {
  [15:45:52.218]                   sessionInformation <- function() {
  [15:45:52.218]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:52.218]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:52.218]                       search = base::search(), system = base::Sys.info())
  [15:45:52.218]                   }
  [15:45:52.218]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.218]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:52.218]                     cond$call), session = sessionInformation(), 
  [15:45:52.218]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:52.218]                   signalCondition(cond)
  [15:45:52.218]                 }
  [15:45:52.218]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:52.218]                 ))) {
  [15:45:52.218]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:52.218]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.218]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:52.218]                   if (!signal) {
  [15:45:52.218]                     muffleCondition <- function (cond) 
  [15:45:52.218]                     {
  [15:45:52.218]                       inherits <- base::inherits
  [15:45:52.218]                       invokeRestart <- base::invokeRestart
  [15:45:52.218]                       muffled <- FALSE
  [15:45:52.218]                       if (inherits(cond, "message")) {
  [15:45:52.218]                         invokeRestart("muffleMessage")
  [15:45:52.218]                         muffled <- TRUE
  [15:45:52.218]                       }
  [15:45:52.218]                       else if (inherits(cond, "warning")) {
  [15:45:52.218]                         invokeRestart("muffleWarning")
  [15:45:52.218]                         muffled <- TRUE
  [15:45:52.218]                       }
  [15:45:52.218]                       else if (inherits(cond, "condition")) {
  [15:45:52.218]                         computeRestarts <- base::computeRestarts
  [15:45:52.218]                         grepl <- base::grepl
  [15:45:52.218]                         is.null <- base::is.null
  [15:45:52.218]                         restarts <- computeRestarts(cond)
  [15:45:52.218]                         for (restart in restarts) {
  [15:45:52.218]                           name <- restart$name
  [15:45:52.218]                           if (is.null(name)) 
  [15:45:52.218]                             next
  [15:45:52.218]                           if (!grepl("^muffle", name)) 
  [15:45:52.218]                             next
  [15:45:52.218]                           invokeRestart(restart)
  [15:45:52.218]                           muffled <- TRUE
  [15:45:52.218]                           break
  [15:45:52.218]                         }
  [15:45:52.218]                       }
  [15:45:52.218]                       invisible(muffled)
  [15:45:52.218]                     }
  [15:45:52.218]                     muffleCondition(cond)
  [15:45:52.218]                   }
  [15:45:52.218]                 }
  [15:45:52.218]             }
  [15:45:52.218]         }))
  [15:45:52.218]     }, error = function(ex) {
  [15:45:52.218]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:52.218]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.218]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:52.218]     }, finally = {
  [15:45:52.218]         {
  [15:45:52.218]             NULL
  [15:45:52.218]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:52.218]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:52.218]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:52.218]                 label = NULL, ...) 
  [15:45:52.218]             {
  [15:45:52.218]                 if (substitute) 
  [15:45:52.218]                   expr <- substitute(expr)
  [15:45:52.218]                 local <- as.logical(local)
  [15:45:52.218]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:52.218]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:52.218]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:52.218]                   label = label, ...)
  [15:45:52.218]                 if (!future$lazy) 
  [15:45:52.218]                   future <- run(future)
  [15:45:52.218]                 invisible(future)
  [15:45:52.218]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:52.218]         }
  [15:45:52.218]         base::options(...future.oldOptions)
  [15:45:52.218]     })
  [15:45:52.218]     Sys.time
  [15:45:52.218]     if (base::is.na(TRUE)) {
  [15:45:52.218]     }
  [15:45:52.218]     else {
  [15:45:52.218]         base::sink(type = "output", split = FALSE)
  [15:45:52.218]         if (TRUE) {
  [15:45:52.218]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:52.218]         }
  [15:45:52.218]         else {
  [15:45:52.218]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:52.218]         }
  [15:45:52.218]         base::close(...future.stdout)
  [15:45:52.218]         ...future.stdout <- NULL
  [15:45:52.218]     }
  [15:45:52.218]     ...future.result$conditions <- ...future.conditions
  [15:45:52.218]     ...future.result
  [15:45:52.218] }
  [15:45:52.223] plan(): Setting new future strategy stack:
  [15:45:52.223] List of future strategies:
  [15:45:52.223] 1. sequential:
  [15:45:52.223]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.223]    - tweaked: FALSE
  [15:45:52.223]    - call: NULL
  [15:45:52.225] plan(): nbrOfWorkers() = 1
  [15:45:52.226] plan(): Setting new future strategy stack:
  [15:45:52.226] List of future strategies:
  [15:45:52.226] 1. sequential:
  [15:45:52.226]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.226]    - tweaked: FALSE
  [15:45:52.226]    - call: plan(strategy)
  [15:45:52.228] plan(): nbrOfWorkers() = 1
  [15:45:52.228] SequentialFuture started (and completed)
  [15:45:52.229] getGlobalsAndPackages() ...
  [15:45:52.229] Searching for globals...
  [15:45:52.233] 
  [15:45:52.233] Searching for globals ... DONE
  [15:45:52.234] - globals: [0] <none>
  [15:45:52.234] getGlobalsAndPackages() ... DONE
  [15:45:52.236] Packages needed by the future expression (n = 0): <none>
  [15:45:52.237] Packages needed by future strategies (n = 0): <none>
  [15:45:52.243] {
  [15:45:52.243]     {
  [15:45:52.243]         ...future.startTime <- base::Sys.time()
  [15:45:52.243]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:52.243]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:52.243]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:52.243]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:52.243]             future.resolve.recursive = NULL, width = 80L)
  [15:45:52.243]         {
  [15:45:52.243]             {
  [15:45:52.243]                 base::local({
  [15:45:52.243]                   has_future <- base::requireNamespace("future", 
  [15:45:52.243]                     quietly = TRUE)
  [15:45:52.243]                   version <- if (has_future) 
  [15:45:52.243]                     utils::packageVersion("future")
  [15:45:52.243]                   else NULL
  [15:45:52.243]                   if (!has_future || version < "1.8.0") {
  [15:45:52.243]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:52.243]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:52.243]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:52.243]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:52.243]                         "release", "version")], collapse = " "), 
  [15:45:52.243]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:52.243]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:52.243]                       info)
  [15:45:52.243]                     info <- base::paste(info, collapse = "; ")
  [15:45:52.243]                     if (!has_future) {
  [15:45:52.243]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:52.243]                         info)
  [15:45:52.243]                     }
  [15:45:52.243]                     else {
  [15:45:52.243]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:52.243]                         info, version)
  [15:45:52.243]                     }
  [15:45:52.243]                     base::stop(msg)
  [15:45:52.243]                   }
  [15:45:52.243]                 })
  [15:45:52.243]             }
  [15:45:52.243]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:52.243]         }
  [15:45:52.243]     }
  [15:45:52.243]     if (base::is.na(TRUE)) {
  [15:45:52.243]     }
  [15:45:52.243]     else {
  [15:45:52.243]         if (TRUE) {
  [15:45:52.243]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:52.243]                 open = "w")
  [15:45:52.243]         }
  [15:45:52.243]         else {
  [15:45:52.243]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:52.243]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:52.243]         }
  [15:45:52.243]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:52.243]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:52.243]             base::sink(type = "output", split = FALSE)
  [15:45:52.243]             base::close(...future.stdout)
  [15:45:52.243]         }, add = TRUE)
  [15:45:52.243]     }
  [15:45:52.243]     ...future.frame <- base::sys.nframe()
  [15:45:52.243]     ...future.conditions <- base::list()
  [15:45:52.243]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:52.243]     ...future.result <- base::tryCatch({
  [15:45:52.243]         base::withCallingHandlers({
  [15:45:52.243]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:52.243]             future::FutureResult(value = ...future.value$value, 
  [15:45:52.243]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.243]                   ...future.rng), started = ...future.startTime, 
  [15:45:52.243]                 version = "1.8")
  [15:45:52.243]         }, condition = base::local({
  [15:45:52.243]             c <- base::c
  [15:45:52.243]             inherits <- base::inherits
  [15:45:52.243]             invokeRestart <- base::invokeRestart
  [15:45:52.243]             length <- base::length
  [15:45:52.243]             list <- base::list
  [15:45:52.243]             seq.int <- base::seq.int
  [15:45:52.243]             signalCondition <- base::signalCondition
  [15:45:52.243]             sys.calls <- base::sys.calls
  [15:45:52.243]             Sys.time <- base::Sys.time
  [15:45:52.243]             `[[` <- base::`[[`
  [15:45:52.243]             `+` <- base::`+`
  [15:45:52.243]             `<<-` <- base::`<<-`
  [15:45:52.243]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:52.243]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:52.243]                   3L)]
  [15:45:52.243]             }
  [15:45:52.243]             function(cond) {
  [15:45:52.243]                 if (inherits(cond, "error")) {
  [15:45:52.243]                   sessionInformation <- function() {
  [15:45:52.243]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:52.243]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:52.243]                       search = base::search(), system = base::Sys.info())
  [15:45:52.243]                   }
  [15:45:52.243]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.243]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:52.243]                     cond$call), session = sessionInformation(), 
  [15:45:52.243]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:52.243]                   signalCondition(cond)
  [15:45:52.243]                 }
  [15:45:52.243]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:52.243]                 ))) {
  [15:45:52.243]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:52.243]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:52.243]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:52.243]                   if (!signal) {
  [15:45:52.243]                     muffleCondition <- function (cond) 
  [15:45:52.243]                     {
  [15:45:52.243]                       inherits <- base::inherits
  [15:45:52.243]                       invokeRestart <- base::invokeRestart
  [15:45:52.243]                       muffled <- FALSE
  [15:45:52.243]                       if (inherits(cond, "message")) {
  [15:45:52.243]                         invokeRestart("muffleMessage")
  [15:45:52.243]                         muffled <- TRUE
  [15:45:52.243]                       }
  [15:45:52.243]                       else if (inherits(cond, "warning")) {
  [15:45:52.243]                         invokeRestart("muffleWarning")
  [15:45:52.243]                         muffled <- TRUE
  [15:45:52.243]                       }
  [15:45:52.243]                       else if (inherits(cond, "condition")) {
  [15:45:52.243]                         computeRestarts <- base::computeRestarts
  [15:45:52.243]                         grepl <- base::grepl
  [15:45:52.243]                         is.null <- base::is.null
  [15:45:52.243]                         restarts <- computeRestarts(cond)
  [15:45:52.243]                         for (restart in restarts) {
  [15:45:52.243]                           name <- restart$name
  [15:45:52.243]                           if (is.null(name)) 
  [15:45:52.243]                             next
  [15:45:52.243]                           if (!grepl("^muffle", name)) 
  [15:45:52.243]                             next
  [15:45:52.243]                           invokeRestart(restart)
  [15:45:52.243]                           muffled <- TRUE
  [15:45:52.243]                           break
  [15:45:52.243]                         }
  [15:45:52.243]                       }
  [15:45:52.243]                       invisible(muffled)
  [15:45:52.243]                     }
  [15:45:52.243]                     muffleCondition(cond)
  [15:45:52.243]                   }
  [15:45:52.243]                 }
  [15:45:52.243]             }
  [15:45:52.243]         }))
  [15:45:52.243]     }, error = function(ex) {
  [15:45:52.243]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:52.243]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:52.243]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:52.243]     }, finally = {
  [15:45:52.243]         {
  [15:45:52.243]             NULL
  [15:45:52.243]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:52.243]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:52.243]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:52.243]                 label = NULL, ...) 
  [15:45:52.243]             {
  [15:45:52.243]                 if (substitute) 
  [15:45:52.243]                   expr <- substitute(expr)
  [15:45:52.243]                 local <- as.logical(local)
  [15:45:52.243]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:52.243]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:52.243]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:52.243]                   label = label, ...)
  [15:45:52.243]                 if (!future$lazy) 
  [15:45:52.243]                   future <- run(future)
  [15:45:52.243]                 invisible(future)
  [15:45:52.243]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:52.243]         }
  [15:45:52.243]         base::options(...future.oldOptions)
  [15:45:52.243]     })
  [15:45:52.243]     Sys.time
  [15:45:52.243]     if (base::is.na(TRUE)) {
  [15:45:52.243]     }
  [15:45:52.243]     else {
  [15:45:52.243]         base::sink(type = "output", split = FALSE)
  [15:45:52.243]         if (TRUE) {
  [15:45:52.243]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:52.243]         }
  [15:45:52.243]         else {
  [15:45:52.243]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:52.243]         }
  [15:45:52.243]         base::close(...future.stdout)
  [15:45:52.243]         ...future.stdout <- NULL
  [15:45:52.243]     }
  [15:45:52.243]     ...future.result$conditions <- ...future.conditions
  [15:45:52.243]     ...future.result
  [15:45:52.243] }
  [15:45:52.248] plan(): Setting new future strategy stack:
  [15:45:52.248] List of future strategies:
  [15:45:52.248] 1. sequential:
  [15:45:52.248]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.248]    - tweaked: FALSE
  [15:45:52.248]    - call: NULL
  [15:45:52.249] plan(): nbrOfWorkers() = 1
  [15:45:52.251] plan(): Setting new future strategy stack:
  [15:45:52.251] List of future strategies:
  [15:45:52.251] 1. sequential:
  [15:45:52.251]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:52.251]    - tweaked: FALSE
  [15:45:52.251]    - call: plan(strategy)
  [15:45:52.252] plan(): nbrOfWorkers() = 1
  [15:45:52.253] SequentialFuture started (and completed)
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2abe07f8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca298f4230> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca2abe07f8> 
   $ c:Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x55ca298f4230> 
   $  : 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" "" ...
  [15:45:52.279] resolve() on list ...
  [15:45:52.279]  recursive: 0
  [15:45:52.280]  length: 6
  [15:45:52.280]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:52.280] signalConditionsASAP(numeric, pos=1) ...
  [15:45:52.281] - nx: 6
  [15:45:52.281] - relay: TRUE
  [15:45:52.281] - stdout: TRUE
  [15:45:52.282] - signal: TRUE
  [15:45:52.282] - resignal: FALSE
  [15:45:52.282] - force: TRUE
  [15:45:52.282] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.283] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.283]  - until=2
  [15:45:52.284]  - relaying element #2
  [15:45:52.284] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.284] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.285] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:52.285]  length: 5 (resolved future 1)
  [15:45:52.285] Future #2
  [15:45:52.286] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:52.286] - nx: 6
  [15:45:52.286] - relay: TRUE
  [15:45:52.287] - stdout: TRUE
  [15:45:52.287] - signal: TRUE
  [15:45:52.287] - resignal: FALSE
  [15:45:52.288] - force: TRUE
  [15:45:52.288] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.288] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.289]  - until=2
  [15:45:52.289]  - relaying element #2
  [15:45:52.290] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.290] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.290] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:52.291]  length: 4 (resolved future 2)
  [15:45:52.291] Future #3
  [15:45:52.292] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:52.292] - nx: 6
  [15:45:52.292] - relay: TRUE
  [15:45:52.293] - stdout: TRUE
  [15:45:52.293] - signal: TRUE
  [15:45:52.293] - resignal: FALSE
  [15:45:52.294] - force: TRUE
  [15:45:52.294] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.294] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:52.295]  - until=3
  [15:45:52.295]  - relaying element #3
  [15:45:52.296] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.296] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.296] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:52.297]  length: 3 (resolved future 3)
  [15:45:52.297] signalConditionsASAP(NULL, pos=4) ...
  [15:45:52.297] - nx: 6
  [15:45:52.298] - relay: TRUE
  [15:45:52.298] - stdout: TRUE
  [15:45:52.298] - signal: TRUE
  [15:45:52.299] - resignal: FALSE
  [15:45:52.299] - force: TRUE
  [15:45:52.299] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.300] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.300]  - until=5
  [15:45:52.300]  - relaying element #5
  [15:45:52.301] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.301] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.301] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:52.302]  length: 2 (resolved future 4)
  [15:45:52.302] signalConditionsASAP(NULL, pos=5) ...
  [15:45:52.302] - nx: 6
  [15:45:52.303] - relay: TRUE
  [15:45:52.303] - stdout: TRUE
  [15:45:52.303] - signal: TRUE
  [15:45:52.304] - resignal: FALSE
  [15:45:52.304] - force: TRUE
  [15:45:52.304] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:52.305] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.305]  - until=6
  [15:45:52.305]  - relaying element #6
  [15:45:52.306] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.306] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.306] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:52.307]  length: 1 (resolved future 5)
  [15:45:52.307] signalConditionsASAP(numeric, pos=6) ...
  [15:45:52.307] - nx: 6
  [15:45:52.308] - relay: TRUE
  [15:45:52.308] - stdout: TRUE
  [15:45:52.308] - signal: TRUE
  [15:45:52.309] - resignal: FALSE
  [15:45:52.309] - force: TRUE
  [15:45:52.309] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:52.310] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.310]  - until=6
  [15:45:52.310] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.311] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.311] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:52.311]  length: 0 (resolved future 6)
  [15:45:52.312] Relaying remaining futures
  [15:45:52.312] signalConditionsASAP(NULL, pos=0) ...
  [15:45:52.312] - nx: 6
  [15:45:52.313] - relay: TRUE
  [15:45:52.313] - stdout: TRUE
  [15:45:52.313] - signal: TRUE
  [15:45:52.314] - resignal: FALSE
  [15:45:52.314] - force: TRUE
  [15:45:52.314] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.318] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:52.319] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:52.319] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:52.320] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:52.320] 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
  [15:45:52.334] plan(): Setting new future strategy stack:
  [15:45:52.335] List of future strategies:
  [15:45:52.335] 1. cluster:
  [15:45:52.335]    - 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, ...)
  [15:45:52.335]    - tweaked: FALSE
  [15:45:52.335]    - call: plan(strategy)
  [15:45:52.336] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [15:45:52.336] cluster:
  [15:45:52.336] - 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, ...)
  [15:45:52.336] - tweaked: FALSE
  [15:45:52.336] - call: plan(strategy)
  [15:45:52.338] getGlobalsAndPackages() ...
  [15:45:52.338] Not searching for globals
  [15:45:52.339] - globals: [0] <none>
  [15:45:52.339] getGlobalsAndPackages() ... DONE
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 26793
  [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/Rtmp4zIndi/future.parent=13636.354463956964.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmp4zIndi/future.parent=13636.354463956964.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:13636' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmp4zIndi/future.parent=13636.354463956964.pid")), silent = TRUE)' -e 'workRSOCK <- tryCatch(parallel:::.slaveRSOCK, error=function(e) parallel:::.workRSOCK); workRSOCK()' MASTER=localhost PORT=26793 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
  [15:45:53.783] Packages needed by the future expression (n = 0): <none>
  [15:45:53.783] Packages needed by future strategies (n = 0): <none>
  [15:45:53.790] {
  [15:45:53.790]     {
  [15:45:53.790]         ...future.startTime <- base::Sys.time()
  [15:45:53.790]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:53.790]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:53.790]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:53.790]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:53.790]             future.resolve.recursive = NULL, width = 80L)
  [15:45:53.790]         {
  [15:45:53.790]             {
  [15:45:53.790]                 base::local({
  [15:45:53.790]                   has_future <- base::requireNamespace("future", 
  [15:45:53.790]                     quietly = TRUE)
  [15:45:53.790]                   version <- if (has_future) 
  [15:45:53.790]                     utils::packageVersion("future")
  [15:45:53.790]                   else NULL
  [15:45:53.790]                   if (!has_future || version < "1.8.0") {
  [15:45:53.790]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:53.790]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:53.790]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:53.790]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:53.790]                         "release", "version")], collapse = " "), 
  [15:45:53.790]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:53.790]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:53.790]                       info)
  [15:45:53.790]                     info <- base::paste(info, collapse = "; ")
  [15:45:53.790]                     if (!has_future) {
  [15:45:53.790]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:53.790]                         info)
  [15:45:53.790]                     }
  [15:45:53.790]                     else {
  [15:45:53.790]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:53.790]                         info, version)
  [15:45:53.790]                     }
  [15:45:53.790]                     base::stop(msg)
  [15:45:53.790]                   }
  [15:45:53.790]                 })
  [15:45:53.790]             }
  [15:45:53.790]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:53.790]         }
  [15:45:53.790]     }
  [15:45:53.790]     if (base::is.na(TRUE)) {
  [15:45:53.790]     }
  [15:45:53.790]     else {
  [15:45:53.790]         if (TRUE) {
  [15:45:53.790]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:53.790]                 open = "w")
  [15:45:53.790]         }
  [15:45:53.790]         else {
  [15:45:53.790]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:53.790]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:53.790]         }
  [15:45:53.790]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:53.790]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:53.790]             base::sink(type = "output", split = FALSE)
  [15:45:53.790]             base::close(...future.stdout)
  [15:45:53.790]         }, add = TRUE)
  [15:45:53.790]     }
  [15:45:53.790]     ...future.frame <- base::sys.nframe()
  [15:45:53.790]     ...future.conditions <- base::list()
  [15:45:53.790]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:53.790]     ...future.result <- base::tryCatch({
  [15:45:53.790]         base::withCallingHandlers({
  [15:45:53.790]             ...future.value <- base::withVisible(base::local({
  [15:45:53.790]                 ...future.sendCondition <- local({
  [15:45:53.790]                   sendCondition <- NULL
  [15:45:53.790]                   function(frame = 1L) {
  [15:45:53.790]                     if (is.function(sendCondition)) 
  [15:45:53.790]                       return(sendCondition)
  [15:45:53.790]                     ns <- getNamespace("parallel")
  [15:45:53.790]                     if (exists("sendData", mode = "function", 
  [15:45:53.790]                       envir = ns)) {
  [15:45:53.790]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:53.790]                         envir = ns)
  [15:45:53.790]                       envir <- sys.frame(frame)
  [15:45:53.790]                       master <- NULL
  [15:45:53.790]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:53.790]                         !identical(envir, emptyenv())) {
  [15:45:53.790]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:53.790]                           inherits = FALSE)) {
  [15:45:53.790]                           master <- get("master", mode = "list", 
  [15:45:53.790]                             envir = envir, inherits = FALSE)
  [15:45:53.790]                           if (inherits(master, "SOCKnode")) {
  [15:45:53.790]                             sendCondition <<- function(cond) {
  [15:45:53.790]                               data <- list(type = "VALUE", value = cond, 
  [15:45:53.790]                                 success = TRUE)
  [15:45:53.790]                               parallel_sendData(master, data)
  [15:45:53.790]                             }
  [15:45:53.790]                             return(sendCondition)
  [15:45:53.790]                           }
  [15:45:53.790]                         }
  [15:45:53.790]                         frame <- frame + 1L
  [15:45:53.790]                         envir <- sys.frame(frame)
  [15:45:53.790]                       }
  [15:45:53.790]                     }
  [15:45:53.790]                     sendCondition <<- function(cond) NULL
  [15:45:53.790]                   }
  [15:45:53.790]                 })
  [15:45:53.790]                 withCallingHandlers({
  [15:45:53.790]                   NA
  [15:45:53.790]                 }, immediateCondition = function(cond) {
  [15:45:53.790]                   sendCondition <- ...future.sendCondition()
  [15:45:53.790]                   sendCondition(cond)
  [15:45:53.790]                   muffleCondition <- function (cond) 
  [15:45:53.790]                   {
  [15:45:53.790]                     inherits <- base::inherits
  [15:45:53.790]                     invokeRestart <- base::invokeRestart
  [15:45:53.790]                     muffled <- FALSE
  [15:45:53.790]                     if (inherits(cond, "message")) {
  [15:45:53.790]                       invokeRestart("muffleMessage")
  [15:45:53.790]                       muffled <- TRUE
  [15:45:53.790]                     }
  [15:45:53.790]                     else if (inherits(cond, "warning")) {
  [15:45:53.790]                       invokeRestart("muffleWarning")
  [15:45:53.790]                       muffled <- TRUE
  [15:45:53.790]                     }
  [15:45:53.790]                     else if (inherits(cond, "condition")) {
  [15:45:53.790]                       computeRestarts <- base::computeRestarts
  [15:45:53.790]                       grepl <- base::grepl
  [15:45:53.790]                       is.null <- base::is.null
  [15:45:53.790]                       restarts <- computeRestarts(cond)
  [15:45:53.790]                       for (restart in restarts) {
  [15:45:53.790]                         name <- restart$name
  [15:45:53.790]                         if (is.null(name)) 
  [15:45:53.790]                           next
  [15:45:53.790]                         if (!grepl("^muffle", name)) 
  [15:45:53.790]                           next
  [15:45:53.790]                         invokeRestart(restart)
  [15:45:53.790]                         muffled <- TRUE
  [15:45:53.790]                         break
  [15:45:53.790]                       }
  [15:45:53.790]                     }
  [15:45:53.790]                     invisible(muffled)
  [15:45:53.790]                   }
  [15:45:53.790]                   muffleCondition(cond)
  [15:45:53.790]                 })
  [15:45:53.790]             }))
  [15:45:53.790]             future::FutureResult(value = ...future.value$value, 
  [15:45:53.790]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:53.790]                   ...future.rng), started = ...future.startTime, 
  [15:45:53.790]                 version = "1.8")
  [15:45:53.790]         }, condition = base::local({
  [15:45:53.790]             c <- base::c
  [15:45:53.790]             inherits <- base::inherits
  [15:45:53.790]             invokeRestart <- base::invokeRestart
  [15:45:53.790]             length <- base::length
  [15:45:53.790]             list <- base::list
  [15:45:53.790]             seq.int <- base::seq.int
  [15:45:53.790]             signalCondition <- base::signalCondition
  [15:45:53.790]             sys.calls <- base::sys.calls
  [15:45:53.790]             Sys.time <- base::Sys.time
  [15:45:53.790]             `[[` <- base::`[[`
  [15:45:53.790]             `+` <- base::`+`
  [15:45:53.790]             `<<-` <- base::`<<-`
  [15:45:53.790]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:53.790]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:53.790]                   3L)]
  [15:45:53.790]             }
  [15:45:53.790]             function(cond) {
  [15:45:53.790]                 if (inherits(cond, "error")) {
  [15:45:53.790]                   sessionInformation <- function() {
  [15:45:53.790]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:53.790]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:53.790]                       search = base::search(), system = base::Sys.info())
  [15:45:53.790]                   }
  [15:45:53.790]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:53.790]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:53.790]                     cond$call), session = sessionInformation(), 
  [15:45:53.790]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:53.790]                   signalCondition(cond)
  [15:45:53.790]                 }
  [15:45:53.790]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:53.790]                 ))) {
  [15:45:53.790]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:53.790]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:53.790]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:53.790]                   if (!signal) {
  [15:45:53.790]                     muffleCondition <- function (cond) 
  [15:45:53.790]                     {
  [15:45:53.790]                       inherits <- base::inherits
  [15:45:53.790]                       invokeRestart <- base::invokeRestart
  [15:45:53.790]                       muffled <- FALSE
  [15:45:53.790]                       if (inherits(cond, "message")) {
  [15:45:53.790]                         invokeRestart("muffleMessage")
  [15:45:53.790]                         muffled <- TRUE
  [15:45:53.790]                       }
  [15:45:53.790]                       else if (inherits(cond, "warning")) {
  [15:45:53.790]                         invokeRestart("muffleWarning")
  [15:45:53.790]                         muffled <- TRUE
  [15:45:53.790]                       }
  [15:45:53.790]                       else if (inherits(cond, "condition")) {
  [15:45:53.790]                         computeRestarts <- base::computeRestarts
  [15:45:53.790]                         grepl <- base::grepl
  [15:45:53.790]                         is.null <- base::is.null
  [15:45:53.790]                         restarts <- computeRestarts(cond)
  [15:45:53.790]                         for (restart in restarts) {
  [15:45:53.790]                           name <- restart$name
  [15:45:53.790]                           if (is.null(name)) 
  [15:45:53.790]                             next
  [15:45:53.790]                           if (!grepl("^muffle", name)) 
  [15:45:53.790]                             next
  [15:45:53.790]                           invokeRestart(restart)
  [15:45:53.790]                           muffled <- TRUE
  [15:45:53.790]                           break
  [15:45:53.790]                         }
  [15:45:53.790]                       }
  [15:45:53.790]                       invisible(muffled)
  [15:45:53.790]                     }
  [15:45:53.790]                     muffleCondition(cond)
  [15:45:53.790]                   }
  [15:45:53.790]                 }
  [15:45:53.790]             }
  [15:45:53.790]         }))
  [15:45:53.790]     }, error = function(ex) {
  [15:45:53.790]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:53.790]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:53.790]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:53.790]     }, finally = {
  [15:45:53.790]         {
  [15:45:53.790]             NULL
  [15:45:53.790]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:53.790]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:53.790]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:53.790]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:53.790]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:53.790]                 ...) 
  [15:45:53.790]             {
  [15:45:53.790]                 if (substitute) 
  [15:45:53.790]                   expr <- substitute(expr)
  [15:45:53.790]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:53.790]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:53.790]                   globals = globals, persistent = persistent, 
  [15:45:53.790]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:53.790]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:53.790]                   label = label, ...)
  [15:45:53.790]                 if (!future$lazy) 
  [15:45:53.790]                   future <- run(future)
  [15:45:53.790]                 invisible(future)
  [15:45:53.790]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:53.790]         }
  [15:45:53.790]         base::options(...future.oldOptions)
  [15:45:53.790]     })
  [15:45:53.790]     Sys.time
  [15:45:53.790]     if (base::is.na(TRUE)) {
  [15:45:53.790]     }
  [15:45:53.790]     else {
  [15:45:53.790]         base::sink(type = "output", split = FALSE)
  [15:45:53.790]         if (TRUE) {
  [15:45:53.790]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:53.790]         }
  [15:45:53.790]         else {
  [15:45:53.790]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:53.790]         }
  [15:45:53.790]         base::close(...future.stdout)
  [15:45:53.790]         ...future.stdout <- NULL
  [15:45:53.790]     }
  [15:45:53.790]     ...future.result$conditions <- ...future.conditions
  [15:45:53.790]     ...future.result
  [15:45:53.790] }
  [15:45:53.797] ClusterFuture started
  [15:45:53.797] result() for ClusterFuture ...
  [15:45:53.799] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:53.799] - Validating connection of ClusterFuture
  [15:45:54.007] - received message: FutureResult
  [15:45:54.007] - Received FutureResult
  [15:45:54.015] - Erased future from FutureRegistry
  [15:45:54.015] result() for ClusterFuture ...
  [15:45:54.015] - result already collected: FutureResult
  [15:45:54.016] result() for ClusterFuture ... done
  [15:45:54.016] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:54.016] result() for ClusterFuture ... done
  [15:45:54.017] result() for ClusterFuture ...
  [15:45:54.017] - result already collected: FutureResult
  [15:45:54.017] result() for ClusterFuture ... done
  [15:45:54.018] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [15:45:54.019] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [15:45:54.020] getGlobalsAndPackages() ...
  [15:45:54.021] Searching for globals...
  [15:45:54.021] 
  [15:45:54.032] Searching for globals ... DONE
  [15:45:54.032] - globals: [0] <none>
  [15:45:54.033] getGlobalsAndPackages() ... DONE
  [15:45:54.038] Packages needed by the future expression (n = 0): <none>
  [15:45:54.039] Packages needed by future strategies (n = 0): <none>
  [15:45:54.055] {
  [15:45:54.055]     {
  [15:45:54.055]         ...future.startTime <- base::Sys.time()
  [15:45:54.055]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.055]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.055]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.055]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.055]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.055]         {
  [15:45:54.055]             {
  [15:45:54.055]                 base::local({
  [15:45:54.055]                   has_future <- base::requireNamespace("future", 
  [15:45:54.055]                     quietly = TRUE)
  [15:45:54.055]                   version <- if (has_future) 
  [15:45:54.055]                     utils::packageVersion("future")
  [15:45:54.055]                   else NULL
  [15:45:54.055]                   if (!has_future || version < "1.8.0") {
  [15:45:54.055]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.055]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.055]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.055]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.055]                         "release", "version")], collapse = " "), 
  [15:45:54.055]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.055]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.055]                       info)
  [15:45:54.055]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.055]                     if (!has_future) {
  [15:45:54.055]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.055]                         info)
  [15:45:54.055]                     }
  [15:45:54.055]                     else {
  [15:45:54.055]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.055]                         info, version)
  [15:45:54.055]                     }
  [15:45:54.055]                     base::stop(msg)
  [15:45:54.055]                   }
  [15:45:54.055]                 })
  [15:45:54.055]             }
  [15:45:54.055]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.055]         }
  [15:45:54.055]     }
  [15:45:54.055]     if (base::is.na(TRUE)) {
  [15:45:54.055]     }
  [15:45:54.055]     else {
  [15:45:54.055]         if (TRUE) {
  [15:45:54.055]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.055]                 open = "w")
  [15:45:54.055]         }
  [15:45:54.055]         else {
  [15:45:54.055]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.055]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.055]         }
  [15:45:54.055]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.055]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.055]             base::sink(type = "output", split = FALSE)
  [15:45:54.055]             base::close(...future.stdout)
  [15:45:54.055]         }, add = TRUE)
  [15:45:54.055]     }
  [15:45:54.055]     ...future.frame <- base::sys.nframe()
  [15:45:54.055]     ...future.conditions <- base::list()
  [15:45:54.055]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.055]     ...future.result <- base::tryCatch({
  [15:45:54.055]         base::withCallingHandlers({
  [15:45:54.055]             ...future.value <- base::withVisible(base::local({
  [15:45:54.055]                 ...future.sendCondition <- local({
  [15:45:54.055]                   sendCondition <- NULL
  [15:45:54.055]                   function(frame = 1L) {
  [15:45:54.055]                     if (is.function(sendCondition)) 
  [15:45:54.055]                       return(sendCondition)
  [15:45:54.055]                     ns <- getNamespace("parallel")
  [15:45:54.055]                     if (exists("sendData", mode = "function", 
  [15:45:54.055]                       envir = ns)) {
  [15:45:54.055]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.055]                         envir = ns)
  [15:45:54.055]                       envir <- sys.frame(frame)
  [15:45:54.055]                       master <- NULL
  [15:45:54.055]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.055]                         !identical(envir, emptyenv())) {
  [15:45:54.055]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.055]                           inherits = FALSE)) {
  [15:45:54.055]                           master <- get("master", mode = "list", 
  [15:45:54.055]                             envir = envir, inherits = FALSE)
  [15:45:54.055]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.055]                             sendCondition <<- function(cond) {
  [15:45:54.055]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.055]                                 success = TRUE)
  [15:45:54.055]                               parallel_sendData(master, data)
  [15:45:54.055]                             }
  [15:45:54.055]                             return(sendCondition)
  [15:45:54.055]                           }
  [15:45:54.055]                         }
  [15:45:54.055]                         frame <- frame + 1L
  [15:45:54.055]                         envir <- sys.frame(frame)
  [15:45:54.055]                       }
  [15:45:54.055]                     }
  [15:45:54.055]                     sendCondition <<- function(cond) NULL
  [15:45:54.055]                   }
  [15:45:54.055]                 })
  [15:45:54.055]                 withCallingHandlers({
  [15:45:54.055]                   2
  [15:45:54.055]                 }, immediateCondition = function(cond) {
  [15:45:54.055]                   sendCondition <- ...future.sendCondition()
  [15:45:54.055]                   sendCondition(cond)
  [15:45:54.055]                   muffleCondition <- function (cond) 
  [15:45:54.055]                   {
  [15:45:54.055]                     inherits <- base::inherits
  [15:45:54.055]                     invokeRestart <- base::invokeRestart
  [15:45:54.055]                     muffled <- FALSE
  [15:45:54.055]                     if (inherits(cond, "message")) {
  [15:45:54.055]                       invokeRestart("muffleMessage")
  [15:45:54.055]                       muffled <- TRUE
  [15:45:54.055]                     }
  [15:45:54.055]                     else if (inherits(cond, "warning")) {
  [15:45:54.055]                       invokeRestart("muffleWarning")
  [15:45:54.055]                       muffled <- TRUE
  [15:45:54.055]                     }
  [15:45:54.055]                     else if (inherits(cond, "condition")) {
  [15:45:54.055]                       computeRestarts <- base::computeRestarts
  [15:45:54.055]                       grepl <- base::grepl
  [15:45:54.055]                       is.null <- base::is.null
  [15:45:54.055]                       restarts <- computeRestarts(cond)
  [15:45:54.055]                       for (restart in restarts) {
  [15:45:54.055]                         name <- restart$name
  [15:45:54.055]                         if (is.null(name)) 
  [15:45:54.055]                           next
  [15:45:54.055]                         if (!grepl("^muffle", name)) 
  [15:45:54.055]                           next
  [15:45:54.055]                         invokeRestart(restart)
  [15:45:54.055]                         muffled <- TRUE
  [15:45:54.055]                         break
  [15:45:54.055]                       }
  [15:45:54.055]                     }
  [15:45:54.055]                     invisible(muffled)
  [15:45:54.055]                   }
  [15:45:54.055]                   muffleCondition(cond)
  [15:45:54.055]                 })
  [15:45:54.055]             }))
  [15:45:54.055]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.055]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.055]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.055]                 version = "1.8")
  [15:45:54.055]         }, condition = base::local({
  [15:45:54.055]             c <- base::c
  [15:45:54.055]             inherits <- base::inherits
  [15:45:54.055]             invokeRestart <- base::invokeRestart
  [15:45:54.055]             length <- base::length
  [15:45:54.055]             list <- base::list
  [15:45:54.055]             seq.int <- base::seq.int
  [15:45:54.055]             signalCondition <- base::signalCondition
  [15:45:54.055]             sys.calls <- base::sys.calls
  [15:45:54.055]             Sys.time <- base::Sys.time
  [15:45:54.055]             `[[` <- base::`[[`
  [15:45:54.055]             `+` <- base::`+`
  [15:45:54.055]             `<<-` <- base::`<<-`
  [15:45:54.055]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.055]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.055]                   3L)]
  [15:45:54.055]             }
  [15:45:54.055]             function(cond) {
  [15:45:54.055]                 if (inherits(cond, "error")) {
  [15:45:54.055]                   sessionInformation <- function() {
  [15:45:54.055]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.055]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.055]                       search = base::search(), system = base::Sys.info())
  [15:45:54.055]                   }
  [15:45:54.055]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.055]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.055]                     cond$call), session = sessionInformation(), 
  [15:45:54.055]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.055]                   signalCondition(cond)
  [15:45:54.055]                 }
  [15:45:54.055]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.055]                 ))) {
  [15:45:54.055]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.055]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.055]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.055]                   if (!signal) {
  [15:45:54.055]                     muffleCondition <- function (cond) 
  [15:45:54.055]                     {
  [15:45:54.055]                       inherits <- base::inherits
  [15:45:54.055]                       invokeRestart <- base::invokeRestart
  [15:45:54.055]                       muffled <- FALSE
  [15:45:54.055]                       if (inherits(cond, "message")) {
  [15:45:54.055]                         invokeRestart("muffleMessage")
  [15:45:54.055]                         muffled <- TRUE
  [15:45:54.055]                       }
  [15:45:54.055]                       else if (inherits(cond, "warning")) {
  [15:45:54.055]                         invokeRestart("muffleWarning")
  [15:45:54.055]                         muffled <- TRUE
  [15:45:54.055]                       }
  [15:45:54.055]                       else if (inherits(cond, "condition")) {
  [15:45:54.055]                         computeRestarts <- base::computeRestarts
  [15:45:54.055]                         grepl <- base::grepl
  [15:45:54.055]                         is.null <- base::is.null
  [15:45:54.055]                         restarts <- computeRestarts(cond)
  [15:45:54.055]                         for (restart in restarts) {
  [15:45:54.055]                           name <- restart$name
  [15:45:54.055]                           if (is.null(name)) 
  [15:45:54.055]                             next
  [15:45:54.055]                           if (!grepl("^muffle", name)) 
  [15:45:54.055]                             next
  [15:45:54.055]                           invokeRestart(restart)
  [15:45:54.055]                           muffled <- TRUE
  [15:45:54.055]                           break
  [15:45:54.055]                         }
  [15:45:54.055]                       }
  [15:45:54.055]                       invisible(muffled)
  [15:45:54.055]                     }
  [15:45:54.055]                     muffleCondition(cond)
  [15:45:54.055]                   }
  [15:45:54.055]                 }
  [15:45:54.055]             }
  [15:45:54.055]         }))
  [15:45:54.055]     }, error = function(ex) {
  [15:45:54.055]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.055]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.055]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.055]     }, finally = {
  [15:45:54.055]         {
  [15:45:54.055]             NULL
  [15:45:54.055]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.055]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.055]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.055]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.055]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.055]                 ...) 
  [15:45:54.055]             {
  [15:45:54.055]                 if (substitute) 
  [15:45:54.055]                   expr <- substitute(expr)
  [15:45:54.055]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.055]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.055]                   globals = globals, persistent = persistent, 
  [15:45:54.055]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.055]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.055]                   label = label, ...)
  [15:45:54.055]                 if (!future$lazy) 
  [15:45:54.055]                   future <- run(future)
  [15:45:54.055]                 invisible(future)
  [15:45:54.055]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.055]         }
  [15:45:54.055]         base::options(...future.oldOptions)
  [15:45:54.055]     })
  [15:45:54.055]     Sys.time
  [15:45:54.055]     if (base::is.na(TRUE)) {
  [15:45:54.055]     }
  [15:45:54.055]     else {
  [15:45:54.055]         base::sink(type = "output", split = FALSE)
  [15:45:54.055]         if (TRUE) {
  [15:45:54.055]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.055]         }
  [15:45:54.055]         else {
  [15:45:54.055]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.055]         }
  [15:45:54.055]         base::close(...future.stdout)
  [15:45:54.055]         ...future.stdout <- NULL
  [15:45:54.055]     }
  [15:45:54.055]     ...future.result$conditions <- ...future.conditions
  [15:45:54.055]     ...future.result
  [15:45:54.055] }
  [15:45:54.078] ClusterFuture started
  [15:45:54.078] getGlobalsAndPackages() ...
  [15:45:54.079] Searching for globals...
  [15:45:54.080] 
  [15:45:54.080] Searching for globals ... DONE
  [15:45:54.080] - globals: [0] <none>
  [15:45:54.081] getGlobalsAndPackages() ... DONE
  [15:45:54.097] Packages needed by the future expression (n = 0): <none>
  [15:45:54.097] Packages needed by future strategies (n = 0): <none>
  [15:45:54.114] {
  [15:45:54.114]     {
  [15:45:54.114]         ...future.startTime <- base::Sys.time()
  [15:45:54.114]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.114]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.114]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.114]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.114]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.114]         {
  [15:45:54.114]             {
  [15:45:54.114]                 base::local({
  [15:45:54.114]                   has_future <- base::requireNamespace("future", 
  [15:45:54.114]                     quietly = TRUE)
  [15:45:54.114]                   version <- if (has_future) 
  [15:45:54.114]                     utils::packageVersion("future")
  [15:45:54.114]                   else NULL
  [15:45:54.114]                   if (!has_future || version < "1.8.0") {
  [15:45:54.114]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.114]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.114]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.114]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.114]                         "release", "version")], collapse = " "), 
  [15:45:54.114]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.114]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.114]                       info)
  [15:45:54.114]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.114]                     if (!has_future) {
  [15:45:54.114]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.114]                         info)
  [15:45:54.114]                     }
  [15:45:54.114]                     else {
  [15:45:54.114]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.114]                         info, version)
  [15:45:54.114]                     }
  [15:45:54.114]                     base::stop(msg)
  [15:45:54.114]                   }
  [15:45:54.114]                 })
  [15:45:54.114]             }
  [15:45:54.114]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.114]         }
  [15:45:54.114]     }
  [15:45:54.114]     if (base::is.na(TRUE)) {
  [15:45:54.114]     }
  [15:45:54.114]     else {
  [15:45:54.114]         if (TRUE) {
  [15:45:54.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.114]                 open = "w")
  [15:45:54.114]         }
  [15:45:54.114]         else {
  [15:45:54.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.114]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.114]         }
  [15:45:54.114]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.114]             base::sink(type = "output", split = FALSE)
  [15:45:54.114]             base::close(...future.stdout)
  [15:45:54.114]         }, add = TRUE)
  [15:45:54.114]     }
  [15:45:54.114]     ...future.frame <- base::sys.nframe()
  [15:45:54.114]     ...future.conditions <- base::list()
  [15:45:54.114]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.114]     ...future.result <- base::tryCatch({
  [15:45:54.114]         base::withCallingHandlers({
  [15:45:54.114]             ...future.value <- base::withVisible(base::local({
  [15:45:54.114]                 ...future.sendCondition <- local({
  [15:45:54.114]                   sendCondition <- NULL
  [15:45:54.114]                   function(frame = 1L) {
  [15:45:54.114]                     if (is.function(sendCondition)) 
  [15:45:54.114]                       return(sendCondition)
  [15:45:54.114]                     ns <- getNamespace("parallel")
  [15:45:54.114]                     if (exists("sendData", mode = "function", 
  [15:45:54.114]                       envir = ns)) {
  [15:45:54.114]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.114]                         envir = ns)
  [15:45:54.114]                       envir <- sys.frame(frame)
  [15:45:54.114]                       master <- NULL
  [15:45:54.114]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.114]                         !identical(envir, emptyenv())) {
  [15:45:54.114]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.114]                           inherits = FALSE)) {
  [15:45:54.114]                           master <- get("master", mode = "list", 
  [15:45:54.114]                             envir = envir, inherits = FALSE)
  [15:45:54.114]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.114]                             sendCondition <<- function(cond) {
  [15:45:54.114]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.114]                                 success = TRUE)
  [15:45:54.114]                               parallel_sendData(master, data)
  [15:45:54.114]                             }
  [15:45:54.114]                             return(sendCondition)
  [15:45:54.114]                           }
  [15:45:54.114]                         }
  [15:45:54.114]                         frame <- frame + 1L
  [15:45:54.114]                         envir <- sys.frame(frame)
  [15:45:54.114]                       }
  [15:45:54.114]                     }
  [15:45:54.114]                     sendCondition <<- function(cond) NULL
  [15:45:54.114]                   }
  [15:45:54.114]                 })
  [15:45:54.114]                 withCallingHandlers({
  [15:45:54.114]                   NULL
  [15:45:54.114]                 }, immediateCondition = function(cond) {
  [15:45:54.114]                   sendCondition <- ...future.sendCondition()
  [15:45:54.114]                   sendCondition(cond)
  [15:45:54.114]                   muffleCondition <- function (cond) 
  [15:45:54.114]                   {
  [15:45:54.114]                     inherits <- base::inherits
  [15:45:54.114]                     invokeRestart <- base::invokeRestart
  [15:45:54.114]                     muffled <- FALSE
  [15:45:54.114]                     if (inherits(cond, "message")) {
  [15:45:54.114]                       invokeRestart("muffleMessage")
  [15:45:54.114]                       muffled <- TRUE
  [15:45:54.114]                     }
  [15:45:54.114]                     else if (inherits(cond, "warning")) {
  [15:45:54.114]                       invokeRestart("muffleWarning")
  [15:45:54.114]                       muffled <- TRUE
  [15:45:54.114]                     }
  [15:45:54.114]                     else if (inherits(cond, "condition")) {
  [15:45:54.114]                       computeRestarts <- base::computeRestarts
  [15:45:54.114]                       grepl <- base::grepl
  [15:45:54.114]                       is.null <- base::is.null
  [15:45:54.114]                       restarts <- computeRestarts(cond)
  [15:45:54.114]                       for (restart in restarts) {
  [15:45:54.114]                         name <- restart$name
  [15:45:54.114]                         if (is.null(name)) 
  [15:45:54.114]                           next
  [15:45:54.114]                         if (!grepl("^muffle", name)) 
  [15:45:54.114]                           next
  [15:45:54.114]                         invokeRestart(restart)
  [15:45:54.114]                         muffled <- TRUE
  [15:45:54.114]                         break
  [15:45:54.114]                       }
  [15:45:54.114]                     }
  [15:45:54.114]                     invisible(muffled)
  [15:45:54.114]                   }
  [15:45:54.114]                   muffleCondition(cond)
  [15:45:54.114]                 })
  [15:45:54.114]             }))
  [15:45:54.114]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.114]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.114]                 version = "1.8")
  [15:45:54.114]         }, condition = base::local({
  [15:45:54.114]             c <- base::c
  [15:45:54.114]             inherits <- base::inherits
  [15:45:54.114]             invokeRestart <- base::invokeRestart
  [15:45:54.114]             length <- base::length
  [15:45:54.114]             list <- base::list
  [15:45:54.114]             seq.int <- base::seq.int
  [15:45:54.114]             signalCondition <- base::signalCondition
  [15:45:54.114]             sys.calls <- base::sys.calls
  [15:45:54.114]             Sys.time <- base::Sys.time
  [15:45:54.114]             `[[` <- base::`[[`
  [15:45:54.114]             `+` <- base::`+`
  [15:45:54.114]             `<<-` <- base::`<<-`
  [15:45:54.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.114]                   3L)]
  [15:45:54.114]             }
  [15:45:54.114]             function(cond) {
  [15:45:54.114]                 if (inherits(cond, "error")) {
  [15:45:54.114]                   sessionInformation <- function() {
  [15:45:54.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.114]                       search = base::search(), system = base::Sys.info())
  [15:45:54.114]                   }
  [15:45:54.114]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.114]                     cond$call), session = sessionInformation(), 
  [15:45:54.114]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.114]                   signalCondition(cond)
  [15:45:54.114]                 }
  [15:45:54.114]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.114]                 ))) {
  [15:45:54.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.114]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.114]                   if (!signal) {
  [15:45:54.114]                     muffleCondition <- function (cond) 
  [15:45:54.114]                     {
  [15:45:54.114]                       inherits <- base::inherits
  [15:45:54.114]                       invokeRestart <- base::invokeRestart
  [15:45:54.114]                       muffled <- FALSE
  [15:45:54.114]                       if (inherits(cond, "message")) {
  [15:45:54.114]                         invokeRestart("muffleMessage")
  [15:45:54.114]                         muffled <- TRUE
  [15:45:54.114]                       }
  [15:45:54.114]                       else if (inherits(cond, "warning")) {
  [15:45:54.114]                         invokeRestart("muffleWarning")
  [15:45:54.114]                         muffled <- TRUE
  [15:45:54.114]                       }
  [15:45:54.114]                       else if (inherits(cond, "condition")) {
  [15:45:54.114]                         computeRestarts <- base::computeRestarts
  [15:45:54.114]                         grepl <- base::grepl
  [15:45:54.114]                         is.null <- base::is.null
  [15:45:54.114]                         restarts <- computeRestarts(cond)
  [15:45:54.114]                         for (restart in restarts) {
  [15:45:54.114]                           name <- restart$name
  [15:45:54.114]                           if (is.null(name)) 
  [15:45:54.114]                             next
  [15:45:54.114]                           if (!grepl("^muffle", name)) 
  [15:45:54.114]                             next
  [15:45:54.114]                           invokeRestart(restart)
  [15:45:54.114]                           muffled <- TRUE
  [15:45:54.114]                           break
  [15:45:54.114]                         }
  [15:45:54.114]                       }
  [15:45:54.114]                       invisible(muffled)
  [15:45:54.114]                     }
  [15:45:54.114]                     muffleCondition(cond)
  [15:45:54.114]                   }
  [15:45:54.114]                 }
  [15:45:54.114]             }
  [15:45:54.114]         }))
  [15:45:54.114]     }, error = function(ex) {
  [15:45:54.114]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.114]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.114]     }, finally = {
  [15:45:54.114]         {
  [15:45:54.114]             NULL
  [15:45:54.114]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.114]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.114]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.114]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.114]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.114]                 ...) 
  [15:45:54.114]             {
  [15:45:54.114]                 if (substitute) 
  [15:45:54.114]                   expr <- substitute(expr)
  [15:45:54.114]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.114]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.114]                   globals = globals, persistent = persistent, 
  [15:45:54.114]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.114]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.114]                   label = label, ...)
  [15:45:54.114]                 if (!future$lazy) 
  [15:45:54.114]                   future <- run(future)
  [15:45:54.114]                 invisible(future)
  [15:45:54.114]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.114]         }
  [15:45:54.114]         base::options(...future.oldOptions)
  [15:45:54.114]     })
  [15:45:54.114]     Sys.time
  [15:45:54.114]     if (base::is.na(TRUE)) {
  [15:45:54.114]     }
  [15:45:54.114]     else {
  [15:45:54.114]         base::sink(type = "output", split = FALSE)
  [15:45:54.114]         if (TRUE) {
  [15:45:54.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.114]         }
  [15:45:54.114]         else {
  [15:45:54.114]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.114]         }
  [15:45:54.114]         base::close(...future.stdout)
  [15:45:54.114]         ...future.stdout <- NULL
  [15:45:54.114]     }
  [15:45:54.114]     ...future.result$conditions <- ...future.conditions
  [15:45:54.114]     ...future.result
  [15:45:54.114] }
  [15:45:54.125] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:54.138] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.139] - Validating connection of ClusterFuture
  [15:45:54.139] - received message: FutureResult
  [15:45:54.140] - Received FutureResult
  [15:45:54.140] - Erased future from FutureRegistry
  [15:45:54.140] result() for ClusterFuture ...
  [15:45:54.141] - result already collected: FutureResult
  [15:45:54.141] result() for ClusterFuture ... done
  [15:45:54.142] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:54.142] result() for ClusterFuture ...
  [15:45:54.143] - result already collected: FutureResult
  [15:45:54.143] result() for ClusterFuture ... done
  [15:45:54.143] result() for ClusterFuture ...
  [15:45:54.144] - result already collected: FutureResult
  [15:45:54.144] result() for ClusterFuture ... done
  [15:45:54.155] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2abe09b8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca29788a98> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2abe09b8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca29788a98> 
   $  : NULL
   $  : NULL
   $  : num 6
  [15:45:54.204] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.204] - Validating connection of ClusterFuture
  [15:45:54.205] - received message: FutureResult
  [15:45:54.205] - Received FutureResult
  [15:45:54.205] - Erased future from FutureRegistry
  [15:45:54.206] result() for ClusterFuture ...
  [15:45:54.206] - result already collected: FutureResult
  [15:45:54.206] result() for ClusterFuture ... done
  [15:45:54.207] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "" ...
  [15:45:54.209] resolve() on list ...
  [15:45:54.210]  recursive: 0
  [15:45:54.210]  length: 6
  [15:45:54.210]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:54.211] signalConditionsASAP(numeric, pos=1) ...
  [15:45:54.211] - nx: 6
  [15:45:54.211] - relay: TRUE
  [15:45:54.212] - stdout: TRUE
  [15:45:54.212] - signal: TRUE
  [15:45:54.212] - resignal: FALSE
  [15:45:54.213] - force: TRUE
  [15:45:54.213] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.213] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.214]  - until=2
  [15:45:54.214]  - relaying element #2
  [15:45:54.214] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.215] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.215] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:54.216]  length: 5 (resolved future 1)
  [15:45:54.216] Future #2
  [15:45:54.216] result() for ClusterFuture ...
  [15:45:54.217] - result already collected: FutureResult
  [15:45:54.217] result() for ClusterFuture ... done
  [15:45:54.217] result() for ClusterFuture ...
  [15:45:54.218] - result already collected: FutureResult
  [15:45:54.218] result() for ClusterFuture ... done
  [15:45:54.218] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:54.219] - nx: 6
  [15:45:54.219] - relay: TRUE
  [15:45:54.219] - stdout: TRUE
  [15:45:54.220] - signal: TRUE
  [15:45:54.220] - resignal: FALSE
  [15:45:54.220] - force: TRUE
  [15:45:54.231] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.231] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.232]  - until=2
  [15:45:54.232]  - relaying element #2
  [15:45:54.232] result() for ClusterFuture ...
  [15:45:54.233] - result already collected: FutureResult
  [15:45:54.233] result() for ClusterFuture ... done
  [15:45:54.234] result() for ClusterFuture ...
  [15:45:54.234] - result already collected: FutureResult
  [15:45:54.234] result() for ClusterFuture ... done
  [15:45:54.235] result() for ClusterFuture ...
  [15:45:54.235] - result already collected: FutureResult
  [15:45:54.235] result() for ClusterFuture ... done
  [15:45:54.236] result() for ClusterFuture ...
  [15:45:54.236] - result already collected: FutureResult
  [15:45:54.237] result() for ClusterFuture ... done
  [15:45:54.237] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.237] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.238] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:54.238]  length: 4 (resolved future 2)
  [15:45:54.238] Future #3
  [15:45:54.239] result() for ClusterFuture ...
  [15:45:54.239] - result already collected: FutureResult
  [15:45:54.239] result() for ClusterFuture ... done
  [15:45:54.240] result() for ClusterFuture ...
  [15:45:54.240] - result already collected: FutureResult
  [15:45:54.240] result() for ClusterFuture ... done
  [15:45:54.251] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:54.252] - nx: 6
  [15:45:54.252] - relay: TRUE
  [15:45:54.252] - stdout: TRUE
  [15:45:54.253] - signal: TRUE
  [15:45:54.253] - resignal: FALSE
  [15:45:54.253] - force: TRUE
  [15:45:54.254] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.254] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.254]  - until=3
  [15:45:54.255]  - relaying element #3
  [15:45:54.255] result() for ClusterFuture ...
  [15:45:54.255] - result already collected: FutureResult
  [15:45:54.256] result() for ClusterFuture ... done
  [15:45:54.256] result() for ClusterFuture ...
  [15:45:54.256] - result already collected: FutureResult
  [15:45:54.257] result() for ClusterFuture ... done
  [15:45:54.257] result() for ClusterFuture ...
  [15:45:54.258] - result already collected: FutureResult
  [15:45:54.258] result() for ClusterFuture ... done
  [15:45:54.258] result() for ClusterFuture ...
  [15:45:54.259] - result already collected: FutureResult
  [15:45:54.259] result() for ClusterFuture ... done
  [15:45:54.259] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.260] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.260] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:54.260]  length: 3 (resolved future 3)
  [15:45:54.274] signalConditionsASAP(NULL, pos=4) ...
  [15:45:54.274] - nx: 6
  [15:45:54.275] - relay: TRUE
  [15:45:54.275] - stdout: TRUE
  [15:45:54.275] - signal: TRUE
  [15:45:54.275] - resignal: FALSE
  [15:45:54.276] - force: TRUE
  [15:45:54.276] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.276] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.277]  - until=5
  [15:45:54.277]  - relaying element #5
  [15:45:54.277] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.278] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.278] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:54.279]  length: 2 (resolved future 4)
  [15:45:54.279] signalConditionsASAP(NULL, pos=5) ...
  [15:45:54.279] - nx: 6
  [15:45:54.279] - relay: TRUE
  [15:45:54.280] - stdout: TRUE
  [15:45:54.280] - signal: TRUE
  [15:45:54.280] - resignal: FALSE
  [15:45:54.281] - force: TRUE
  [15:45:54.281] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.281] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.282]  - until=6
  [15:45:54.282]  - relaying element #6
  [15:45:54.282] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.283] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.283] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:54.284]  length: 1 (resolved future 5)
  [15:45:54.284] signalConditionsASAP(numeric, pos=6) ...
  [15:45:54.284] - nx: 6
  [15:45:54.285] - relay: TRUE
  [15:45:54.285] - stdout: TRUE
  [15:45:54.285] - signal: TRUE
  [15:45:54.286] - resignal: FALSE
  [15:45:54.286] - force: TRUE
  [15:45:54.286] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.303] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.303]  - until=6
  [15:45:54.303] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.304] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.304] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:54.305]  length: 0 (resolved future 6)
  [15:45:54.305] Relaying remaining futures
  [15:45:54.305] signalConditionsASAP(NULL, pos=0) ...
  [15:45:54.306] - nx: 6
  [15:45:54.306] - relay: TRUE
  [15:45:54.306] - stdout: TRUE
  [15:45:54.307] - signal: TRUE
  [15:45:54.307] - resignal: FALSE
  [15:45:54.307] - force: TRUE
  [15:45:54.308] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.308] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:54.309] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.309] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.309] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:54.310] resolve() on list ... DONE
  [15:45:54.310] result() for ClusterFuture ...
  [15:45:54.310] - result already collected: FutureResult
  [15:45:54.311] result() for ClusterFuture ... done
  [15:45:54.311] result() for ClusterFuture ...
  [15:45:54.311] - result already collected: FutureResult
  [15:45:54.312] result() for ClusterFuture ... done
  [15:45:54.312] result() for ClusterFuture ...
  [15:45:54.312] - result already collected: FutureResult
  [15:45:54.313] result() for ClusterFuture ... done
  [15:45:54.313] result() for ClusterFuture ...
  [15:45:54.313] - result already collected: FutureResult
  [15:45:54.314] result() for ClusterFuture ... done
  List of 6
   $ a: num 1
   $ b: num 2
   $ c: NULL
   $  : NULL
   $  : NULL
   $  : num 6
  Dimensions: c(1, 6)
  [15:45:54.338] getGlobalsAndPackages() ...
  [15:45:54.338] Searching for globals...
  [15:45:54.339] 
  [15:45:54.339] Searching for globals ... DONE
  [15:45:54.340] - globals: [0] <none>
  [15:45:54.340] getGlobalsAndPackages() ... DONE
  [15:45:54.346] Packages needed by the future expression (n = 0): <none>
  [15:45:54.346] Packages needed by future strategies (n = 0): <none>
  [15:45:54.368] {
  [15:45:54.368]     {
  [15:45:54.368]         ...future.startTime <- base::Sys.time()
  [15:45:54.368]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.368]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.368]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.368]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.368]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.368]         {
  [15:45:54.368]             {
  [15:45:54.368]                 base::local({
  [15:45:54.368]                   has_future <- base::requireNamespace("future", 
  [15:45:54.368]                     quietly = TRUE)
  [15:45:54.368]                   version <- if (has_future) 
  [15:45:54.368]                     utils::packageVersion("future")
  [15:45:54.368]                   else NULL
  [15:45:54.368]                   if (!has_future || version < "1.8.0") {
  [15:45:54.368]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.368]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.368]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.368]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.368]                         "release", "version")], collapse = " "), 
  [15:45:54.368]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.368]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.368]                       info)
  [15:45:54.368]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.368]                     if (!has_future) {
  [15:45:54.368]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.368]                         info)
  [15:45:54.368]                     }
  [15:45:54.368]                     else {
  [15:45:54.368]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.368]                         info, version)
  [15:45:54.368]                     }
  [15:45:54.368]                     base::stop(msg)
  [15:45:54.368]                   }
  [15:45:54.368]                 })
  [15:45:54.368]             }
  [15:45:54.368]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.368]         }
  [15:45:54.368]     }
  [15:45:54.368]     if (base::is.na(TRUE)) {
  [15:45:54.368]     }
  [15:45:54.368]     else {
  [15:45:54.368]         if (TRUE) {
  [15:45:54.368]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.368]                 open = "w")
  [15:45:54.368]         }
  [15:45:54.368]         else {
  [15:45:54.368]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.368]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.368]         }
  [15:45:54.368]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.368]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.368]             base::sink(type = "output", split = FALSE)
  [15:45:54.368]             base::close(...future.stdout)
  [15:45:54.368]         }, add = TRUE)
  [15:45:54.368]     }
  [15:45:54.368]     ...future.frame <- base::sys.nframe()
  [15:45:54.368]     ...future.conditions <- base::list()
  [15:45:54.368]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.368]     ...future.result <- base::tryCatch({
  [15:45:54.368]         base::withCallingHandlers({
  [15:45:54.368]             ...future.value <- base::withVisible(base::local({
  [15:45:54.368]                 ...future.sendCondition <- local({
  [15:45:54.368]                   sendCondition <- NULL
  [15:45:54.368]                   function(frame = 1L) {
  [15:45:54.368]                     if (is.function(sendCondition)) 
  [15:45:54.368]                       return(sendCondition)
  [15:45:54.368]                     ns <- getNamespace("parallel")
  [15:45:54.368]                     if (exists("sendData", mode = "function", 
  [15:45:54.368]                       envir = ns)) {
  [15:45:54.368]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.368]                         envir = ns)
  [15:45:54.368]                       envir <- sys.frame(frame)
  [15:45:54.368]                       master <- NULL
  [15:45:54.368]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.368]                         !identical(envir, emptyenv())) {
  [15:45:54.368]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.368]                           inherits = FALSE)) {
  [15:45:54.368]                           master <- get("master", mode = "list", 
  [15:45:54.368]                             envir = envir, inherits = FALSE)
  [15:45:54.368]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.368]                             sendCondition <<- function(cond) {
  [15:45:54.368]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.368]                                 success = TRUE)
  [15:45:54.368]                               parallel_sendData(master, data)
  [15:45:54.368]                             }
  [15:45:54.368]                             return(sendCondition)
  [15:45:54.368]                           }
  [15:45:54.368]                         }
  [15:45:54.368]                         frame <- frame + 1L
  [15:45:54.368]                         envir <- sys.frame(frame)
  [15:45:54.368]                       }
  [15:45:54.368]                     }
  [15:45:54.368]                     sendCondition <<- function(cond) NULL
  [15:45:54.368]                   }
  [15:45:54.368]                 })
  [15:45:54.368]                 withCallingHandlers({
  [15:45:54.368]                   2
  [15:45:54.368]                 }, immediateCondition = function(cond) {
  [15:45:54.368]                   sendCondition <- ...future.sendCondition()
  [15:45:54.368]                   sendCondition(cond)
  [15:45:54.368]                   muffleCondition <- function (cond) 
  [15:45:54.368]                   {
  [15:45:54.368]                     inherits <- base::inherits
  [15:45:54.368]                     invokeRestart <- base::invokeRestart
  [15:45:54.368]                     muffled <- FALSE
  [15:45:54.368]                     if (inherits(cond, "message")) {
  [15:45:54.368]                       invokeRestart("muffleMessage")
  [15:45:54.368]                       muffled <- TRUE
  [15:45:54.368]                     }
  [15:45:54.368]                     else if (inherits(cond, "warning")) {
  [15:45:54.368]                       invokeRestart("muffleWarning")
  [15:45:54.368]                       muffled <- TRUE
  [15:45:54.368]                     }
  [15:45:54.368]                     else if (inherits(cond, "condition")) {
  [15:45:54.368]                       computeRestarts <- base::computeRestarts
  [15:45:54.368]                       grepl <- base::grepl
  [15:45:54.368]                       is.null <- base::is.null
  [15:45:54.368]                       restarts <- computeRestarts(cond)
  [15:45:54.368]                       for (restart in restarts) {
  [15:45:54.368]                         name <- restart$name
  [15:45:54.368]                         if (is.null(name)) 
  [15:45:54.368]                           next
  [15:45:54.368]                         if (!grepl("^muffle", name)) 
  [15:45:54.368]                           next
  [15:45:54.368]                         invokeRestart(restart)
  [15:45:54.368]                         muffled <- TRUE
  [15:45:54.368]                         break
  [15:45:54.368]                       }
  [15:45:54.368]                     }
  [15:45:54.368]                     invisible(muffled)
  [15:45:54.368]                   }
  [15:45:54.368]                   muffleCondition(cond)
  [15:45:54.368]                 })
  [15:45:54.368]             }))
  [15:45:54.368]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.368]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.368]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.368]                 version = "1.8")
  [15:45:54.368]         }, condition = base::local({
  [15:45:54.368]             c <- base::c
  [15:45:54.368]             inherits <- base::inherits
  [15:45:54.368]             invokeRestart <- base::invokeRestart
  [15:45:54.368]             length <- base::length
  [15:45:54.368]             list <- base::list
  [15:45:54.368]             seq.int <- base::seq.int
  [15:45:54.368]             signalCondition <- base::signalCondition
  [15:45:54.368]             sys.calls <- base::sys.calls
  [15:45:54.368]             Sys.time <- base::Sys.time
  [15:45:54.368]             `[[` <- base::`[[`
  [15:45:54.368]             `+` <- base::`+`
  [15:45:54.368]             `<<-` <- base::`<<-`
  [15:45:54.368]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.368]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.368]                   3L)]
  [15:45:54.368]             }
  [15:45:54.368]             function(cond) {
  [15:45:54.368]                 if (inherits(cond, "error")) {
  [15:45:54.368]                   sessionInformation <- function() {
  [15:45:54.368]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.368]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.368]                       search = base::search(), system = base::Sys.info())
  [15:45:54.368]                   }
  [15:45:54.368]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.368]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.368]                     cond$call), session = sessionInformation(), 
  [15:45:54.368]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.368]                   signalCondition(cond)
  [15:45:54.368]                 }
  [15:45:54.368]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.368]                 ))) {
  [15:45:54.368]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.368]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.368]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.368]                   if (!signal) {
  [15:45:54.368]                     muffleCondition <- function (cond) 
  [15:45:54.368]                     {
  [15:45:54.368]                       inherits <- base::inherits
  [15:45:54.368]                       invokeRestart <- base::invokeRestart
  [15:45:54.368]                       muffled <- FALSE
  [15:45:54.368]                       if (inherits(cond, "message")) {
  [15:45:54.368]                         invokeRestart("muffleMessage")
  [15:45:54.368]                         muffled <- TRUE
  [15:45:54.368]                       }
  [15:45:54.368]                       else if (inherits(cond, "warning")) {
  [15:45:54.368]                         invokeRestart("muffleWarning")
  [15:45:54.368]                         muffled <- TRUE
  [15:45:54.368]                       }
  [15:45:54.368]                       else if (inherits(cond, "condition")) {
  [15:45:54.368]                         computeRestarts <- base::computeRestarts
  [15:45:54.368]                         grepl <- base::grepl
  [15:45:54.368]                         is.null <- base::is.null
  [15:45:54.368]                         restarts <- computeRestarts(cond)
  [15:45:54.368]                         for (restart in restarts) {
  [15:45:54.368]                           name <- restart$name
  [15:45:54.368]                           if (is.null(name)) 
  [15:45:54.368]                             next
  [15:45:54.368]                           if (!grepl("^muffle", name)) 
  [15:45:54.368]                             next
  [15:45:54.368]                           invokeRestart(restart)
  [15:45:54.368]                           muffled <- TRUE
  [15:45:54.368]                           break
  [15:45:54.368]                         }
  [15:45:54.368]                       }
  [15:45:54.368]                       invisible(muffled)
  [15:45:54.368]                     }
  [15:45:54.368]                     muffleCondition(cond)
  [15:45:54.368]                   }
  [15:45:54.368]                 }
  [15:45:54.368]             }
  [15:45:54.368]         }))
  [15:45:54.368]     }, error = function(ex) {
  [15:45:54.368]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.368]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.368]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.368]     }, finally = {
  [15:45:54.368]         {
  [15:45:54.368]             NULL
  [15:45:54.368]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.368]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.368]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.368]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.368]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.368]                 ...) 
  [15:45:54.368]             {
  [15:45:54.368]                 if (substitute) 
  [15:45:54.368]                   expr <- substitute(expr)
  [15:45:54.368]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.368]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.368]                   globals = globals, persistent = persistent, 
  [15:45:54.368]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.368]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.368]                   label = label, ...)
  [15:45:54.368]                 if (!future$lazy) 
  [15:45:54.368]                   future <- run(future)
  [15:45:54.368]                 invisible(future)
  [15:45:54.368]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.368]         }
  [15:45:54.368]         base::options(...future.oldOptions)
  [15:45:54.368]     })
  [15:45:54.368]     Sys.time
  [15:45:54.368]     if (base::is.na(TRUE)) {
  [15:45:54.368]     }
  [15:45:54.368]     else {
  [15:45:54.368]         base::sink(type = "output", split = FALSE)
  [15:45:54.368]         if (TRUE) {
  [15:45:54.368]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.368]         }
  [15:45:54.368]         else {
  [15:45:54.368]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.368]         }
  [15:45:54.368]         base::close(...future.stdout)
  [15:45:54.368]         ...future.stdout <- NULL
  [15:45:54.368]     }
  [15:45:54.368]     ...future.result$conditions <- ...future.conditions
  [15:45:54.368]     ...future.result
  [15:45:54.368] }
  [15:45:54.393] ClusterFuture started
  [15:45:54.393] getGlobalsAndPackages() ...
  [15:45:54.394] Searching for globals...
  [15:45:54.395] 
  [15:45:54.395] Searching for globals ... DONE
  [15:45:54.395] - globals: [0] <none>
  [15:45:54.396] getGlobalsAndPackages() ... DONE
  [15:45:54.401] Packages needed by the future expression (n = 0): <none>
  [15:45:54.401] Packages needed by future strategies (n = 0): <none>
  [15:45:54.417] {
  [15:45:54.417]     {
  [15:45:54.417]         ...future.startTime <- base::Sys.time()
  [15:45:54.417]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.417]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.417]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.417]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.417]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.417]         {
  [15:45:54.417]             {
  [15:45:54.417]                 base::local({
  [15:45:54.417]                   has_future <- base::requireNamespace("future", 
  [15:45:54.417]                     quietly = TRUE)
  [15:45:54.417]                   version <- if (has_future) 
  [15:45:54.417]                     utils::packageVersion("future")
  [15:45:54.417]                   else NULL
  [15:45:54.417]                   if (!has_future || version < "1.8.0") {
  [15:45:54.417]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.417]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.417]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.417]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.417]                         "release", "version")], collapse = " "), 
  [15:45:54.417]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.417]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.417]                       info)
  [15:45:54.417]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.417]                     if (!has_future) {
  [15:45:54.417]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.417]                         info)
  [15:45:54.417]                     }
  [15:45:54.417]                     else {
  [15:45:54.417]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.417]                         info, version)
  [15:45:54.417]                     }
  [15:45:54.417]                     base::stop(msg)
  [15:45:54.417]                   }
  [15:45:54.417]                 })
  [15:45:54.417]             }
  [15:45:54.417]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.417]         }
  [15:45:54.417]     }
  [15:45:54.417]     if (base::is.na(TRUE)) {
  [15:45:54.417]     }
  [15:45:54.417]     else {
  [15:45:54.417]         if (TRUE) {
  [15:45:54.417]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.417]                 open = "w")
  [15:45:54.417]         }
  [15:45:54.417]         else {
  [15:45:54.417]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.417]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.417]         }
  [15:45:54.417]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.417]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.417]             base::sink(type = "output", split = FALSE)
  [15:45:54.417]             base::close(...future.stdout)
  [15:45:54.417]         }, add = TRUE)
  [15:45:54.417]     }
  [15:45:54.417]     ...future.frame <- base::sys.nframe()
  [15:45:54.417]     ...future.conditions <- base::list()
  [15:45:54.417]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.417]     ...future.result <- base::tryCatch({
  [15:45:54.417]         base::withCallingHandlers({
  [15:45:54.417]             ...future.value <- base::withVisible(base::local({
  [15:45:54.417]                 ...future.sendCondition <- local({
  [15:45:54.417]                   sendCondition <- NULL
  [15:45:54.417]                   function(frame = 1L) {
  [15:45:54.417]                     if (is.function(sendCondition)) 
  [15:45:54.417]                       return(sendCondition)
  [15:45:54.417]                     ns <- getNamespace("parallel")
  [15:45:54.417]                     if (exists("sendData", mode = "function", 
  [15:45:54.417]                       envir = ns)) {
  [15:45:54.417]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.417]                         envir = ns)
  [15:45:54.417]                       envir <- sys.frame(frame)
  [15:45:54.417]                       master <- NULL
  [15:45:54.417]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.417]                         !identical(envir, emptyenv())) {
  [15:45:54.417]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.417]                           inherits = FALSE)) {
  [15:45:54.417]                           master <- get("master", mode = "list", 
  [15:45:54.417]                             envir = envir, inherits = FALSE)
  [15:45:54.417]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.417]                             sendCondition <<- function(cond) {
  [15:45:54.417]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.417]                                 success = TRUE)
  [15:45:54.417]                               parallel_sendData(master, data)
  [15:45:54.417]                             }
  [15:45:54.417]                             return(sendCondition)
  [15:45:54.417]                           }
  [15:45:54.417]                         }
  [15:45:54.417]                         frame <- frame + 1L
  [15:45:54.417]                         envir <- sys.frame(frame)
  [15:45:54.417]                       }
  [15:45:54.417]                     }
  [15:45:54.417]                     sendCondition <<- function(cond) NULL
  [15:45:54.417]                   }
  [15:45:54.417]                 })
  [15:45:54.417]                 withCallingHandlers({
  [15:45:54.417]                   NULL
  [15:45:54.417]                 }, immediateCondition = function(cond) {
  [15:45:54.417]                   sendCondition <- ...future.sendCondition()
  [15:45:54.417]                   sendCondition(cond)
  [15:45:54.417]                   muffleCondition <- function (cond) 
  [15:45:54.417]                   {
  [15:45:54.417]                     inherits <- base::inherits
  [15:45:54.417]                     invokeRestart <- base::invokeRestart
  [15:45:54.417]                     muffled <- FALSE
  [15:45:54.417]                     if (inherits(cond, "message")) {
  [15:45:54.417]                       invokeRestart("muffleMessage")
  [15:45:54.417]                       muffled <- TRUE
  [15:45:54.417]                     }
  [15:45:54.417]                     else if (inherits(cond, "warning")) {
  [15:45:54.417]                       invokeRestart("muffleWarning")
  [15:45:54.417]                       muffled <- TRUE
  [15:45:54.417]                     }
  [15:45:54.417]                     else if (inherits(cond, "condition")) {
  [15:45:54.417]                       computeRestarts <- base::computeRestarts
  [15:45:54.417]                       grepl <- base::grepl
  [15:45:54.417]                       is.null <- base::is.null
  [15:45:54.417]                       restarts <- computeRestarts(cond)
  [15:45:54.417]                       for (restart in restarts) {
  [15:45:54.417]                         name <- restart$name
  [15:45:54.417]                         if (is.null(name)) 
  [15:45:54.417]                           next
  [15:45:54.417]                         if (!grepl("^muffle", name)) 
  [15:45:54.417]                           next
  [15:45:54.417]                         invokeRestart(restart)
  [15:45:54.417]                         muffled <- TRUE
  [15:45:54.417]                         break
  [15:45:54.417]                       }
  [15:45:54.417]                     }
  [15:45:54.417]                     invisible(muffled)
  [15:45:54.417]                   }
  [15:45:54.417]                   muffleCondition(cond)
  [15:45:54.417]                 })
  [15:45:54.417]             }))
  [15:45:54.417]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.417]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.417]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.417]                 version = "1.8")
  [15:45:54.417]         }, condition = base::local({
  [15:45:54.417]             c <- base::c
  [15:45:54.417]             inherits <- base::inherits
  [15:45:54.417]             invokeRestart <- base::invokeRestart
  [15:45:54.417]             length <- base::length
  [15:45:54.417]             list <- base::list
  [15:45:54.417]             seq.int <- base::seq.int
  [15:45:54.417]             signalCondition <- base::signalCondition
  [15:45:54.417]             sys.calls <- base::sys.calls
  [15:45:54.417]             Sys.time <- base::Sys.time
  [15:45:54.417]             `[[` <- base::`[[`
  [15:45:54.417]             `+` <- base::`+`
  [15:45:54.417]             `<<-` <- base::`<<-`
  [15:45:54.417]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.417]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.417]                   3L)]
  [15:45:54.417]             }
  [15:45:54.417]             function(cond) {
  [15:45:54.417]                 if (inherits(cond, "error")) {
  [15:45:54.417]                   sessionInformation <- function() {
  [15:45:54.417]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.417]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.417]                       search = base::search(), system = base::Sys.info())
  [15:45:54.417]                   }
  [15:45:54.417]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.417]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.417]                     cond$call), session = sessionInformation(), 
  [15:45:54.417]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.417]                   signalCondition(cond)
  [15:45:54.417]                 }
  [15:45:54.417]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.417]                 ))) {
  [15:45:54.417]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.417]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.417]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.417]                   if (!signal) {
  [15:45:54.417]                     muffleCondition <- function (cond) 
  [15:45:54.417]                     {
  [15:45:54.417]                       inherits <- base::inherits
  [15:45:54.417]                       invokeRestart <- base::invokeRestart
  [15:45:54.417]                       muffled <- FALSE
  [15:45:54.417]                       if (inherits(cond, "message")) {
  [15:45:54.417]                         invokeRestart("muffleMessage")
  [15:45:54.417]                         muffled <- TRUE
  [15:45:54.417]                       }
  [15:45:54.417]                       else if (inherits(cond, "warning")) {
  [15:45:54.417]                         invokeRestart("muffleWarning")
  [15:45:54.417]                         muffled <- TRUE
  [15:45:54.417]                       }
  [15:45:54.417]                       else if (inherits(cond, "condition")) {
  [15:45:54.417]                         computeRestarts <- base::computeRestarts
  [15:45:54.417]                         grepl <- base::grepl
  [15:45:54.417]                         is.null <- base::is.null
  [15:45:54.417]                         restarts <- computeRestarts(cond)
  [15:45:54.417]                         for (restart in restarts) {
  [15:45:54.417]                           name <- restart$name
  [15:45:54.417]                           if (is.null(name)) 
  [15:45:54.417]                             next
  [15:45:54.417]                           if (!grepl("^muffle", name)) 
  [15:45:54.417]                             next
  [15:45:54.417]                           invokeRestart(restart)
  [15:45:54.417]                           muffled <- TRUE
  [15:45:54.417]                           break
  [15:45:54.417]                         }
  [15:45:54.417]                       }
  [15:45:54.417]                       invisible(muffled)
  [15:45:54.417]                     }
  [15:45:54.417]                     muffleCondition(cond)
  [15:45:54.417]                   }
  [15:45:54.417]                 }
  [15:45:54.417]             }
  [15:45:54.417]         }))
  [15:45:54.417]     }, error = function(ex) {
  [15:45:54.417]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.417]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.417]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.417]     }, finally = {
  [15:45:54.417]         {
  [15:45:54.417]             NULL
  [15:45:54.417]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.417]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.417]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.417]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.417]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.417]                 ...) 
  [15:45:54.417]             {
  [15:45:54.417]                 if (substitute) 
  [15:45:54.417]                   expr <- substitute(expr)
  [15:45:54.417]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.417]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.417]                   globals = globals, persistent = persistent, 
  [15:45:54.417]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.417]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.417]                   label = label, ...)
  [15:45:54.417]                 if (!future$lazy) 
  [15:45:54.417]                   future <- run(future)
  [15:45:54.417]                 invisible(future)
  [15:45:54.417]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.417]         }
  [15:45:54.417]         base::options(...future.oldOptions)
  [15:45:54.417]     })
  [15:45:54.417]     Sys.time
  [15:45:54.417]     if (base::is.na(TRUE)) {
  [15:45:54.417]     }
  [15:45:54.417]     else {
  [15:45:54.417]         base::sink(type = "output", split = FALSE)
  [15:45:54.417]         if (TRUE) {
  [15:45:54.417]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.417]         }
  [15:45:54.417]         else {
  [15:45:54.417]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.417]         }
  [15:45:54.417]         base::close(...future.stdout)
  [15:45:54.417]         ...future.stdout <- NULL
  [15:45:54.417]     }
  [15:45:54.417]     ...future.result$conditions <- ...future.conditions
  [15:45:54.417]     ...future.result
  [15:45:54.417] }
  [15:45:54.432] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:54.494] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.495] - Validating connection of ClusterFuture
  [15:45:54.495] - received message: FutureResult
  [15:45:54.496] - Received FutureResult
  [15:45:54.496] - Erased future from FutureRegistry
  [15:45:54.497] result() for ClusterFuture ...
  [15:45:54.497] - result already collected: FutureResult
  [15:45:54.498] result() for ClusterFuture ... done
  [15:45:54.498] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:54.499] result() for ClusterFuture ...
  [15:45:54.499] - result already collected: FutureResult
  [15:45:54.500] result() for ClusterFuture ... done
  [15:45:54.500] result() for ClusterFuture ...
  [15:45:54.501] - result already collected: FutureResult
  [15:45:54.501] result() for ClusterFuture ... done
  [15:45:54.514] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a60d6a0> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa91e78> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a60d6a0> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa91e78> 
   $  : 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" ...
  [15:45:54.560] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.560] - Validating connection of ClusterFuture
  [15:45:54.561] - received message: FutureResult
  [15:45:54.561] - Received FutureResult
  [15:45:54.561] - Erased future from FutureRegistry
  [15:45:54.562] result() for ClusterFuture ...
  [15:45:54.562] - result already collected: FutureResult
  [15:45:54.563] result() for ClusterFuture ... done
  [15:45:54.563] 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" "" ...
  [15:45:54.569] resolve() on list ...
  [15:45:54.569]  recursive: 0
  [15:45:54.569]  length: 6
  [15:45:54.570]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:54.570] signalConditionsASAP(numeric, pos=1) ...
  [15:45:54.570] - nx: 6
  [15:45:54.571] - relay: TRUE
  [15:45:54.571] - stdout: TRUE
  [15:45:54.571] - signal: TRUE
  [15:45:54.571] - resignal: FALSE
  [15:45:54.572] - force: TRUE
  [15:45:54.572] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.572] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.573]  - until=2
  [15:45:54.573]  - relaying element #2
  [15:45:54.573] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.574] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.574] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:54.574]  length: 5 (resolved future 1)
  [15:45:54.591] Future #2
  [15:45:54.591] result() for ClusterFuture ...
  [15:45:54.592] - result already collected: FutureResult
  [15:45:54.592] result() for ClusterFuture ... done
  [15:45:54.592] result() for ClusterFuture ...
  [15:45:54.593] - result already collected: FutureResult
  [15:45:54.593] result() for ClusterFuture ... done
  [15:45:54.593] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:54.594] - nx: 6
  [15:45:54.594] - relay: TRUE
  [15:45:54.594] - stdout: TRUE
  [15:45:54.595] - signal: TRUE
  [15:45:54.595] - resignal: FALSE
  [15:45:54.595] - force: TRUE
  [15:45:54.596] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.596] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.596]  - until=2
  [15:45:54.597]  - relaying element #2
  [15:45:54.597] result() for ClusterFuture ...
  [15:45:54.597] - result already collected: FutureResult
  [15:45:54.598] result() for ClusterFuture ... done
  [15:45:54.598] result() for ClusterFuture ...
  [15:45:54.598] - result already collected: FutureResult
  [15:45:54.599] result() for ClusterFuture ... done
  [15:45:54.599] result() for ClusterFuture ...
  [15:45:54.603] - result already collected: FutureResult
  [15:45:54.604] result() for ClusterFuture ... done
  [15:45:54.604] result() for ClusterFuture ...
  [15:45:54.604] - result already collected: FutureResult
  [15:45:54.605] result() for ClusterFuture ... done
  [15:45:54.605] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.605] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.606] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:54.606]  length: 4 (resolved future 2)
  [15:45:54.623] Future #3
  [15:45:54.623] result() for ClusterFuture ...
  [15:45:54.623] - result already collected: FutureResult
  [15:45:54.624] result() for ClusterFuture ... done
  [15:45:54.624] result() for ClusterFuture ...
  [15:45:54.624] - result already collected: FutureResult
  [15:45:54.625] result() for ClusterFuture ... done
  [15:45:54.625] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:54.625] - nx: 6
  [15:45:54.626] - relay: TRUE
  [15:45:54.626] - stdout: TRUE
  [15:45:54.626] - signal: TRUE
  [15:45:54.627] - resignal: FALSE
  [15:45:54.627] - force: TRUE
  [15:45:54.627] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.627] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.628]  - until=3
  [15:45:54.628]  - relaying element #3
  [15:45:54.628] result() for ClusterFuture ...
  [15:45:54.629] - result already collected: FutureResult
  [15:45:54.629] result() for ClusterFuture ... done
  [15:45:54.629] result() for ClusterFuture ...
  [15:45:54.630] - result already collected: FutureResult
  [15:45:54.630] result() for ClusterFuture ... done
  [15:45:54.631] result() for ClusterFuture ...
  [15:45:54.631] - result already collected: FutureResult
  [15:45:54.631] result() for ClusterFuture ... done
  [15:45:54.632] result() for ClusterFuture ...
  [15:45:54.632] - result already collected: FutureResult
  [15:45:54.632] result() for ClusterFuture ... done
  [15:45:54.632] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.633] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.633] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:54.634]  length: 3 (resolved future 3)
  [15:45:54.634] signalConditionsASAP(NULL, pos=4) ...
  [15:45:54.634] - nx: 6
  [15:45:54.634] - relay: TRUE
  [15:45:54.635] - stdout: TRUE
  [15:45:54.635] - signal: TRUE
  [15:45:54.635] - resignal: FALSE
  [15:45:54.636] - force: TRUE
  [15:45:54.636] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.636] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.637]  - until=5
  [15:45:54.637]  - relaying element #5
  [15:45:54.637] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.637] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.638] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:54.638]  length: 2 (resolved future 4)
  [15:45:54.654] signalConditionsASAP(NULL, pos=5) ...
  [15:45:54.654] - nx: 6
  [15:45:54.655] - relay: TRUE
  [15:45:54.655] - stdout: TRUE
  [15:45:54.655] - signal: TRUE
  [15:45:54.655] - resignal: FALSE
  [15:45:54.656] - force: TRUE
  [15:45:54.656] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.656] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.657]  - until=6
  [15:45:54.657]  - relaying element #6
  [15:45:54.657] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.658] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.658] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:54.659]  length: 1 (resolved future 5)
  [15:45:54.659] signalConditionsASAP(numeric, pos=6) ...
  [15:45:54.659] - nx: 6
  [15:45:54.660] - relay: TRUE
  [15:45:54.660] - stdout: TRUE
  [15:45:54.660] - signal: TRUE
  [15:45:54.660] - resignal: FALSE
  [15:45:54.661] - force: TRUE
  [15:45:54.661] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.661] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.662]  - until=6
  [15:45:54.662] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.663] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.663] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:54.663]  length: 0 (resolved future 6)
  [15:45:54.664] Relaying remaining futures
  [15:45:54.674] signalConditionsASAP(NULL, pos=0) ...
  [15:45:54.675] - nx: 6
  [15:45:54.675] - relay: TRUE
  [15:45:54.675] - stdout: TRUE
  [15:45:54.676] - signal: TRUE
  [15:45:54.676] - resignal: FALSE
  [15:45:54.676] - force: TRUE
  [15:45:54.677] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.677] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:54.678] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.678] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.678] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:54.679] resolve() on list ... DONE
  [15:45:54.679] result() for ClusterFuture ...
  [15:45:54.679] - result already collected: FutureResult
  [15:45:54.680] result() for ClusterFuture ... done
  [15:45:54.680] result() for ClusterFuture ...
  [15:45:54.680] - result already collected: FutureResult
  [15:45:54.681] result() for ClusterFuture ... done
  [15:45:54.681] result() for ClusterFuture ...
  [15:45:54.681] - result already collected: FutureResult
  [15:45:54.682] result() for ClusterFuture ... done
  [15:45:54.682] result() for ClusterFuture ...
  [15:45:54.682] - result already collected: FutureResult
  [15:45:54.683] 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)
  [15:45:54.714] getGlobalsAndPackages() ...
  [15:45:54.715] Searching for globals...
  [15:45:54.716] 
  [15:45:54.716] Searching for globals ... DONE
  [15:45:54.716] - globals: [0] <none>
  [15:45:54.717] getGlobalsAndPackages() ... DONE
  [15:45:54.723] Packages needed by the future expression (n = 0): <none>
  [15:45:54.723] Packages needed by future strategies (n = 0): <none>
  [15:45:54.740] {
  [15:45:54.740]     {
  [15:45:54.740]         ...future.startTime <- base::Sys.time()
  [15:45:54.740]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.740]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.740]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.740]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.740]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.740]         {
  [15:45:54.740]             {
  [15:45:54.740]                 base::local({
  [15:45:54.740]                   has_future <- base::requireNamespace("future", 
  [15:45:54.740]                     quietly = TRUE)
  [15:45:54.740]                   version <- if (has_future) 
  [15:45:54.740]                     utils::packageVersion("future")
  [15:45:54.740]                   else NULL
  [15:45:54.740]                   if (!has_future || version < "1.8.0") {
  [15:45:54.740]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.740]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.740]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.740]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.740]                         "release", "version")], collapse = " "), 
  [15:45:54.740]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.740]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.740]                       info)
  [15:45:54.740]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.740]                     if (!has_future) {
  [15:45:54.740]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.740]                         info)
  [15:45:54.740]                     }
  [15:45:54.740]                     else {
  [15:45:54.740]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.740]                         info, version)
  [15:45:54.740]                     }
  [15:45:54.740]                     base::stop(msg)
  [15:45:54.740]                   }
  [15:45:54.740]                 })
  [15:45:54.740]             }
  [15:45:54.740]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.740]         }
  [15:45:54.740]     }
  [15:45:54.740]     if (base::is.na(TRUE)) {
  [15:45:54.740]     }
  [15:45:54.740]     else {
  [15:45:54.740]         if (TRUE) {
  [15:45:54.740]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.740]                 open = "w")
  [15:45:54.740]         }
  [15:45:54.740]         else {
  [15:45:54.740]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.740]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.740]         }
  [15:45:54.740]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.740]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.740]             base::sink(type = "output", split = FALSE)
  [15:45:54.740]             base::close(...future.stdout)
  [15:45:54.740]         }, add = TRUE)
  [15:45:54.740]     }
  [15:45:54.740]     ...future.frame <- base::sys.nframe()
  [15:45:54.740]     ...future.conditions <- base::list()
  [15:45:54.740]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.740]     ...future.result <- base::tryCatch({
  [15:45:54.740]         base::withCallingHandlers({
  [15:45:54.740]             ...future.value <- base::withVisible(base::local({
  [15:45:54.740]                 ...future.sendCondition <- local({
  [15:45:54.740]                   sendCondition <- NULL
  [15:45:54.740]                   function(frame = 1L) {
  [15:45:54.740]                     if (is.function(sendCondition)) 
  [15:45:54.740]                       return(sendCondition)
  [15:45:54.740]                     ns <- getNamespace("parallel")
  [15:45:54.740]                     if (exists("sendData", mode = "function", 
  [15:45:54.740]                       envir = ns)) {
  [15:45:54.740]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.740]                         envir = ns)
  [15:45:54.740]                       envir <- sys.frame(frame)
  [15:45:54.740]                       master <- NULL
  [15:45:54.740]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.740]                         !identical(envir, emptyenv())) {
  [15:45:54.740]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.740]                           inherits = FALSE)) {
  [15:45:54.740]                           master <- get("master", mode = "list", 
  [15:45:54.740]                             envir = envir, inherits = FALSE)
  [15:45:54.740]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.740]                             sendCondition <<- function(cond) {
  [15:45:54.740]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.740]                                 success = TRUE)
  [15:45:54.740]                               parallel_sendData(master, data)
  [15:45:54.740]                             }
  [15:45:54.740]                             return(sendCondition)
  [15:45:54.740]                           }
  [15:45:54.740]                         }
  [15:45:54.740]                         frame <- frame + 1L
  [15:45:54.740]                         envir <- sys.frame(frame)
  [15:45:54.740]                       }
  [15:45:54.740]                     }
  [15:45:54.740]                     sendCondition <<- function(cond) NULL
  [15:45:54.740]                   }
  [15:45:54.740]                 })
  [15:45:54.740]                 withCallingHandlers({
  [15:45:54.740]                   2
  [15:45:54.740]                 }, immediateCondition = function(cond) {
  [15:45:54.740]                   sendCondition <- ...future.sendCondition()
  [15:45:54.740]                   sendCondition(cond)
  [15:45:54.740]                   muffleCondition <- function (cond) 
  [15:45:54.740]                   {
  [15:45:54.740]                     inherits <- base::inherits
  [15:45:54.740]                     invokeRestart <- base::invokeRestart
  [15:45:54.740]                     muffled <- FALSE
  [15:45:54.740]                     if (inherits(cond, "message")) {
  [15:45:54.740]                       invokeRestart("muffleMessage")
  [15:45:54.740]                       muffled <- TRUE
  [15:45:54.740]                     }
  [15:45:54.740]                     else if (inherits(cond, "warning")) {
  [15:45:54.740]                       invokeRestart("muffleWarning")
  [15:45:54.740]                       muffled <- TRUE
  [15:45:54.740]                     }
  [15:45:54.740]                     else if (inherits(cond, "condition")) {
  [15:45:54.740]                       computeRestarts <- base::computeRestarts
  [15:45:54.740]                       grepl <- base::grepl
  [15:45:54.740]                       is.null <- base::is.null
  [15:45:54.740]                       restarts <- computeRestarts(cond)
  [15:45:54.740]                       for (restart in restarts) {
  [15:45:54.740]                         name <- restart$name
  [15:45:54.740]                         if (is.null(name)) 
  [15:45:54.740]                           next
  [15:45:54.740]                         if (!grepl("^muffle", name)) 
  [15:45:54.740]                           next
  [15:45:54.740]                         invokeRestart(restart)
  [15:45:54.740]                         muffled <- TRUE
  [15:45:54.740]                         break
  [15:45:54.740]                       }
  [15:45:54.740]                     }
  [15:45:54.740]                     invisible(muffled)
  [15:45:54.740]                   }
  [15:45:54.740]                   muffleCondition(cond)
  [15:45:54.740]                 })
  [15:45:54.740]             }))
  [15:45:54.740]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.740]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.740]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.740]                 version = "1.8")
  [15:45:54.740]         }, condition = base::local({
  [15:45:54.740]             c <- base::c
  [15:45:54.740]             inherits <- base::inherits
  [15:45:54.740]             invokeRestart <- base::invokeRestart
  [15:45:54.740]             length <- base::length
  [15:45:54.740]             list <- base::list
  [15:45:54.740]             seq.int <- base::seq.int
  [15:45:54.740]             signalCondition <- base::signalCondition
  [15:45:54.740]             sys.calls <- base::sys.calls
  [15:45:54.740]             Sys.time <- base::Sys.time
  [15:45:54.740]             `[[` <- base::`[[`
  [15:45:54.740]             `+` <- base::`+`
  [15:45:54.740]             `<<-` <- base::`<<-`
  [15:45:54.740]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.740]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.740]                   3L)]
  [15:45:54.740]             }
  [15:45:54.740]             function(cond) {
  [15:45:54.740]                 if (inherits(cond, "error")) {
  [15:45:54.740]                   sessionInformation <- function() {
  [15:45:54.740]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.740]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.740]                       search = base::search(), system = base::Sys.info())
  [15:45:54.740]                   }
  [15:45:54.740]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.740]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.740]                     cond$call), session = sessionInformation(), 
  [15:45:54.740]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.740]                   signalCondition(cond)
  [15:45:54.740]                 }
  [15:45:54.740]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.740]                 ))) {
  [15:45:54.740]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.740]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.740]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.740]                   if (!signal) {
  [15:45:54.740]                     muffleCondition <- function (cond) 
  [15:45:54.740]                     {
  [15:45:54.740]                       inherits <- base::inherits
  [15:45:54.740]                       invokeRestart <- base::invokeRestart
  [15:45:54.740]                       muffled <- FALSE
  [15:45:54.740]                       if (inherits(cond, "message")) {
  [15:45:54.740]                         invokeRestart("muffleMessage")
  [15:45:54.740]                         muffled <- TRUE
  [15:45:54.740]                       }
  [15:45:54.740]                       else if (inherits(cond, "warning")) {
  [15:45:54.740]                         invokeRestart("muffleWarning")
  [15:45:54.740]                         muffled <- TRUE
  [15:45:54.740]                       }
  [15:45:54.740]                       else if (inherits(cond, "condition")) {
  [15:45:54.740]                         computeRestarts <- base::computeRestarts
  [15:45:54.740]                         grepl <- base::grepl
  [15:45:54.740]                         is.null <- base::is.null
  [15:45:54.740]                         restarts <- computeRestarts(cond)
  [15:45:54.740]                         for (restart in restarts) {
  [15:45:54.740]                           name <- restart$name
  [15:45:54.740]                           if (is.null(name)) 
  [15:45:54.740]                             next
  [15:45:54.740]                           if (!grepl("^muffle", name)) 
  [15:45:54.740]                             next
  [15:45:54.740]                           invokeRestart(restart)
  [15:45:54.740]                           muffled <- TRUE
  [15:45:54.740]                           break
  [15:45:54.740]                         }
  [15:45:54.740]                       }
  [15:45:54.740]                       invisible(muffled)
  [15:45:54.740]                     }
  [15:45:54.740]                     muffleCondition(cond)
  [15:45:54.740]                   }
  [15:45:54.740]                 }
  [15:45:54.740]             }
  [15:45:54.740]         }))
  [15:45:54.740]     }, error = function(ex) {
  [15:45:54.740]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.740]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.740]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.740]     }, finally = {
  [15:45:54.740]         {
  [15:45:54.740]             NULL
  [15:45:54.740]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.740]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.740]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.740]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.740]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.740]                 ...) 
  [15:45:54.740]             {
  [15:45:54.740]                 if (substitute) 
  [15:45:54.740]                   expr <- substitute(expr)
  [15:45:54.740]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.740]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.740]                   globals = globals, persistent = persistent, 
  [15:45:54.740]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.740]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.740]                   label = label, ...)
  [15:45:54.740]                 if (!future$lazy) 
  [15:45:54.740]                   future <- run(future)
  [15:45:54.740]                 invisible(future)
  [15:45:54.740]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.740]         }
  [15:45:54.740]         base::options(...future.oldOptions)
  [15:45:54.740]     })
  [15:45:54.740]     Sys.time
  [15:45:54.740]     if (base::is.na(TRUE)) {
  [15:45:54.740]     }
  [15:45:54.740]     else {
  [15:45:54.740]         base::sink(type = "output", split = FALSE)
  [15:45:54.740]         if (TRUE) {
  [15:45:54.740]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.740]         }
  [15:45:54.740]         else {
  [15:45:54.740]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.740]         }
  [15:45:54.740]         base::close(...future.stdout)
  [15:45:54.740]         ...future.stdout <- NULL
  [15:45:54.740]     }
  [15:45:54.740]     ...future.result$conditions <- ...future.conditions
  [15:45:54.740]     ...future.result
  [15:45:54.740] }
  [15:45:54.757] ClusterFuture started
  [15:45:54.758] getGlobalsAndPackages() ...
  [15:45:54.758] Searching for globals...
  [15:45:54.759] 
  [15:45:54.760] Searching for globals ... DONE
  [15:45:54.760] - globals: [0] <none>
  [15:45:54.760] getGlobalsAndPackages() ... DONE
  [15:45:54.780] Packages needed by the future expression (n = 0): <none>
  [15:45:54.780] Packages needed by future strategies (n = 0): <none>
  [15:45:54.796] {
  [15:45:54.796]     {
  [15:45:54.796]         ...future.startTime <- base::Sys.time()
  [15:45:54.796]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:54.796]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:54.796]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:54.796]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:54.796]             future.resolve.recursive = NULL, width = 80L)
  [15:45:54.796]         {
  [15:45:54.796]             {
  [15:45:54.796]                 base::local({
  [15:45:54.796]                   has_future <- base::requireNamespace("future", 
  [15:45:54.796]                     quietly = TRUE)
  [15:45:54.796]                   version <- if (has_future) 
  [15:45:54.796]                     utils::packageVersion("future")
  [15:45:54.796]                   else NULL
  [15:45:54.796]                   if (!has_future || version < "1.8.0") {
  [15:45:54.796]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:54.796]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:54.796]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:54.796]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:54.796]                         "release", "version")], collapse = " "), 
  [15:45:54.796]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:54.796]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:54.796]                       info)
  [15:45:54.796]                     info <- base::paste(info, collapse = "; ")
  [15:45:54.796]                     if (!has_future) {
  [15:45:54.796]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:54.796]                         info)
  [15:45:54.796]                     }
  [15:45:54.796]                     else {
  [15:45:54.796]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:54.796]                         info, version)
  [15:45:54.796]                     }
  [15:45:54.796]                     base::stop(msg)
  [15:45:54.796]                   }
  [15:45:54.796]                 })
  [15:45:54.796]             }
  [15:45:54.796]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:54.796]         }
  [15:45:54.796]     }
  [15:45:54.796]     if (base::is.na(TRUE)) {
  [15:45:54.796]     }
  [15:45:54.796]     else {
  [15:45:54.796]         if (TRUE) {
  [15:45:54.796]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:54.796]                 open = "w")
  [15:45:54.796]         }
  [15:45:54.796]         else {
  [15:45:54.796]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:54.796]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:54.796]         }
  [15:45:54.796]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:54.796]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:54.796]             base::sink(type = "output", split = FALSE)
  [15:45:54.796]             base::close(...future.stdout)
  [15:45:54.796]         }, add = TRUE)
  [15:45:54.796]     }
  [15:45:54.796]     ...future.frame <- base::sys.nframe()
  [15:45:54.796]     ...future.conditions <- base::list()
  [15:45:54.796]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:54.796]     ...future.result <- base::tryCatch({
  [15:45:54.796]         base::withCallingHandlers({
  [15:45:54.796]             ...future.value <- base::withVisible(base::local({
  [15:45:54.796]                 ...future.sendCondition <- local({
  [15:45:54.796]                   sendCondition <- NULL
  [15:45:54.796]                   function(frame = 1L) {
  [15:45:54.796]                     if (is.function(sendCondition)) 
  [15:45:54.796]                       return(sendCondition)
  [15:45:54.796]                     ns <- getNamespace("parallel")
  [15:45:54.796]                     if (exists("sendData", mode = "function", 
  [15:45:54.796]                       envir = ns)) {
  [15:45:54.796]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:54.796]                         envir = ns)
  [15:45:54.796]                       envir <- sys.frame(frame)
  [15:45:54.796]                       master <- NULL
  [15:45:54.796]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:54.796]                         !identical(envir, emptyenv())) {
  [15:45:54.796]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:54.796]                           inherits = FALSE)) {
  [15:45:54.796]                           master <- get("master", mode = "list", 
  [15:45:54.796]                             envir = envir, inherits = FALSE)
  [15:45:54.796]                           if (inherits(master, "SOCKnode")) {
  [15:45:54.796]                             sendCondition <<- function(cond) {
  [15:45:54.796]                               data <- list(type = "VALUE", value = cond, 
  [15:45:54.796]                                 success = TRUE)
  [15:45:54.796]                               parallel_sendData(master, data)
  [15:45:54.796]                             }
  [15:45:54.796]                             return(sendCondition)
  [15:45:54.796]                           }
  [15:45:54.796]                         }
  [15:45:54.796]                         frame <- frame + 1L
  [15:45:54.796]                         envir <- sys.frame(frame)
  [15:45:54.796]                       }
  [15:45:54.796]                     }
  [15:45:54.796]                     sendCondition <<- function(cond) NULL
  [15:45:54.796]                   }
  [15:45:54.796]                 })
  [15:45:54.796]                 withCallingHandlers({
  [15:45:54.796]                   NULL
  [15:45:54.796]                 }, immediateCondition = function(cond) {
  [15:45:54.796]                   sendCondition <- ...future.sendCondition()
  [15:45:54.796]                   sendCondition(cond)
  [15:45:54.796]                   muffleCondition <- function (cond) 
  [15:45:54.796]                   {
  [15:45:54.796]                     inherits <- base::inherits
  [15:45:54.796]                     invokeRestart <- base::invokeRestart
  [15:45:54.796]                     muffled <- FALSE
  [15:45:54.796]                     if (inherits(cond, "message")) {
  [15:45:54.796]                       invokeRestart("muffleMessage")
  [15:45:54.796]                       muffled <- TRUE
  [15:45:54.796]                     }
  [15:45:54.796]                     else if (inherits(cond, "warning")) {
  [15:45:54.796]                       invokeRestart("muffleWarning")
  [15:45:54.796]                       muffled <- TRUE
  [15:45:54.796]                     }
  [15:45:54.796]                     else if (inherits(cond, "condition")) {
  [15:45:54.796]                       computeRestarts <- base::computeRestarts
  [15:45:54.796]                       grepl <- base::grepl
  [15:45:54.796]                       is.null <- base::is.null
  [15:45:54.796]                       restarts <- computeRestarts(cond)
  [15:45:54.796]                       for (restart in restarts) {
  [15:45:54.796]                         name <- restart$name
  [15:45:54.796]                         if (is.null(name)) 
  [15:45:54.796]                           next
  [15:45:54.796]                         if (!grepl("^muffle", name)) 
  [15:45:54.796]                           next
  [15:45:54.796]                         invokeRestart(restart)
  [15:45:54.796]                         muffled <- TRUE
  [15:45:54.796]                         break
  [15:45:54.796]                       }
  [15:45:54.796]                     }
  [15:45:54.796]                     invisible(muffled)
  [15:45:54.796]                   }
  [15:45:54.796]                   muffleCondition(cond)
  [15:45:54.796]                 })
  [15:45:54.796]             }))
  [15:45:54.796]             future::FutureResult(value = ...future.value$value, 
  [15:45:54.796]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.796]                   ...future.rng), started = ...future.startTime, 
  [15:45:54.796]                 version = "1.8")
  [15:45:54.796]         }, condition = base::local({
  [15:45:54.796]             c <- base::c
  [15:45:54.796]             inherits <- base::inherits
  [15:45:54.796]             invokeRestart <- base::invokeRestart
  [15:45:54.796]             length <- base::length
  [15:45:54.796]             list <- base::list
  [15:45:54.796]             seq.int <- base::seq.int
  [15:45:54.796]             signalCondition <- base::signalCondition
  [15:45:54.796]             sys.calls <- base::sys.calls
  [15:45:54.796]             Sys.time <- base::Sys.time
  [15:45:54.796]             `[[` <- base::`[[`
  [15:45:54.796]             `+` <- base::`+`
  [15:45:54.796]             `<<-` <- base::`<<-`
  [15:45:54.796]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:54.796]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:54.796]                   3L)]
  [15:45:54.796]             }
  [15:45:54.796]             function(cond) {
  [15:45:54.796]                 if (inherits(cond, "error")) {
  [15:45:54.796]                   sessionInformation <- function() {
  [15:45:54.796]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:54.796]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:54.796]                       search = base::search(), system = base::Sys.info())
  [15:45:54.796]                   }
  [15:45:54.796]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.796]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:54.796]                     cond$call), session = sessionInformation(), 
  [15:45:54.796]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:54.796]                   signalCondition(cond)
  [15:45:54.796]                 }
  [15:45:54.796]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:54.796]                 ))) {
  [15:45:54.796]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:54.796]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:54.796]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:54.796]                   if (!signal) {
  [15:45:54.796]                     muffleCondition <- function (cond) 
  [15:45:54.796]                     {
  [15:45:54.796]                       inherits <- base::inherits
  [15:45:54.796]                       invokeRestart <- base::invokeRestart
  [15:45:54.796]                       muffled <- FALSE
  [15:45:54.796]                       if (inherits(cond, "message")) {
  [15:45:54.796]                         invokeRestart("muffleMessage")
  [15:45:54.796]                         muffled <- TRUE
  [15:45:54.796]                       }
  [15:45:54.796]                       else if (inherits(cond, "warning")) {
  [15:45:54.796]                         invokeRestart("muffleWarning")
  [15:45:54.796]                         muffled <- TRUE
  [15:45:54.796]                       }
  [15:45:54.796]                       else if (inherits(cond, "condition")) {
  [15:45:54.796]                         computeRestarts <- base::computeRestarts
  [15:45:54.796]                         grepl <- base::grepl
  [15:45:54.796]                         is.null <- base::is.null
  [15:45:54.796]                         restarts <- computeRestarts(cond)
  [15:45:54.796]                         for (restart in restarts) {
  [15:45:54.796]                           name <- restart$name
  [15:45:54.796]                           if (is.null(name)) 
  [15:45:54.796]                             next
  [15:45:54.796]                           if (!grepl("^muffle", name)) 
  [15:45:54.796]                             next
  [15:45:54.796]                           invokeRestart(restart)
  [15:45:54.796]                           muffled <- TRUE
  [15:45:54.796]                           break
  [15:45:54.796]                         }
  [15:45:54.796]                       }
  [15:45:54.796]                       invisible(muffled)
  [15:45:54.796]                     }
  [15:45:54.796]                     muffleCondition(cond)
  [15:45:54.796]                   }
  [15:45:54.796]                 }
  [15:45:54.796]             }
  [15:45:54.796]         }))
  [15:45:54.796]     }, error = function(ex) {
  [15:45:54.796]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:54.796]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:54.796]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:54.796]     }, finally = {
  [15:45:54.796]         {
  [15:45:54.796]             NULL
  [15:45:54.796]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:54.796]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:54.796]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:54.796]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:54.796]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:54.796]                 ...) 
  [15:45:54.796]             {
  [15:45:54.796]                 if (substitute) 
  [15:45:54.796]                   expr <- substitute(expr)
  [15:45:54.796]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:54.796]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:54.796]                   globals = globals, persistent = persistent, 
  [15:45:54.796]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:54.796]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:54.796]                   label = label, ...)
  [15:45:54.796]                 if (!future$lazy) 
  [15:45:54.796]                   future <- run(future)
  [15:45:54.796]                 invisible(future)
  [15:45:54.796]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:54.796]         }
  [15:45:54.796]         base::options(...future.oldOptions)
  [15:45:54.796]     })
  [15:45:54.796]     Sys.time
  [15:45:54.796]     if (base::is.na(TRUE)) {
  [15:45:54.796]     }
  [15:45:54.796]     else {
  [15:45:54.796]         base::sink(type = "output", split = FALSE)
  [15:45:54.796]         if (TRUE) {
  [15:45:54.796]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:54.796]         }
  [15:45:54.796]         else {
  [15:45:54.796]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:54.796]         }
  [15:45:54.796]         base::close(...future.stdout)
  [15:45:54.796]         ...future.stdout <- NULL
  [15:45:54.796]     }
  [15:45:54.796]     ...future.result$conditions <- ...future.conditions
  [15:45:54.796]     ...future.result
  [15:45:54.796] }
  [15:45:54.807] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:54.820] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.820] - Validating connection of ClusterFuture
  [15:45:54.821] - received message: FutureResult
  [15:45:54.821] - Received FutureResult
  [15:45:54.822] - Erased future from FutureRegistry
  [15:45:54.822] result() for ClusterFuture ...
  [15:45:54.822] - result already collected: FutureResult
  [15:45:54.823] result() for ClusterFuture ... done
  [15:45:54.823] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:54.824] result() for ClusterFuture ...
  [15:45:54.824] - result already collected: FutureResult
  [15:45:54.825] result() for ClusterFuture ... done
  [15:45:54.825] result() for ClusterFuture ...
  [15:45:54.825] - result already collected: FutureResult
  [15:45:54.826] result() for ClusterFuture ... done
  [15:45:54.828] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa61cb8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2adbcd58> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2aa61cb8> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2adbcd58> 
   $  : 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"
  [15:45:54.876] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:54.876] - Validating connection of ClusterFuture
  [15:45:54.877] - received message: FutureResult
  [15:45:54.877] - Received FutureResult
  [15:45:54.877] - Erased future from FutureRegistry
  [15:45:54.878] result() for ClusterFuture ...
  [15:45:54.878] - result already collected: FutureResult
  [15:45:54.878] result() for ClusterFuture ... done
  [15:45:54.879] 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" "" ...
  [15:45:54.885] resolve() on list ...
  [15:45:54.886]  recursive: 0
  [15:45:54.886]  length: 6
  [15:45:54.886]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:54.887] signalConditionsASAP(numeric, pos=1) ...
  [15:45:54.887] - nx: 6
  [15:45:54.887] - relay: TRUE
  [15:45:54.888] - stdout: TRUE
  [15:45:54.888] - signal: TRUE
  [15:45:54.888] - resignal: FALSE
  [15:45:54.889] - force: TRUE
  [15:45:54.889] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.889] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.890]  - until=2
  [15:45:54.890]  - relaying element #2
  [15:45:54.907] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.907] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.907] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:54.908]  length: 5 (resolved future 1)
  [15:45:54.908] Future #2
  [15:45:54.908] result() for ClusterFuture ...
  [15:45:54.909] - result already collected: FutureResult
  [15:45:54.909] result() for ClusterFuture ... done
  [15:45:54.909] result() for ClusterFuture ...
  [15:45:54.910] - result already collected: FutureResult
  [15:45:54.910] result() for ClusterFuture ... done
  [15:45:54.910] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:54.911] - nx: 6
  [15:45:54.911] - relay: TRUE
  [15:45:54.911] - stdout: TRUE
  [15:45:54.912] - signal: TRUE
  [15:45:54.912] - resignal: FALSE
  [15:45:54.912] - force: TRUE
  [15:45:54.913] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.913] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.914]  - until=2
  [15:45:54.914]  - relaying element #2
  [15:45:54.914] result() for ClusterFuture ...
  [15:45:54.915] - result already collected: FutureResult
  [15:45:54.915] result() for ClusterFuture ... done
  [15:45:54.915] result() for ClusterFuture ...
  [15:45:54.930] - result already collected: FutureResult
  [15:45:54.931] result() for ClusterFuture ... done
  [15:45:54.931] result() for ClusterFuture ...
  [15:45:54.932] - result already collected: FutureResult
  [15:45:54.932] result() for ClusterFuture ... done
  [15:45:54.932] result() for ClusterFuture ...
  [15:45:54.933] - result already collected: FutureResult
  [15:45:54.933] result() for ClusterFuture ... done
  [15:45:54.934] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.934] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.934] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:54.935]  length: 4 (resolved future 2)
  [15:45:54.935] Future #3
  [15:45:54.935] result() for ClusterFuture ...
  [15:45:54.936] - result already collected: FutureResult
  [15:45:54.936] result() for ClusterFuture ... done
  [15:45:54.936] result() for ClusterFuture ...
  [15:45:54.937] - result already collected: FutureResult
  [15:45:54.937] result() for ClusterFuture ... done
  [15:45:54.938] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:54.938] - nx: 6
  [15:45:54.938] - relay: TRUE
  [15:45:54.939] - stdout: TRUE
  [15:45:54.939] - signal: TRUE
  [15:45:54.939] - resignal: FALSE
  [15:45:54.940] - force: TRUE
  [15:45:54.940] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.940] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:54.941]  - until=3
  [15:45:54.941]  - relaying element #3
  [15:45:54.941] result() for ClusterFuture ...
  [15:45:54.942] - result already collected: FutureResult
  [15:45:54.942] result() for ClusterFuture ... done
  [15:45:54.942] result() for ClusterFuture ...
  [15:45:54.943] - result already collected: FutureResult
  [15:45:54.943] result() for ClusterFuture ... done
  [15:45:54.944] result() for ClusterFuture ...
  [15:45:54.967] - result already collected: FutureResult
  [15:45:54.968] result() for ClusterFuture ... done
  [15:45:54.968] result() for ClusterFuture ...
  [15:45:54.968] - result already collected: FutureResult
  [15:45:54.969] result() for ClusterFuture ... done
  [15:45:54.969] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.969] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.970] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:54.970]  length: 3 (resolved future 3)
  [15:45:54.971] signalConditionsASAP(NULL, pos=4) ...
  [15:45:54.971] - nx: 6
  [15:45:54.971] - relay: TRUE
  [15:45:54.972] - stdout: TRUE
  [15:45:54.972] - signal: TRUE
  [15:45:54.972] - resignal: FALSE
  [15:45:54.973] - force: TRUE
  [15:45:54.973] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.973] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.974]  - until=5
  [15:45:54.974]  - relaying element #5
  [15:45:54.974] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.975] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.975] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:54.975]  length: 2 (resolved future 4)
  [15:45:54.976] signalConditionsASAP(NULL, pos=5) ...
  [15:45:54.986] - nx: 6
  [15:45:54.987] - relay: TRUE
  [15:45:54.987] - stdout: TRUE
  [15:45:54.988] - signal: TRUE
  [15:45:54.988] - resignal: FALSE
  [15:45:54.988] - force: TRUE
  [15:45:54.989] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:54.989] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.989]  - until=6
  [15:45:54.990]  - relaying element #6
  [15:45:54.990] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.990] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.991] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:54.991]  length: 1 (resolved future 5)
  [15:45:54.991] signalConditionsASAP(numeric, pos=6) ...
  [15:45:54.992] - nx: 6
  [15:45:54.992] - relay: TRUE
  [15:45:54.992] - stdout: TRUE
  [15:45:54.993] - signal: TRUE
  [15:45:54.993] - resignal: FALSE
  [15:45:54.993] - force: TRUE
  [15:45:54.994] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:54.994] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.995]  - until=6
  [15:45:54.995] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:54.995] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:54.996] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:55.006]  length: 0 (resolved future 6)
  [15:45:55.007] Relaying remaining futures
  [15:45:55.007] signalConditionsASAP(NULL, pos=0) ...
  [15:45:55.007] - nx: 6
  [15:45:55.008] - relay: TRUE
  [15:45:55.008] - stdout: TRUE
  [15:45:55.008] - signal: TRUE
  [15:45:55.009] - resignal: FALSE
  [15:45:55.009] - force: TRUE
  [15:45:55.009] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.010] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:55.010] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.011] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.011] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:55.011] resolve() on list ... DONE
  [15:45:55.012] result() for ClusterFuture ...
  [15:45:55.012] - result already collected: FutureResult
  [15:45:55.013] result() for ClusterFuture ... done
  [15:45:55.013] result() for ClusterFuture ...
  [15:45:55.013] - result already collected: FutureResult
  [15:45:55.014] result() for ClusterFuture ... done
  [15:45:55.014] result() for ClusterFuture ...
  [15:45:55.014] - result already collected: FutureResult
  [15:45:55.015] result() for ClusterFuture ... done
  [15:45:55.015] result() for ClusterFuture ...
  [15:45:55.015] - result already collected: FutureResult
  [15:45:55.016] 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)
  [15:45:55.049] getGlobalsAndPackages() ...
  [15:45:55.049] Searching for globals...
  [15:45:55.050] 
  [15:45:55.051] Searching for globals ... DONE
  [15:45:55.051] - globals: [0] <none>
  [15:45:55.051] getGlobalsAndPackages() ... DONE
  [15:45:55.067] Packages needed by the future expression (n = 0): <none>
  [15:45:55.068] Packages needed by future strategies (n = 0): <none>
  [15:45:55.074] {
  [15:45:55.074]     {
  [15:45:55.074]         ...future.startTime <- base::Sys.time()
  [15:45:55.074]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.074]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.074]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.074]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.074]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.074]         {
  [15:45:55.074]             {
  [15:45:55.074]                 base::local({
  [15:45:55.074]                   has_future <- base::requireNamespace("future", 
  [15:45:55.074]                     quietly = TRUE)
  [15:45:55.074]                   version <- if (has_future) 
  [15:45:55.074]                     utils::packageVersion("future")
  [15:45:55.074]                   else NULL
  [15:45:55.074]                   if (!has_future || version < "1.8.0") {
  [15:45:55.074]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.074]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.074]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.074]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.074]                         "release", "version")], collapse = " "), 
  [15:45:55.074]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.074]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.074]                       info)
  [15:45:55.074]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.074]                     if (!has_future) {
  [15:45:55.074]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.074]                         info)
  [15:45:55.074]                     }
  [15:45:55.074]                     else {
  [15:45:55.074]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.074]                         info, version)
  [15:45:55.074]                     }
  [15:45:55.074]                     base::stop(msg)
  [15:45:55.074]                   }
  [15:45:55.074]                 })
  [15:45:55.074]             }
  [15:45:55.074]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.074]         }
  [15:45:55.074]     }
  [15:45:55.074]     if (base::is.na(TRUE)) {
  [15:45:55.074]     }
  [15:45:55.074]     else {
  [15:45:55.074]         if (TRUE) {
  [15:45:55.074]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.074]                 open = "w")
  [15:45:55.074]         }
  [15:45:55.074]         else {
  [15:45:55.074]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.074]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.074]         }
  [15:45:55.074]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.074]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.074]             base::sink(type = "output", split = FALSE)
  [15:45:55.074]             base::close(...future.stdout)
  [15:45:55.074]         }, add = TRUE)
  [15:45:55.074]     }
  [15:45:55.074]     ...future.frame <- base::sys.nframe()
  [15:45:55.074]     ...future.conditions <- base::list()
  [15:45:55.074]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.074]     ...future.result <- base::tryCatch({
  [15:45:55.074]         base::withCallingHandlers({
  [15:45:55.074]             ...future.value <- base::withVisible(base::local({
  [15:45:55.074]                 ...future.sendCondition <- local({
  [15:45:55.074]                   sendCondition <- NULL
  [15:45:55.074]                   function(frame = 1L) {
  [15:45:55.074]                     if (is.function(sendCondition)) 
  [15:45:55.074]                       return(sendCondition)
  [15:45:55.074]                     ns <- getNamespace("parallel")
  [15:45:55.074]                     if (exists("sendData", mode = "function", 
  [15:45:55.074]                       envir = ns)) {
  [15:45:55.074]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:55.074]                         envir = ns)
  [15:45:55.074]                       envir <- sys.frame(frame)
  [15:45:55.074]                       master <- NULL
  [15:45:55.074]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:55.074]                         !identical(envir, emptyenv())) {
  [15:45:55.074]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:55.074]                           inherits = FALSE)) {
  [15:45:55.074]                           master <- get("master", mode = "list", 
  [15:45:55.074]                             envir = envir, inherits = FALSE)
  [15:45:55.074]                           if (inherits(master, "SOCKnode")) {
  [15:45:55.074]                             sendCondition <<- function(cond) {
  [15:45:55.074]                               data <- list(type = "VALUE", value = cond, 
  [15:45:55.074]                                 success = TRUE)
  [15:45:55.074]                               parallel_sendData(master, data)
  [15:45:55.074]                             }
  [15:45:55.074]                             return(sendCondition)
  [15:45:55.074]                           }
  [15:45:55.074]                         }
  [15:45:55.074]                         frame <- frame + 1L
  [15:45:55.074]                         envir <- sys.frame(frame)
  [15:45:55.074]                       }
  [15:45:55.074]                     }
  [15:45:55.074]                     sendCondition <<- function(cond) NULL
  [15:45:55.074]                   }
  [15:45:55.074]                 })
  [15:45:55.074]                 withCallingHandlers({
  [15:45:55.074]                   2
  [15:45:55.074]                 }, immediateCondition = function(cond) {
  [15:45:55.074]                   sendCondition <- ...future.sendCondition()
  [15:45:55.074]                   sendCondition(cond)
  [15:45:55.074]                   muffleCondition <- function (cond) 
  [15:45:55.074]                   {
  [15:45:55.074]                     inherits <- base::inherits
  [15:45:55.074]                     invokeRestart <- base::invokeRestart
  [15:45:55.074]                     muffled <- FALSE
  [15:45:55.074]                     if (inherits(cond, "message")) {
  [15:45:55.074]                       invokeRestart("muffleMessage")
  [15:45:55.074]                       muffled <- TRUE
  [15:45:55.074]                     }
  [15:45:55.074]                     else if (inherits(cond, "warning")) {
  [15:45:55.074]                       invokeRestart("muffleWarning")
  [15:45:55.074]                       muffled <- TRUE
  [15:45:55.074]                     }
  [15:45:55.074]                     else if (inherits(cond, "condition")) {
  [15:45:55.074]                       computeRestarts <- base::computeRestarts
  [15:45:55.074]                       grepl <- base::grepl
  [15:45:55.074]                       is.null <- base::is.null
  [15:45:55.074]                       restarts <- computeRestarts(cond)
  [15:45:55.074]                       for (restart in restarts) {
  [15:45:55.074]                         name <- restart$name
  [15:45:55.074]                         if (is.null(name)) 
  [15:45:55.074]                           next
  [15:45:55.074]                         if (!grepl("^muffle", name)) 
  [15:45:55.074]                           next
  [15:45:55.074]                         invokeRestart(restart)
  [15:45:55.074]                         muffled <- TRUE
  [15:45:55.074]                         break
  [15:45:55.074]                       }
  [15:45:55.074]                     }
  [15:45:55.074]                     invisible(muffled)
  [15:45:55.074]                   }
  [15:45:55.074]                   muffleCondition(cond)
  [15:45:55.074]                 })
  [15:45:55.074]             }))
  [15:45:55.074]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.074]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.074]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.074]                 version = "1.8")
  [15:45:55.074]         }, condition = base::local({
  [15:45:55.074]             c <- base::c
  [15:45:55.074]             inherits <- base::inherits
  [15:45:55.074]             invokeRestart <- base::invokeRestart
  [15:45:55.074]             length <- base::length
  [15:45:55.074]             list <- base::list
  [15:45:55.074]             seq.int <- base::seq.int
  [15:45:55.074]             signalCondition <- base::signalCondition
  [15:45:55.074]             sys.calls <- base::sys.calls
  [15:45:55.074]             Sys.time <- base::Sys.time
  [15:45:55.074]             `[[` <- base::`[[`
  [15:45:55.074]             `+` <- base::`+`
  [15:45:55.074]             `<<-` <- base::`<<-`
  [15:45:55.074]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.074]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.074]                   3L)]
  [15:45:55.074]             }
  [15:45:55.074]             function(cond) {
  [15:45:55.074]                 if (inherits(cond, "error")) {
  [15:45:55.074]                   sessionInformation <- function() {
  [15:45:55.074]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.074]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.074]                       search = base::search(), system = base::Sys.info())
  [15:45:55.074]                   }
  [15:45:55.074]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.074]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.074]                     cond$call), session = sessionInformation(), 
  [15:45:55.074]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.074]                   signalCondition(cond)
  [15:45:55.074]                 }
  [15:45:55.074]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.074]                 ))) {
  [15:45:55.074]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.074]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.074]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.074]                   if (!signal) {
  [15:45:55.074]                     muffleCondition <- function (cond) 
  [15:45:55.074]                     {
  [15:45:55.074]                       inherits <- base::inherits
  [15:45:55.074]                       invokeRestart <- base::invokeRestart
  [15:45:55.074]                       muffled <- FALSE
  [15:45:55.074]                       if (inherits(cond, "message")) {
  [15:45:55.074]                         invokeRestart("muffleMessage")
  [15:45:55.074]                         muffled <- TRUE
  [15:45:55.074]                       }
  [15:45:55.074]                       else if (inherits(cond, "warning")) {
  [15:45:55.074]                         invokeRestart("muffleWarning")
  [15:45:55.074]                         muffled <- TRUE
  [15:45:55.074]                       }
  [15:45:55.074]                       else if (inherits(cond, "condition")) {
  [15:45:55.074]                         computeRestarts <- base::computeRestarts
  [15:45:55.074]                         grepl <- base::grepl
  [15:45:55.074]                         is.null <- base::is.null
  [15:45:55.074]                         restarts <- computeRestarts(cond)
  [15:45:55.074]                         for (restart in restarts) {
  [15:45:55.074]                           name <- restart$name
  [15:45:55.074]                           if (is.null(name)) 
  [15:45:55.074]                             next
  [15:45:55.074]                           if (!grepl("^muffle", name)) 
  [15:45:55.074]                             next
  [15:45:55.074]                           invokeRestart(restart)
  [15:45:55.074]                           muffled <- TRUE
  [15:45:55.074]                           break
  [15:45:55.074]                         }
  [15:45:55.074]                       }
  [15:45:55.074]                       invisible(muffled)
  [15:45:55.074]                     }
  [15:45:55.074]                     muffleCondition(cond)
  [15:45:55.074]                   }
  [15:45:55.074]                 }
  [15:45:55.074]             }
  [15:45:55.074]         }))
  [15:45:55.074]     }, error = function(ex) {
  [15:45:55.074]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.074]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.074]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.074]     }, finally = {
  [15:45:55.074]         {
  [15:45:55.074]             NULL
  [15:45:55.074]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.074]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.074]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:55.074]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:55.074]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:55.074]                 ...) 
  [15:45:55.074]             {
  [15:45:55.074]                 if (substitute) 
  [15:45:55.074]                   expr <- substitute(expr)
  [15:45:55.074]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:55.074]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.074]                   globals = globals, persistent = persistent, 
  [15:45:55.074]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:55.074]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:55.074]                   label = label, ...)
  [15:45:55.074]                 if (!future$lazy) 
  [15:45:55.074]                   future <- run(future)
  [15:45:55.074]                 invisible(future)
  [15:45:55.074]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.074]         }
  [15:45:55.074]         base::options(...future.oldOptions)
  [15:45:55.074]     })
  [15:45:55.074]     Sys.time
  [15:45:55.074]     if (base::is.na(TRUE)) {
  [15:45:55.074]     }
  [15:45:55.074]     else {
  [15:45:55.074]         base::sink(type = "output", split = FALSE)
  [15:45:55.074]         if (TRUE) {
  [15:45:55.074]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.074]         }
  [15:45:55.074]         else {
  [15:45:55.074]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.074]         }
  [15:45:55.074]         base::close(...future.stdout)
  [15:45:55.074]         ...future.stdout <- NULL
  [15:45:55.074]     }
  [15:45:55.074]     ...future.result$conditions <- ...future.conditions
  [15:45:55.074]     ...future.result
  [15:45:55.074] }
  [15:45:55.088] ClusterFuture started
  [15:45:55.089] getGlobalsAndPackages() ...
  [15:45:55.089] Searching for globals...
  [15:45:55.090] 
  [15:45:55.091] Searching for globals ... DONE
  [15:45:55.091] - globals: [0] <none>
  [15:45:55.091] getGlobalsAndPackages() ... DONE
  [15:45:55.098] Packages needed by the future expression (n = 0): <none>
  [15:45:55.098] Packages needed by future strategies (n = 0): <none>
  [15:45:55.118] {
  [15:45:55.118]     {
  [15:45:55.118]         ...future.startTime <- base::Sys.time()
  [15:45:55.118]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.118]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.118]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.118]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.118]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.118]         {
  [15:45:55.118]             {
  [15:45:55.118]                 base::local({
  [15:45:55.118]                   has_future <- base::requireNamespace("future", 
  [15:45:55.118]                     quietly = TRUE)
  [15:45:55.118]                   version <- if (has_future) 
  [15:45:55.118]                     utils::packageVersion("future")
  [15:45:55.118]                   else NULL
  [15:45:55.118]                   if (!has_future || version < "1.8.0") {
  [15:45:55.118]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.118]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.118]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.118]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.118]                         "release", "version")], collapse = " "), 
  [15:45:55.118]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.118]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.118]                       info)
  [15:45:55.118]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.118]                     if (!has_future) {
  [15:45:55.118]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.118]                         info)
  [15:45:55.118]                     }
  [15:45:55.118]                     else {
  [15:45:55.118]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.118]                         info, version)
  [15:45:55.118]                     }
  [15:45:55.118]                     base::stop(msg)
  [15:45:55.118]                   }
  [15:45:55.118]                 })
  [15:45:55.118]             }
  [15:45:55.118]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.118]         }
  [15:45:55.118]     }
  [15:45:55.118]     if (base::is.na(TRUE)) {
  [15:45:55.118]     }
  [15:45:55.118]     else {
  [15:45:55.118]         if (TRUE) {
  [15:45:55.118]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.118]                 open = "w")
  [15:45:55.118]         }
  [15:45:55.118]         else {
  [15:45:55.118]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.118]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.118]         }
  [15:45:55.118]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.118]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.118]             base::sink(type = "output", split = FALSE)
  [15:45:55.118]             base::close(...future.stdout)
  [15:45:55.118]         }, add = TRUE)
  [15:45:55.118]     }
  [15:45:55.118]     ...future.frame <- base::sys.nframe()
  [15:45:55.118]     ...future.conditions <- base::list()
  [15:45:55.118]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.118]     ...future.result <- base::tryCatch({
  [15:45:55.118]         base::withCallingHandlers({
  [15:45:55.118]             ...future.value <- base::withVisible(base::local({
  [15:45:55.118]                 ...future.sendCondition <- local({
  [15:45:55.118]                   sendCondition <- NULL
  [15:45:55.118]                   function(frame = 1L) {
  [15:45:55.118]                     if (is.function(sendCondition)) 
  [15:45:55.118]                       return(sendCondition)
  [15:45:55.118]                     ns <- getNamespace("parallel")
  [15:45:55.118]                     if (exists("sendData", mode = "function", 
  [15:45:55.118]                       envir = ns)) {
  [15:45:55.118]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:55.118]                         envir = ns)
  [15:45:55.118]                       envir <- sys.frame(frame)
  [15:45:55.118]                       master <- NULL
  [15:45:55.118]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:55.118]                         !identical(envir, emptyenv())) {
  [15:45:55.118]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:55.118]                           inherits = FALSE)) {
  [15:45:55.118]                           master <- get("master", mode = "list", 
  [15:45:55.118]                             envir = envir, inherits = FALSE)
  [15:45:55.118]                           if (inherits(master, "SOCKnode")) {
  [15:45:55.118]                             sendCondition <<- function(cond) {
  [15:45:55.118]                               data <- list(type = "VALUE", value = cond, 
  [15:45:55.118]                                 success = TRUE)
  [15:45:55.118]                               parallel_sendData(master, data)
  [15:45:55.118]                             }
  [15:45:55.118]                             return(sendCondition)
  [15:45:55.118]                           }
  [15:45:55.118]                         }
  [15:45:55.118]                         frame <- frame + 1L
  [15:45:55.118]                         envir <- sys.frame(frame)
  [15:45:55.118]                       }
  [15:45:55.118]                     }
  [15:45:55.118]                     sendCondition <<- function(cond) NULL
  [15:45:55.118]                   }
  [15:45:55.118]                 })
  [15:45:55.118]                 withCallingHandlers({
  [15:45:55.118]                   NULL
  [15:45:55.118]                 }, immediateCondition = function(cond) {
  [15:45:55.118]                   sendCondition <- ...future.sendCondition()
  [15:45:55.118]                   sendCondition(cond)
  [15:45:55.118]                   muffleCondition <- function (cond) 
  [15:45:55.118]                   {
  [15:45:55.118]                     inherits <- base::inherits
  [15:45:55.118]                     invokeRestart <- base::invokeRestart
  [15:45:55.118]                     muffled <- FALSE
  [15:45:55.118]                     if (inherits(cond, "message")) {
  [15:45:55.118]                       invokeRestart("muffleMessage")
  [15:45:55.118]                       muffled <- TRUE
  [15:45:55.118]                     }
  [15:45:55.118]                     else if (inherits(cond, "warning")) {
  [15:45:55.118]                       invokeRestart("muffleWarning")
  [15:45:55.118]                       muffled <- TRUE
  [15:45:55.118]                     }
  [15:45:55.118]                     else if (inherits(cond, "condition")) {
  [15:45:55.118]                       computeRestarts <- base::computeRestarts
  [15:45:55.118]                       grepl <- base::grepl
  [15:45:55.118]                       is.null <- base::is.null
  [15:45:55.118]                       restarts <- computeRestarts(cond)
  [15:45:55.118]                       for (restart in restarts) {
  [15:45:55.118]                         name <- restart$name
  [15:45:55.118]                         if (is.null(name)) 
  [15:45:55.118]                           next
  [15:45:55.118]                         if (!grepl("^muffle", name)) 
  [15:45:55.118]                           next
  [15:45:55.118]                         invokeRestart(restart)
  [15:45:55.118]                         muffled <- TRUE
  [15:45:55.118]                         break
  [15:45:55.118]                       }
  [15:45:55.118]                     }
  [15:45:55.118]                     invisible(muffled)
  [15:45:55.118]                   }
  [15:45:55.118]                   muffleCondition(cond)
  [15:45:55.118]                 })
  [15:45:55.118]             }))
  [15:45:55.118]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.118]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.118]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.118]                 version = "1.8")
  [15:45:55.118]         }, condition = base::local({
  [15:45:55.118]             c <- base::c
  [15:45:55.118]             inherits <- base::inherits
  [15:45:55.118]             invokeRestart <- base::invokeRestart
  [15:45:55.118]             length <- base::length
  [15:45:55.118]             list <- base::list
  [15:45:55.118]             seq.int <- base::seq.int
  [15:45:55.118]             signalCondition <- base::signalCondition
  [15:45:55.118]             sys.calls <- base::sys.calls
  [15:45:55.118]             Sys.time <- base::Sys.time
  [15:45:55.118]             `[[` <- base::`[[`
  [15:45:55.118]             `+` <- base::`+`
  [15:45:55.118]             `<<-` <- base::`<<-`
  [15:45:55.118]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.118]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.118]                   3L)]
  [15:45:55.118]             }
  [15:45:55.118]             function(cond) {
  [15:45:55.118]                 if (inherits(cond, "error")) {
  [15:45:55.118]                   sessionInformation <- function() {
  [15:45:55.118]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.118]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.118]                       search = base::search(), system = base::Sys.info())
  [15:45:55.118]                   }
  [15:45:55.118]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.118]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.118]                     cond$call), session = sessionInformation(), 
  [15:45:55.118]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.118]                   signalCondition(cond)
  [15:45:55.118]                 }
  [15:45:55.118]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.118]                 ))) {
  [15:45:55.118]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.118]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.118]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.118]                   if (!signal) {
  [15:45:55.118]                     muffleCondition <- function (cond) 
  [15:45:55.118]                     {
  [15:45:55.118]                       inherits <- base::inherits
  [15:45:55.118]                       invokeRestart <- base::invokeRestart
  [15:45:55.118]                       muffled <- FALSE
  [15:45:55.118]                       if (inherits(cond, "message")) {
  [15:45:55.118]                         invokeRestart("muffleMessage")
  [15:45:55.118]                         muffled <- TRUE
  [15:45:55.118]                       }
  [15:45:55.118]                       else if (inherits(cond, "warning")) {
  [15:45:55.118]                         invokeRestart("muffleWarning")
  [15:45:55.118]                         muffled <- TRUE
  [15:45:55.118]                       }
  [15:45:55.118]                       else if (inherits(cond, "condition")) {
  [15:45:55.118]                         computeRestarts <- base::computeRestarts
  [15:45:55.118]                         grepl <- base::grepl
  [15:45:55.118]                         is.null <- base::is.null
  [15:45:55.118]                         restarts <- computeRestarts(cond)
  [15:45:55.118]                         for (restart in restarts) {
  [15:45:55.118]                           name <- restart$name
  [15:45:55.118]                           if (is.null(name)) 
  [15:45:55.118]                             next
  [15:45:55.118]                           if (!grepl("^muffle", name)) 
  [15:45:55.118]                             next
  [15:45:55.118]                           invokeRestart(restart)
  [15:45:55.118]                           muffled <- TRUE
  [15:45:55.118]                           break
  [15:45:55.118]                         }
  [15:45:55.118]                       }
  [15:45:55.118]                       invisible(muffled)
  [15:45:55.118]                     }
  [15:45:55.118]                     muffleCondition(cond)
  [15:45:55.118]                   }
  [15:45:55.118]                 }
  [15:45:55.118]             }
  [15:45:55.118]         }))
  [15:45:55.118]     }, error = function(ex) {
  [15:45:55.118]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.118]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.118]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.118]     }, finally = {
  [15:45:55.118]         {
  [15:45:55.118]             NULL
  [15:45:55.118]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.118]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.118]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:55.118]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:55.118]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:55.118]                 ...) 
  [15:45:55.118]             {
  [15:45:55.118]                 if (substitute) 
  [15:45:55.118]                   expr <- substitute(expr)
  [15:45:55.118]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:55.118]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.118]                   globals = globals, persistent = persistent, 
  [15:45:55.118]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:55.118]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:55.118]                   label = label, ...)
  [15:45:55.118]                 if (!future$lazy) 
  [15:45:55.118]                   future <- run(future)
  [15:45:55.118]                 invisible(future)
  [15:45:55.118]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.118]         }
  [15:45:55.118]         base::options(...future.oldOptions)
  [15:45:55.118]     })
  [15:45:55.118]     Sys.time
  [15:45:55.118]     if (base::is.na(TRUE)) {
  [15:45:55.118]     }
  [15:45:55.118]     else {
  [15:45:55.118]         base::sink(type = "output", split = FALSE)
  [15:45:55.118]         if (TRUE) {
  [15:45:55.118]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.118]         }
  [15:45:55.118]         else {
  [15:45:55.118]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.118]         }
  [15:45:55.118]         base::close(...future.stdout)
  [15:45:55.118]         ...future.stdout <- NULL
  [15:45:55.118]     }
  [15:45:55.118]     ...future.result$conditions <- ...future.conditions
  [15:45:55.118]     ...future.result
  [15:45:55.118] }
  [15:45:55.125] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:55.137] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:55.138] - Validating connection of ClusterFuture
  [15:45:55.138] - received message: FutureResult
  [15:45:55.139] - Received FutureResult
  [15:45:55.139] - Erased future from FutureRegistry
  [15:45:55.139] result() for ClusterFuture ...
  [15:45:55.140] - result already collected: FutureResult
  [15:45:55.140] result() for ClusterFuture ... done
  [15:45:55.141] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:55.141] result() for ClusterFuture ...
  [15:45:55.141] - result already collected: FutureResult
  [15:45:55.142] result() for ClusterFuture ... done
  [15:45:55.142] result() for ClusterFuture ...
  [15:45:55.143] - result already collected: FutureResult
  [15:45:55.143] result() for ClusterFuture ... done
  [15:45:55.155] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a8aeae0> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2abea168> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a8aeae0> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2abea168> 
   $  : 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"
  [15:45:55.208] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:55.208] - Validating connection of ClusterFuture
  [15:45:55.209] - received message: FutureResult
  [15:45:55.209] - Received FutureResult
  [15:45:55.210] - Erased future from FutureRegistry
  [15:45:55.210] result() for ClusterFuture ...
  [15:45:55.210] - result already collected: FutureResult
  [15:45:55.211] result() for ClusterFuture ... done
  [15:45:55.211] 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" "" ...
  [15:45:55.218] resolve() on list ...
  [15:45:55.219]  recursive: 0
  [15:45:55.219]  length: 6
  [15:45:55.219]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:55.220] signalConditionsASAP(numeric, pos=1) ...
  [15:45:55.220] - nx: 6
  [15:45:55.221] - relay: TRUE
  [15:45:55.221] - stdout: TRUE
  [15:45:55.221] - signal: TRUE
  [15:45:55.221] - resignal: FALSE
  [15:45:55.222] - force: TRUE
  [15:45:55.222] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.223] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.223]  - until=2
  [15:45:55.223]  - relaying element #2
  [15:45:55.224] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.224] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.224] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:55.225]  length: 5 (resolved future 1)
  [15:45:55.225] Future #2
  [15:45:55.226] result() for ClusterFuture ...
  [15:45:55.226] - result already collected: FutureResult
  [15:45:55.226] result() for ClusterFuture ... done
  [15:45:55.227] result() for ClusterFuture ...
  [15:45:55.227] - result already collected: FutureResult
  [15:45:55.227] result() for ClusterFuture ... done
  [15:45:55.228] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:55.228] - nx: 6
  [15:45:55.229] - relay: TRUE
  [15:45:55.229] - stdout: TRUE
  [15:45:55.229] - signal: TRUE
  [15:45:55.229] - resignal: FALSE
  [15:45:55.230] - force: TRUE
  [15:45:55.230] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.231] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.231]  - until=2
  [15:45:55.231]  - relaying element #2
  [15:45:55.232] result() for ClusterFuture ...
  [15:45:55.232] - result already collected: FutureResult
  [15:45:55.232] result() for ClusterFuture ... done
  [15:45:55.233] result() for ClusterFuture ...
  [15:45:55.233] - result already collected: FutureResult
  [15:45:55.233] result() for ClusterFuture ... done
  [15:45:55.234] result() for ClusterFuture ...
  [15:45:55.250] - result already collected: FutureResult
  [15:45:55.251] result() for ClusterFuture ... done
  [15:45:55.251] result() for ClusterFuture ...
  [15:45:55.252] - result already collected: FutureResult
  [15:45:55.252] result() for ClusterFuture ... done
  [15:45:55.252] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.253] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.253] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:55.254]  length: 4 (resolved future 2)
  [15:45:55.254] Future #3
  [15:45:55.254] result() for ClusterFuture ...
  [15:45:55.255] - result already collected: FutureResult
  [15:45:55.255] result() for ClusterFuture ... done
  [15:45:55.255] result() for ClusterFuture ...
  [15:45:55.256] - result already collected: FutureResult
  [15:45:55.256] result() for ClusterFuture ... done
  [15:45:55.257] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:55.257] - nx: 6
  [15:45:55.257] - relay: TRUE
  [15:45:55.258] - stdout: TRUE
  [15:45:55.258] - signal: TRUE
  [15:45:55.258] - resignal: FALSE
  [15:45:55.259] - force: TRUE
  [15:45:55.259] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.259] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.260]  - until=3
  [15:45:55.260]  - relaying element #3
  [15:45:55.260] result() for ClusterFuture ...
  [15:45:55.261] - result already collected: FutureResult
  [15:45:55.261] result() for ClusterFuture ... done
  [15:45:55.261] result() for ClusterFuture ...
  [15:45:55.262] - result already collected: FutureResult
  [15:45:55.262] result() for ClusterFuture ... done
  [15:45:55.263] result() for ClusterFuture ...
  [15:45:55.263] - result already collected: FutureResult
  [15:45:55.263] result() for ClusterFuture ... done
  [15:45:55.264] result() for ClusterFuture ...
  [15:45:55.264] - result already collected: FutureResult
  [15:45:55.264] result() for ClusterFuture ... done
  [15:45:55.265] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.265] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.266] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:55.266]  length: 3 (resolved future 3)
  [15:45:55.266] signalConditionsASAP(NULL, pos=4) ...
  [15:45:55.283] - nx: 6
  [15:45:55.283] - relay: TRUE
  [15:45:55.283] - stdout: TRUE
  [15:45:55.284] - signal: TRUE
  [15:45:55.284] - resignal: FALSE
  [15:45:55.284] - force: TRUE
  [15:45:55.285] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.285] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.286]  - until=5
  [15:45:55.289]  - relaying element #5
  [15:45:55.290] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:55.290] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.290] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:55.291]  length: 2 (resolved future 4)
  [15:45:55.291] signalConditionsASAP(NULL, pos=5) ...
  [15:45:55.291] - nx: 6
  [15:45:55.292] - relay: TRUE
  [15:45:55.292] - stdout: TRUE
  [15:45:55.292] - signal: TRUE
  [15:45:55.293] - resignal: FALSE
  [15:45:55.293] - force: TRUE
  [15:45:55.293] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:55.294] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.294]  - until=6
  [15:45:55.294]  - relaying element #6
  [15:45:55.295] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:55.295] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.296] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:55.296]  length: 1 (resolved future 5)
  [15:45:55.296] signalConditionsASAP(numeric, pos=6) ...
  [15:45:55.297] - nx: 6
  [15:45:55.297] - relay: TRUE
  [15:45:55.297] - stdout: TRUE
  [15:45:55.297] - signal: TRUE
  [15:45:55.298] - resignal: FALSE
  [15:45:55.298] - force: TRUE
  [15:45:55.315] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:55.315] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.315]  - until=6
  [15:45:55.316] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.316] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.317] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:55.317]  length: 0 (resolved future 6)
  [15:45:55.317] Relaying remaining futures
  [15:45:55.318] signalConditionsASAP(NULL, pos=0) ...
  [15:45:55.318] - nx: 6
  [15:45:55.318] - relay: TRUE
  [15:45:55.319] - stdout: TRUE
  [15:45:55.319] - signal: TRUE
  [15:45:55.319] - resignal: FALSE
  [15:45:55.319] - force: TRUE
  [15:45:55.320] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.320] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:55.321] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.321] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.322] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:55.322] resolve() on list ... DONE
  [15:45:55.322] result() for ClusterFuture ...
  [15:45:55.323] - result already collected: FutureResult
  [15:45:55.323] result() for ClusterFuture ... done
  [15:45:55.323] result() for ClusterFuture ...
  [15:45:55.324] - result already collected: FutureResult
  [15:45:55.324] result() for ClusterFuture ... done
  [15:45:55.324] result() for ClusterFuture ...
  [15:45:55.325] - result already collected: FutureResult
  [15:45:55.325] result() for ClusterFuture ... done
  [15:45:55.325] result() for ClusterFuture ...
  [15:45:55.326] - result already collected: FutureResult
  [15:45:55.326] 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)
  [15:45:55.357] getGlobalsAndPackages() ...
  [15:45:55.357] Searching for globals...
  [15:45:55.358] 
  [15:45:55.359] Searching for globals ... DONE
  [15:45:55.359] - globals: [0] <none>
  [15:45:55.359] getGlobalsAndPackages() ... DONE
  [15:45:55.381] Packages needed by the future expression (n = 0): <none>
  [15:45:55.382] Packages needed by future strategies (n = 0): <none>
  [15:45:55.388] {
  [15:45:55.388]     {
  [15:45:55.388]         ...future.startTime <- base::Sys.time()
  [15:45:55.388]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.388]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.388]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.388]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.388]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.388]         {
  [15:45:55.388]             {
  [15:45:55.388]                 base::local({
  [15:45:55.388]                   has_future <- base::requireNamespace("future", 
  [15:45:55.388]                     quietly = TRUE)
  [15:45:55.388]                   version <- if (has_future) 
  [15:45:55.388]                     utils::packageVersion("future")
  [15:45:55.388]                   else NULL
  [15:45:55.388]                   if (!has_future || version < "1.8.0") {
  [15:45:55.388]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.388]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.388]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.388]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.388]                         "release", "version")], collapse = " "), 
  [15:45:55.388]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.388]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.388]                       info)
  [15:45:55.388]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.388]                     if (!has_future) {
  [15:45:55.388]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.388]                         info)
  [15:45:55.388]                     }
  [15:45:55.388]                     else {
  [15:45:55.388]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.388]                         info, version)
  [15:45:55.388]                     }
  [15:45:55.388]                     base::stop(msg)
  [15:45:55.388]                   }
  [15:45:55.388]                 })
  [15:45:55.388]             }
  [15:45:55.388]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.388]         }
  [15:45:55.388]     }
  [15:45:55.388]     if (base::is.na(TRUE)) {
  [15:45:55.388]     }
  [15:45:55.388]     else {
  [15:45:55.388]         if (TRUE) {
  [15:45:55.388]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.388]                 open = "w")
  [15:45:55.388]         }
  [15:45:55.388]         else {
  [15:45:55.388]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.388]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.388]         }
  [15:45:55.388]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.388]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.388]             base::sink(type = "output", split = FALSE)
  [15:45:55.388]             base::close(...future.stdout)
  [15:45:55.388]         }, add = TRUE)
  [15:45:55.388]     }
  [15:45:55.388]     ...future.frame <- base::sys.nframe()
  [15:45:55.388]     ...future.conditions <- base::list()
  [15:45:55.388]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.388]     ...future.result <- base::tryCatch({
  [15:45:55.388]         base::withCallingHandlers({
  [15:45:55.388]             ...future.value <- base::withVisible(base::local({
  [15:45:55.388]                 ...future.sendCondition <- local({
  [15:45:55.388]                   sendCondition <- NULL
  [15:45:55.388]                   function(frame = 1L) {
  [15:45:55.388]                     if (is.function(sendCondition)) 
  [15:45:55.388]                       return(sendCondition)
  [15:45:55.388]                     ns <- getNamespace("parallel")
  [15:45:55.388]                     if (exists("sendData", mode = "function", 
  [15:45:55.388]                       envir = ns)) {
  [15:45:55.388]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:55.388]                         envir = ns)
  [15:45:55.388]                       envir <- sys.frame(frame)
  [15:45:55.388]                       master <- NULL
  [15:45:55.388]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:55.388]                         !identical(envir, emptyenv())) {
  [15:45:55.388]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:55.388]                           inherits = FALSE)) {
  [15:45:55.388]                           master <- get("master", mode = "list", 
  [15:45:55.388]                             envir = envir, inherits = FALSE)
  [15:45:55.388]                           if (inherits(master, "SOCKnode")) {
  [15:45:55.388]                             sendCondition <<- function(cond) {
  [15:45:55.388]                               data <- list(type = "VALUE", value = cond, 
  [15:45:55.388]                                 success = TRUE)
  [15:45:55.388]                               parallel_sendData(master, data)
  [15:45:55.388]                             }
  [15:45:55.388]                             return(sendCondition)
  [15:45:55.388]                           }
  [15:45:55.388]                         }
  [15:45:55.388]                         frame <- frame + 1L
  [15:45:55.388]                         envir <- sys.frame(frame)
  [15:45:55.388]                       }
  [15:45:55.388]                     }
  [15:45:55.388]                     sendCondition <<- function(cond) NULL
  [15:45:55.388]                   }
  [15:45:55.388]                 })
  [15:45:55.388]                 withCallingHandlers({
  [15:45:55.388]                   2
  [15:45:55.388]                 }, immediateCondition = function(cond) {
  [15:45:55.388]                   sendCondition <- ...future.sendCondition()
  [15:45:55.388]                   sendCondition(cond)
  [15:45:55.388]                   muffleCondition <- function (cond) 
  [15:45:55.388]                   {
  [15:45:55.388]                     inherits <- base::inherits
  [15:45:55.388]                     invokeRestart <- base::invokeRestart
  [15:45:55.388]                     muffled <- FALSE
  [15:45:55.388]                     if (inherits(cond, "message")) {
  [15:45:55.388]                       invokeRestart("muffleMessage")
  [15:45:55.388]                       muffled <- TRUE
  [15:45:55.388]                     }
  [15:45:55.388]                     else if (inherits(cond, "warning")) {
  [15:45:55.388]                       invokeRestart("muffleWarning")
  [15:45:55.388]                       muffled <- TRUE
  [15:45:55.388]                     }
  [15:45:55.388]                     else if (inherits(cond, "condition")) {
  [15:45:55.388]                       computeRestarts <- base::computeRestarts
  [15:45:55.388]                       grepl <- base::grepl
  [15:45:55.388]                       is.null <- base::is.null
  [15:45:55.388]                       restarts <- computeRestarts(cond)
  [15:45:55.388]                       for (restart in restarts) {
  [15:45:55.388]                         name <- restart$name
  [15:45:55.388]                         if (is.null(name)) 
  [15:45:55.388]                           next
  [15:45:55.388]                         if (!grepl("^muffle", name)) 
  [15:45:55.388]                           next
  [15:45:55.388]                         invokeRestart(restart)
  [15:45:55.388]                         muffled <- TRUE
  [15:45:55.388]                         break
  [15:45:55.388]                       }
  [15:45:55.388]                     }
  [15:45:55.388]                     invisible(muffled)
  [15:45:55.388]                   }
  [15:45:55.388]                   muffleCondition(cond)
  [15:45:55.388]                 })
  [15:45:55.388]             }))
  [15:45:55.388]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.388]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.388]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.388]                 version = "1.8")
  [15:45:55.388]         }, condition = base::local({
  [15:45:55.388]             c <- base::c
  [15:45:55.388]             inherits <- base::inherits
  [15:45:55.388]             invokeRestart <- base::invokeRestart
  [15:45:55.388]             length <- base::length
  [15:45:55.388]             list <- base::list
  [15:45:55.388]             seq.int <- base::seq.int
  [15:45:55.388]             signalCondition <- base::signalCondition
  [15:45:55.388]             sys.calls <- base::sys.calls
  [15:45:55.388]             Sys.time <- base::Sys.time
  [15:45:55.388]             `[[` <- base::`[[`
  [15:45:55.388]             `+` <- base::`+`
  [15:45:55.388]             `<<-` <- base::`<<-`
  [15:45:55.388]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.388]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.388]                   3L)]
  [15:45:55.388]             }
  [15:45:55.388]             function(cond) {
  [15:45:55.388]                 if (inherits(cond, "error")) {
  [15:45:55.388]                   sessionInformation <- function() {
  [15:45:55.388]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.388]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.388]                       search = base::search(), system = base::Sys.info())
  [15:45:55.388]                   }
  [15:45:55.388]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.388]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.388]                     cond$call), session = sessionInformation(), 
  [15:45:55.388]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.388]                   signalCondition(cond)
  [15:45:55.388]                 }
  [15:45:55.388]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.388]                 ))) {
  [15:45:55.388]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.388]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.388]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.388]                   if (!signal) {
  [15:45:55.388]                     muffleCondition <- function (cond) 
  [15:45:55.388]                     {
  [15:45:55.388]                       inherits <- base::inherits
  [15:45:55.388]                       invokeRestart <- base::invokeRestart
  [15:45:55.388]                       muffled <- FALSE
  [15:45:55.388]                       if (inherits(cond, "message")) {
  [15:45:55.388]                         invokeRestart("muffleMessage")
  [15:45:55.388]                         muffled <- TRUE
  [15:45:55.388]                       }
  [15:45:55.388]                       else if (inherits(cond, "warning")) {
  [15:45:55.388]                         invokeRestart("muffleWarning")
  [15:45:55.388]                         muffled <- TRUE
  [15:45:55.388]                       }
  [15:45:55.388]                       else if (inherits(cond, "condition")) {
  [15:45:55.388]                         computeRestarts <- base::computeRestarts
  [15:45:55.388]                         grepl <- base::grepl
  [15:45:55.388]                         is.null <- base::is.null
  [15:45:55.388]                         restarts <- computeRestarts(cond)
  [15:45:55.388]                         for (restart in restarts) {
  [15:45:55.388]                           name <- restart$name
  [15:45:55.388]                           if (is.null(name)) 
  [15:45:55.388]                             next
  [15:45:55.388]                           if (!grepl("^muffle", name)) 
  [15:45:55.388]                             next
  [15:45:55.388]                           invokeRestart(restart)
  [15:45:55.388]                           muffled <- TRUE
  [15:45:55.388]                           break
  [15:45:55.388]                         }
  [15:45:55.388]                       }
  [15:45:55.388]                       invisible(muffled)
  [15:45:55.388]                     }
  [15:45:55.388]                     muffleCondition(cond)
  [15:45:55.388]                   }
  [15:45:55.388]                 }
  [15:45:55.388]             }
  [15:45:55.388]         }))
  [15:45:55.388]     }, error = function(ex) {
  [15:45:55.388]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.388]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.388]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.388]     }, finally = {
  [15:45:55.388]         {
  [15:45:55.388]             NULL
  [15:45:55.388]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.388]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.388]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:55.388]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:55.388]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:55.388]                 ...) 
  [15:45:55.388]             {
  [15:45:55.388]                 if (substitute) 
  [15:45:55.388]                   expr <- substitute(expr)
  [15:45:55.388]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:55.388]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.388]                   globals = globals, persistent = persistent, 
  [15:45:55.388]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:55.388]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:55.388]                   label = label, ...)
  [15:45:55.388]                 if (!future$lazy) 
  [15:45:55.388]                   future <- run(future)
  [15:45:55.388]                 invisible(future)
  [15:45:55.388]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.388]         }
  [15:45:55.388]         base::options(...future.oldOptions)
  [15:45:55.388]     })
  [15:45:55.388]     Sys.time
  [15:45:55.388]     if (base::is.na(TRUE)) {
  [15:45:55.388]     }
  [15:45:55.388]     else {
  [15:45:55.388]         base::sink(type = "output", split = FALSE)
  [15:45:55.388]         if (TRUE) {
  [15:45:55.388]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.388]         }
  [15:45:55.388]         else {
  [15:45:55.388]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.388]         }
  [15:45:55.388]         base::close(...future.stdout)
  [15:45:55.388]         ...future.stdout <- NULL
  [15:45:55.388]     }
  [15:45:55.388]     ...future.result$conditions <- ...future.conditions
  [15:45:55.388]     ...future.result
  [15:45:55.388] }
  [15:45:55.411] ClusterFuture started
  [15:45:55.412] getGlobalsAndPackages() ...
  [15:45:55.412] Searching for globals...
  [15:45:55.413] 
  [15:45:55.413] Searching for globals ... DONE
  [15:45:55.414] - globals: [0] <none>
  [15:45:55.414] getGlobalsAndPackages() ... DONE
  [15:45:55.420] Packages needed by the future expression (n = 0): <none>
  [15:45:55.420] Packages needed by future strategies (n = 0): <none>
  [15:45:55.427] {
  [15:45:55.427]     {
  [15:45:55.427]         ...future.startTime <- base::Sys.time()
  [15:45:55.427]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.427]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.427]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.427]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.427]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.427]         {
  [15:45:55.427]             {
  [15:45:55.427]                 base::local({
  [15:45:55.427]                   has_future <- base::requireNamespace("future", 
  [15:45:55.427]                     quietly = TRUE)
  [15:45:55.427]                   version <- if (has_future) 
  [15:45:55.427]                     utils::packageVersion("future")
  [15:45:55.427]                   else NULL
  [15:45:55.427]                   if (!has_future || version < "1.8.0") {
  [15:45:55.427]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.427]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.427]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.427]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.427]                         "release", "version")], collapse = " "), 
  [15:45:55.427]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.427]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.427]                       info)
  [15:45:55.427]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.427]                     if (!has_future) {
  [15:45:55.427]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.427]                         info)
  [15:45:55.427]                     }
  [15:45:55.427]                     else {
  [15:45:55.427]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.427]                         info, version)
  [15:45:55.427]                     }
  [15:45:55.427]                     base::stop(msg)
  [15:45:55.427]                   }
  [15:45:55.427]                 })
  [15:45:55.427]             }
  [15:45:55.427]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.427]         }
  [15:45:55.427]     }
  [15:45:55.427]     if (base::is.na(TRUE)) {
  [15:45:55.427]     }
  [15:45:55.427]     else {
  [15:45:55.427]         if (TRUE) {
  [15:45:55.427]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.427]                 open = "w")
  [15:45:55.427]         }
  [15:45:55.427]         else {
  [15:45:55.427]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.427]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.427]         }
  [15:45:55.427]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.427]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.427]             base::sink(type = "output", split = FALSE)
  [15:45:55.427]             base::close(...future.stdout)
  [15:45:55.427]         }, add = TRUE)
  [15:45:55.427]     }
  [15:45:55.427]     ...future.frame <- base::sys.nframe()
  [15:45:55.427]     ...future.conditions <- base::list()
  [15:45:55.427]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.427]     ...future.result <- base::tryCatch({
  [15:45:55.427]         base::withCallingHandlers({
  [15:45:55.427]             ...future.value <- base::withVisible(base::local({
  [15:45:55.427]                 ...future.sendCondition <- local({
  [15:45:55.427]                   sendCondition <- NULL
  [15:45:55.427]                   function(frame = 1L) {
  [15:45:55.427]                     if (is.function(sendCondition)) 
  [15:45:55.427]                       return(sendCondition)
  [15:45:55.427]                     ns <- getNamespace("parallel")
  [15:45:55.427]                     if (exists("sendData", mode = "function", 
  [15:45:55.427]                       envir = ns)) {
  [15:45:55.427]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:55.427]                         envir = ns)
  [15:45:55.427]                       envir <- sys.frame(frame)
  [15:45:55.427]                       master <- NULL
  [15:45:55.427]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:55.427]                         !identical(envir, emptyenv())) {
  [15:45:55.427]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:55.427]                           inherits = FALSE)) {
  [15:45:55.427]                           master <- get("master", mode = "list", 
  [15:45:55.427]                             envir = envir, inherits = FALSE)
  [15:45:55.427]                           if (inherits(master, "SOCKnode")) {
  [15:45:55.427]                             sendCondition <<- function(cond) {
  [15:45:55.427]                               data <- list(type = "VALUE", value = cond, 
  [15:45:55.427]                                 success = TRUE)
  [15:45:55.427]                               parallel_sendData(master, data)
  [15:45:55.427]                             }
  [15:45:55.427]                             return(sendCondition)
  [15:45:55.427]                           }
  [15:45:55.427]                         }
  [15:45:55.427]                         frame <- frame + 1L
  [15:45:55.427]                         envir <- sys.frame(frame)
  [15:45:55.427]                       }
  [15:45:55.427]                     }
  [15:45:55.427]                     sendCondition <<- function(cond) NULL
  [15:45:55.427]                   }
  [15:45:55.427]                 })
  [15:45:55.427]                 withCallingHandlers({
  [15:45:55.427]                   NULL
  [15:45:55.427]                 }, immediateCondition = function(cond) {
  [15:45:55.427]                   sendCondition <- ...future.sendCondition()
  [15:45:55.427]                   sendCondition(cond)
  [15:45:55.427]                   muffleCondition <- function (cond) 
  [15:45:55.427]                   {
  [15:45:55.427]                     inherits <- base::inherits
  [15:45:55.427]                     invokeRestart <- base::invokeRestart
  [15:45:55.427]                     muffled <- FALSE
  [15:45:55.427]                     if (inherits(cond, "message")) {
  [15:45:55.427]                       invokeRestart("muffleMessage")
  [15:45:55.427]                       muffled <- TRUE
  [15:45:55.427]                     }
  [15:45:55.427]                     else if (inherits(cond, "warning")) {
  [15:45:55.427]                       invokeRestart("muffleWarning")
  [15:45:55.427]                       muffled <- TRUE
  [15:45:55.427]                     }
  [15:45:55.427]                     else if (inherits(cond, "condition")) {
  [15:45:55.427]                       computeRestarts <- base::computeRestarts
  [15:45:55.427]                       grepl <- base::grepl
  [15:45:55.427]                       is.null <- base::is.null
  [15:45:55.427]                       restarts <- computeRestarts(cond)
  [15:45:55.427]                       for (restart in restarts) {
  [15:45:55.427]                         name <- restart$name
  [15:45:55.427]                         if (is.null(name)) 
  [15:45:55.427]                           next
  [15:45:55.427]                         if (!grepl("^muffle", name)) 
  [15:45:55.427]                           next
  [15:45:55.427]                         invokeRestart(restart)
  [15:45:55.427]                         muffled <- TRUE
  [15:45:55.427]                         break
  [15:45:55.427]                       }
  [15:45:55.427]                     }
  [15:45:55.427]                     invisible(muffled)
  [15:45:55.427]                   }
  [15:45:55.427]                   muffleCondition(cond)
  [15:45:55.427]                 })
  [15:45:55.427]             }))
  [15:45:55.427]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.427]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.427]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.427]                 version = "1.8")
  [15:45:55.427]         }, condition = base::local({
  [15:45:55.427]             c <- base::c
  [15:45:55.427]             inherits <- base::inherits
  [15:45:55.427]             invokeRestart <- base::invokeRestart
  [15:45:55.427]             length <- base::length
  [15:45:55.427]             list <- base::list
  [15:45:55.427]             seq.int <- base::seq.int
  [15:45:55.427]             signalCondition <- base::signalCondition
  [15:45:55.427]             sys.calls <- base::sys.calls
  [15:45:55.427]             Sys.time <- base::Sys.time
  [15:45:55.427]             `[[` <- base::`[[`
  [15:45:55.427]             `+` <- base::`+`
  [15:45:55.427]             `<<-` <- base::`<<-`
  [15:45:55.427]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.427]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.427]                   3L)]
  [15:45:55.427]             }
  [15:45:55.427]             function(cond) {
  [15:45:55.427]                 if (inherits(cond, "error")) {
  [15:45:55.427]                   sessionInformation <- function() {
  [15:45:55.427]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.427]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.427]                       search = base::search(), system = base::Sys.info())
  [15:45:55.427]                   }
  [15:45:55.427]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.427]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.427]                     cond$call), session = sessionInformation(), 
  [15:45:55.427]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.427]                   signalCondition(cond)
  [15:45:55.427]                 }
  [15:45:55.427]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.427]                 ))) {
  [15:45:55.427]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.427]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.427]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.427]                   if (!signal) {
  [15:45:55.427]                     muffleCondition <- function (cond) 
  [15:45:55.427]                     {
  [15:45:55.427]                       inherits <- base::inherits
  [15:45:55.427]                       invokeRestart <- base::invokeRestart
  [15:45:55.427]                       muffled <- FALSE
  [15:45:55.427]                       if (inherits(cond, "message")) {
  [15:45:55.427]                         invokeRestart("muffleMessage")
  [15:45:55.427]                         muffled <- TRUE
  [15:45:55.427]                       }
  [15:45:55.427]                       else if (inherits(cond, "warning")) {
  [15:45:55.427]                         invokeRestart("muffleWarning")
  [15:45:55.427]                         muffled <- TRUE
  [15:45:55.427]                       }
  [15:45:55.427]                       else if (inherits(cond, "condition")) {
  [15:45:55.427]                         computeRestarts <- base::computeRestarts
  [15:45:55.427]                         grepl <- base::grepl
  [15:45:55.427]                         is.null <- base::is.null
  [15:45:55.427]                         restarts <- computeRestarts(cond)
  [15:45:55.427]                         for (restart in restarts) {
  [15:45:55.427]                           name <- restart$name
  [15:45:55.427]                           if (is.null(name)) 
  [15:45:55.427]                             next
  [15:45:55.427]                           if (!grepl("^muffle", name)) 
  [15:45:55.427]                             next
  [15:45:55.427]                           invokeRestart(restart)
  [15:45:55.427]                           muffled <- TRUE
  [15:45:55.427]                           break
  [15:45:55.427]                         }
  [15:45:55.427]                       }
  [15:45:55.427]                       invisible(muffled)
  [15:45:55.427]                     }
  [15:45:55.427]                     muffleCondition(cond)
  [15:45:55.427]                   }
  [15:45:55.427]                 }
  [15:45:55.427]             }
  [15:45:55.427]         }))
  [15:45:55.427]     }, error = function(ex) {
  [15:45:55.427]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.427]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.427]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.427]     }, finally = {
  [15:45:55.427]         {
  [15:45:55.427]             NULL
  [15:45:55.427]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.427]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.427]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:55.427]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:55.427]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:55.427]                 ...) 
  [15:45:55.427]             {
  [15:45:55.427]                 if (substitute) 
  [15:45:55.427]                   expr <- substitute(expr)
  [15:45:55.427]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:55.427]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.427]                   globals = globals, persistent = persistent, 
  [15:45:55.427]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:55.427]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:55.427]                   label = label, ...)
  [15:45:55.427]                 if (!future$lazy) 
  [15:45:55.427]                   future <- run(future)
  [15:45:55.427]                 invisible(future)
  [15:45:55.427]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.427]         }
  [15:45:55.427]         base::options(...future.oldOptions)
  [15:45:55.427]     })
  [15:45:55.427]     Sys.time
  [15:45:55.427]     if (base::is.na(TRUE)) {
  [15:45:55.427]     }
  [15:45:55.427]     else {
  [15:45:55.427]         base::sink(type = "output", split = FALSE)
  [15:45:55.427]         if (TRUE) {
  [15:45:55.427]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.427]         }
  [15:45:55.427]         else {
  [15:45:55.427]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.427]         }
  [15:45:55.427]         base::close(...future.stdout)
  [15:45:55.427]         ...future.stdout <- NULL
  [15:45:55.427]     }
  [15:45:55.427]     ...future.result$conditions <- ...future.conditions
  [15:45:55.427]     ...future.result
  [15:45:55.427] }
  [15:45:55.433] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:55.460] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:55.460] - Validating connection of ClusterFuture
  [15:45:55.461] - received message: FutureResult
  [15:45:55.461] - Received FutureResult
  [15:45:55.462] - Erased future from FutureRegistry
  [15:45:55.462] result() for ClusterFuture ...
  [15:45:55.462] - result already collected: FutureResult
  [15:45:55.463] result() for ClusterFuture ... done
  [15:45:55.463] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:55.464] result() for ClusterFuture ...
  [15:45:55.464] - result already collected: FutureResult
  [15:45:55.465] result() for ClusterFuture ... done
  [15:45:55.465] result() for ClusterFuture ...
  [15:45:55.465] - result already collected: FutureResult
  [15:45:55.466] result() for ClusterFuture ... done
  [15:45:55.468] ClusterFuture started
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a7d2558> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2ab28a78> 
   $  : NULL
   $  : NULL
   $  : num 6
  List of 6
   $ a: num 1
   $ b:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2a7d2558> 
   $ c:Classes 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment' <environment: 0x55ca2ab28a78> 
   $  : 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"
  [15:45:55.522] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:55.523] - Validating connection of ClusterFuture
  [15:45:55.523] - received message: FutureResult
  [15:45:55.524] - Received FutureResult
  [15:45:55.524] - Erased future from FutureRegistry
  [15:45:55.524] result() for ClusterFuture ...
  [15:45:55.525] - result already collected: FutureResult
  [15:45:55.525] result() for ClusterFuture ... done
  [15:45:55.526] 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" "" ...
  [15:45:55.535] resolve() on list ...
  [15:45:55.535]  recursive: 0
  [15:45:55.536]  length: 6
  [15:45:55.536]  elements: 'a', 'b', 'c', '', '', ''
  [15:45:55.536] signalConditionsASAP(numeric, pos=1) ...
  [15:45:55.537] - nx: 6
  [15:45:55.537] - relay: TRUE
  [15:45:55.537] - stdout: TRUE
  [15:45:55.538] - signal: TRUE
  [15:45:55.538] - resignal: FALSE
  [15:45:55.538] - force: TRUE
  [15:45:55.539] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.539] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.539]  - until=2
  [15:45:55.540]  - relaying element #2
  [15:45:55.540] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.541] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.541] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:55.541]  length: 5 (resolved future 1)
  [15:45:55.542] Future #2
  [15:45:55.542] result() for ClusterFuture ...
  [15:45:55.551] - result already collected: FutureResult
  [15:45:55.551] result() for ClusterFuture ... done
  [15:45:55.552] result() for ClusterFuture ...
  [15:45:55.552] - result already collected: FutureResult
  [15:45:55.552] result() for ClusterFuture ... done
  [15:45:55.553] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:55.553] - nx: 6
  [15:45:55.553] - relay: TRUE
  [15:45:55.554] - stdout: TRUE
  [15:45:55.554] - signal: TRUE
  [15:45:55.554] - resignal: FALSE
  [15:45:55.555] - force: TRUE
  [15:45:55.555] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.555] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.556]  - until=2
  [15:45:55.556]  - relaying element #2
  [15:45:55.556] result() for ClusterFuture ...
  [15:45:55.557] - result already collected: FutureResult
  [15:45:55.557] result() for ClusterFuture ... done
  [15:45:55.558] result() for ClusterFuture ...
  [15:45:55.558] - result already collected: FutureResult
  [15:45:55.558] result() for ClusterFuture ... done
  [15:45:55.559] result() for ClusterFuture ...
  [15:45:55.559] - result already collected: FutureResult
  [15:45:55.560] result() for ClusterFuture ... done
  [15:45:55.560] result() for ClusterFuture ...
  [15:45:55.560] - result already collected: FutureResult
  [15:45:55.561] result() for ClusterFuture ... done
  [15:45:55.561] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.561] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.562] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:55.562]  length: 4 (resolved future 2)
  [15:45:55.563] Future #3
  [15:45:55.563] result() for ClusterFuture ...
  [15:45:55.563] - result already collected: FutureResult
  [15:45:55.564] result() for ClusterFuture ... done
  [15:45:55.564] result() for ClusterFuture ...
  [15:45:55.564] - result already collected: FutureResult
  [15:45:55.565] result() for ClusterFuture ... done
  [15:45:55.565] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:55.566] - nx: 6
  [15:45:55.566] - relay: TRUE
  [15:45:55.566] - stdout: TRUE
  [15:45:55.583] - signal: TRUE
  [15:45:55.583] - resignal: FALSE
  [15:45:55.583] - force: TRUE
  [15:45:55.584] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.584] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:55.584]  - until=3
  [15:45:55.585]  - relaying element #3
  [15:45:55.585] result() for ClusterFuture ...
  [15:45:55.586] - result already collected: FutureResult
  [15:45:55.586] result() for ClusterFuture ... done
  [15:45:55.586] result() for ClusterFuture ...
  [15:45:55.587] - result already collected: FutureResult
  [15:45:55.587] result() for ClusterFuture ... done
  [15:45:55.588] result() for ClusterFuture ...
  [15:45:55.588] - result already collected: FutureResult
  [15:45:55.588] result() for ClusterFuture ... done
  [15:45:55.589] result() for ClusterFuture ...
  [15:45:55.589] - result already collected: FutureResult
  [15:45:55.589] result() for ClusterFuture ... done
  [15:45:55.590] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.590] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.591] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:55.591]  length: 3 (resolved future 3)
  [15:45:55.591] signalConditionsASAP(NULL, pos=4) ...
  [15:45:55.592] - nx: 6
  [15:45:55.592] - relay: TRUE
  [15:45:55.592] - stdout: TRUE
  [15:45:55.593] - signal: TRUE
  [15:45:55.593] - resignal: FALSE
  [15:45:55.593] - force: TRUE
  [15:45:55.594] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.594] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.594]  - until=5
  [15:45:55.615]  - relaying element #5
  [15:45:55.615] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:55.615] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.616] signalConditionsASAP(NULL, pos=4) ... done
  [15:45:55.616]  length: 2 (resolved future 4)
  [15:45:55.617] signalConditionsASAP(NULL, pos=5) ...
  [15:45:55.617] - nx: 6
  [15:45:55.617] - relay: TRUE
  [15:45:55.618] - stdout: TRUE
  [15:45:55.618] - signal: TRUE
  [15:45:55.618] - resignal: FALSE
  [15:45:55.619] - force: TRUE
  [15:45:55.619] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:55.619] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.620]  - until=6
  [15:45:55.620]  - relaying element #6
  [15:45:55.620] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:55.621] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.621] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:55.621]  length: 1 (resolved future 5)
  [15:45:55.622] signalConditionsASAP(numeric, pos=6) ...
  [15:45:55.622] - nx: 6
  [15:45:55.623] - relay: TRUE
  [15:45:55.623] - stdout: TRUE
  [15:45:55.623] - signal: TRUE
  [15:45:55.623] - resignal: FALSE
  [15:45:55.624] - force: TRUE
  [15:45:55.624] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:55.625] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.625]  - until=6
  [15:45:55.625] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.626] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.626] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:55.626]  length: 0 (resolved future 6)
  [15:45:55.627] Relaying remaining futures
  [15:45:55.627] signalConditionsASAP(NULL, pos=0) ...
  [15:45:55.627] - nx: 6
  [15:45:55.628] - relay: TRUE
  [15:45:55.628] - stdout: TRUE
  [15:45:55.628] - signal: TRUE
  [15:45:55.629] - resignal: FALSE
  [15:45:55.629] - force: TRUE
  [15:45:55.629] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.630] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
   - flush all
  [15:45:55.646] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:55.647] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:55.647] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:55.648] resolve() on list ... DONE
  [15:45:55.648] result() for ClusterFuture ...
  [15:45:55.648] - result already collected: FutureResult
  [15:45:55.649] result() for ClusterFuture ... done
  [15:45:55.649] result() for ClusterFuture ...
  [15:45:55.650] - result already collected: FutureResult
  [15:45:55.650] result() for ClusterFuture ... done
  [15:45:55.650] result() for ClusterFuture ...
  [15:45:55.651] - result already collected: FutureResult
  [15:45:55.651] result() for ClusterFuture ... done
  [15:45:55.651] result() for ClusterFuture ...
  [15:45:55.652] - result already collected: FutureResult
  [15:45:55.652] 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
  [15:45:55.681] plan(): Setting new future strategy stack:
  [15:45:55.682] List of future strategies:
  [15:45:55.682] 1. sequential:
  [15:45:55.682]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.682]    - tweaked: FALSE
  [15:45:55.682]    - call: plan(strategy)
  [15:45:55.684] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [15:45:55.685] getGlobalsAndPackages() ...
  [15:45:55.685] Searching for globals...
  [15:45:55.686] 
  [15:45:55.687] Searching for globals ... DONE
  [15:45:55.687] - globals: [0] <none>
  [15:45:55.687] getGlobalsAndPackages() ... DONE
  [15:45:55.690] Packages needed by the future expression (n = 0): <none>
  [15:45:55.690] Packages needed by future strategies (n = 0): <none>
  [15:45:55.697] {
  [15:45:55.697]     {
  [15:45:55.697]         ...future.startTime <- base::Sys.time()
  [15:45:55.697]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.697]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.697]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.697]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.697]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.697]         {
  [15:45:55.697]             {
  [15:45:55.697]                 base::local({
  [15:45:55.697]                   has_future <- base::requireNamespace("future", 
  [15:45:55.697]                     quietly = TRUE)
  [15:45:55.697]                   version <- if (has_future) 
  [15:45:55.697]                     utils::packageVersion("future")
  [15:45:55.697]                   else NULL
  [15:45:55.697]                   if (!has_future || version < "1.8.0") {
  [15:45:55.697]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.697]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.697]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.697]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.697]                         "release", "version")], collapse = " "), 
  [15:45:55.697]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.697]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.697]                       info)
  [15:45:55.697]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.697]                     if (!has_future) {
  [15:45:55.697]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.697]                         info)
  [15:45:55.697]                     }
  [15:45:55.697]                     else {
  [15:45:55.697]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.697]                         info, version)
  [15:45:55.697]                     }
  [15:45:55.697]                     base::stop(msg)
  [15:45:55.697]                   }
  [15:45:55.697]                 })
  [15:45:55.697]             }
  [15:45:55.697]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.697]         }
  [15:45:55.697]     }
  [15:45:55.697]     if (base::is.na(TRUE)) {
  [15:45:55.697]     }
  [15:45:55.697]     else {
  [15:45:55.697]         if (TRUE) {
  [15:45:55.697]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.697]                 open = "w")
  [15:45:55.697]         }
  [15:45:55.697]         else {
  [15:45:55.697]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.697]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.697]         }
  [15:45:55.697]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.697]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.697]             base::sink(type = "output", split = FALSE)
  [15:45:55.697]             base::close(...future.stdout)
  [15:45:55.697]         }, add = TRUE)
  [15:45:55.697]     }
  [15:45:55.697]     ...future.frame <- base::sys.nframe()
  [15:45:55.697]     ...future.conditions <- base::list()
  [15:45:55.697]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.697]     ...future.result <- base::tryCatch({
  [15:45:55.697]         base::withCallingHandlers({
  [15:45:55.697]             ...future.value <- base::withVisible(base::local(2))
  [15:45:55.697]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.697]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.697]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.697]                 version = "1.8")
  [15:45:55.697]         }, condition = base::local({
  [15:45:55.697]             c <- base::c
  [15:45:55.697]             inherits <- base::inherits
  [15:45:55.697]             invokeRestart <- base::invokeRestart
  [15:45:55.697]             length <- base::length
  [15:45:55.697]             list <- base::list
  [15:45:55.697]             seq.int <- base::seq.int
  [15:45:55.697]             signalCondition <- base::signalCondition
  [15:45:55.697]             sys.calls <- base::sys.calls
  [15:45:55.697]             Sys.time <- base::Sys.time
  [15:45:55.697]             `[[` <- base::`[[`
  [15:45:55.697]             `+` <- base::`+`
  [15:45:55.697]             `<<-` <- base::`<<-`
  [15:45:55.697]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.697]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.697]                   3L)]
  [15:45:55.697]             }
  [15:45:55.697]             function(cond) {
  [15:45:55.697]                 if (inherits(cond, "error")) {
  [15:45:55.697]                   sessionInformation <- function() {
  [15:45:55.697]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.697]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.697]                       search = base::search(), system = base::Sys.info())
  [15:45:55.697]                   }
  [15:45:55.697]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.697]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.697]                     cond$call), session = sessionInformation(), 
  [15:45:55.697]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.697]                   signalCondition(cond)
  [15:45:55.697]                 }
  [15:45:55.697]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.697]                 ))) {
  [15:45:55.697]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.697]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.697]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.697]                   if (!signal) {
  [15:45:55.697]                     muffleCondition <- function (cond) 
  [15:45:55.697]                     {
  [15:45:55.697]                       inherits <- base::inherits
  [15:45:55.697]                       invokeRestart <- base::invokeRestart
  [15:45:55.697]                       muffled <- FALSE
  [15:45:55.697]                       if (inherits(cond, "message")) {
  [15:45:55.697]                         invokeRestart("muffleMessage")
  [15:45:55.697]                         muffled <- TRUE
  [15:45:55.697]                       }
  [15:45:55.697]                       else if (inherits(cond, "warning")) {
  [15:45:55.697]                         invokeRestart("muffleWarning")
  [15:45:55.697]                         muffled <- TRUE
  [15:45:55.697]                       }
  [15:45:55.697]                       else if (inherits(cond, "condition")) {
  [15:45:55.697]                         computeRestarts <- base::computeRestarts
  [15:45:55.697]                         grepl <- base::grepl
  [15:45:55.697]                         is.null <- base::is.null
  [15:45:55.697]                         restarts <- computeRestarts(cond)
  [15:45:55.697]                         for (restart in restarts) {
  [15:45:55.697]                           name <- restart$name
  [15:45:55.697]                           if (is.null(name)) 
  [15:45:55.697]                             next
  [15:45:55.697]                           if (!grepl("^muffle", name)) 
  [15:45:55.697]                             next
  [15:45:55.697]                           invokeRestart(restart)
  [15:45:55.697]                           muffled <- TRUE
  [15:45:55.697]                           break
  [15:45:55.697]                         }
  [15:45:55.697]                       }
  [15:45:55.697]                       invisible(muffled)
  [15:45:55.697]                     }
  [15:45:55.697]                     muffleCondition(cond)
  [15:45:55.697]                   }
  [15:45:55.697]                 }
  [15:45:55.697]             }
  [15:45:55.697]         }))
  [15:45:55.697]     }, error = function(ex) {
  [15:45:55.697]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.697]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.697]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.697]     }, finally = {
  [15:45:55.697]         {
  [15:45:55.697]             NULL
  [15:45:55.697]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.697]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.697]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.697]                 label = NULL, ...) 
  [15:45:55.697]             {
  [15:45:55.697]                 if (substitute) 
  [15:45:55.697]                   expr <- substitute(expr)
  [15:45:55.697]                 local <- as.logical(local)
  [15:45:55.697]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.697]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.697]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.697]                   label = label, ...)
  [15:45:55.697]                 if (!future$lazy) 
  [15:45:55.697]                   future <- run(future)
  [15:45:55.697]                 invisible(future)
  [15:45:55.697]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.697]         }
  [15:45:55.697]         base::options(...future.oldOptions)
  [15:45:55.697]     })
  [15:45:55.697]     Sys.time
  [15:45:55.697]     if (base::is.na(TRUE)) {
  [15:45:55.697]     }
  [15:45:55.697]     else {
  [15:45:55.697]         base::sink(type = "output", split = FALSE)
  [15:45:55.697]         if (TRUE) {
  [15:45:55.697]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.697]         }
  [15:45:55.697]         else {
  [15:45:55.697]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.697]         }
  [15:45:55.697]         base::close(...future.stdout)
  [15:45:55.697]         ...future.stdout <- NULL
  [15:45:55.697]     }
  [15:45:55.697]     ...future.result$conditions <- ...future.conditions
  [15:45:55.697]     ...future.result
  [15:45:55.697] }
  [15:45:55.702] plan(): Setting new future strategy stack:
  [15:45:55.703] List of future strategies:
  [15:45:55.703] 1. sequential:
  [15:45:55.703]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.703]    - tweaked: FALSE
  [15:45:55.703]    - call: NULL
  [15:45:55.704] plan(): nbrOfWorkers() = 1
  [15:45:55.705] plan(): Setting new future strategy stack:
  [15:45:55.706] List of future strategies:
  [15:45:55.706] 1. sequential:
  [15:45:55.706]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.706]    - tweaked: FALSE
  [15:45:55.706]    - call: plan(strategy)
  [15:45:55.759] plan(): nbrOfWorkers() = 1
  [15:45:55.760] SequentialFuture started (and completed)
  [15:45:55.761] getGlobalsAndPackages() ...
  [15:45:55.761] Searching for globals...
  [15:45:55.762] 
  [15:45:55.763] Searching for globals ... DONE
  [15:45:55.763] - globals: [0] <none>
  [15:45:55.763] getGlobalsAndPackages() ... DONE
  [15:45:55.765] Packages needed by the future expression (n = 0): <none>
  [15:45:55.766] Packages needed by future strategies (n = 0): <none>
  [15:45:55.772] {
  [15:45:55.772]     {
  [15:45:55.772]         ...future.startTime <- base::Sys.time()
  [15:45:55.772]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.772]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.772]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.772]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.772]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.772]         {
  [15:45:55.772]             {
  [15:45:55.772]                 base::local({
  [15:45:55.772]                   has_future <- base::requireNamespace("future", 
  [15:45:55.772]                     quietly = TRUE)
  [15:45:55.772]                   version <- if (has_future) 
  [15:45:55.772]                     utils::packageVersion("future")
  [15:45:55.772]                   else NULL
  [15:45:55.772]                   if (!has_future || version < "1.8.0") {
  [15:45:55.772]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.772]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.772]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.772]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.772]                         "release", "version")], collapse = " "), 
  [15:45:55.772]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.772]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.772]                       info)
  [15:45:55.772]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.772]                     if (!has_future) {
  [15:45:55.772]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.772]                         info)
  [15:45:55.772]                     }
  [15:45:55.772]                     else {
  [15:45:55.772]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.772]                         info, version)
  [15:45:55.772]                     }
  [15:45:55.772]                     base::stop(msg)
  [15:45:55.772]                   }
  [15:45:55.772]                 })
  [15:45:55.772]             }
  [15:45:55.772]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.772]         }
  [15:45:55.772]     }
  [15:45:55.772]     if (base::is.na(TRUE)) {
  [15:45:55.772]     }
  [15:45:55.772]     else {
  [15:45:55.772]         if (TRUE) {
  [15:45:55.772]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.772]                 open = "w")
  [15:45:55.772]         }
  [15:45:55.772]         else {
  [15:45:55.772]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.772]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.772]         }
  [15:45:55.772]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.772]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.772]             base::sink(type = "output", split = FALSE)
  [15:45:55.772]             base::close(...future.stdout)
  [15:45:55.772]         }, add = TRUE)
  [15:45:55.772]     }
  [15:45:55.772]     ...future.frame <- base::sys.nframe()
  [15:45:55.772]     ...future.conditions <- base::list()
  [15:45:55.772]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.772]     ...future.result <- base::tryCatch({
  [15:45:55.772]         base::withCallingHandlers({
  [15:45:55.772]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:55.772]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.772]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.772]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.772]                 version = "1.8")
  [15:45:55.772]         }, condition = base::local({
  [15:45:55.772]             c <- base::c
  [15:45:55.772]             inherits <- base::inherits
  [15:45:55.772]             invokeRestart <- base::invokeRestart
  [15:45:55.772]             length <- base::length
  [15:45:55.772]             list <- base::list
  [15:45:55.772]             seq.int <- base::seq.int
  [15:45:55.772]             signalCondition <- base::signalCondition
  [15:45:55.772]             sys.calls <- base::sys.calls
  [15:45:55.772]             Sys.time <- base::Sys.time
  [15:45:55.772]             `[[` <- base::`[[`
  [15:45:55.772]             `+` <- base::`+`
  [15:45:55.772]             `<<-` <- base::`<<-`
  [15:45:55.772]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.772]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.772]                   3L)]
  [15:45:55.772]             }
  [15:45:55.772]             function(cond) {
  [15:45:55.772]                 if (inherits(cond, "error")) {
  [15:45:55.772]                   sessionInformation <- function() {
  [15:45:55.772]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.772]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.772]                       search = base::search(), system = base::Sys.info())
  [15:45:55.772]                   }
  [15:45:55.772]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.772]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.772]                     cond$call), session = sessionInformation(), 
  [15:45:55.772]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.772]                   signalCondition(cond)
  [15:45:55.772]                 }
  [15:45:55.772]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.772]                 ))) {
  [15:45:55.772]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.772]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.772]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.772]                   if (!signal) {
  [15:45:55.772]                     muffleCondition <- function (cond) 
  [15:45:55.772]                     {
  [15:45:55.772]                       inherits <- base::inherits
  [15:45:55.772]                       invokeRestart <- base::invokeRestart
  [15:45:55.772]                       muffled <- FALSE
  [15:45:55.772]                       if (inherits(cond, "message")) {
  [15:45:55.772]                         invokeRestart("muffleMessage")
  [15:45:55.772]                         muffled <- TRUE
  [15:45:55.772]                       }
  [15:45:55.772]                       else if (inherits(cond, "warning")) {
  [15:45:55.772]                         invokeRestart("muffleWarning")
  [15:45:55.772]                         muffled <- TRUE
  [15:45:55.772]                       }
  [15:45:55.772]                       else if (inherits(cond, "condition")) {
  [15:45:55.772]                         computeRestarts <- base::computeRestarts
  [15:45:55.772]                         grepl <- base::grepl
  [15:45:55.772]                         is.null <- base::is.null
  [15:45:55.772]                         restarts <- computeRestarts(cond)
  [15:45:55.772]                         for (restart in restarts) {
  [15:45:55.772]                           name <- restart$name
  [15:45:55.772]                           if (is.null(name)) 
  [15:45:55.772]                             next
  [15:45:55.772]                           if (!grepl("^muffle", name)) 
  [15:45:55.772]                             next
  [15:45:55.772]                           invokeRestart(restart)
  [15:45:55.772]                           muffled <- TRUE
  [15:45:55.772]                           break
  [15:45:55.772]                         }
  [15:45:55.772]                       }
  [15:45:55.772]                       invisible(muffled)
  [15:45:55.772]                     }
  [15:45:55.772]                     muffleCondition(cond)
  [15:45:55.772]                   }
  [15:45:55.772]                 }
  [15:45:55.772]             }
  [15:45:55.772]         }))
  [15:45:55.772]     }, error = function(ex) {
  [15:45:55.772]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.772]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.772]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.772]     }, finally = {
  [15:45:55.772]         {
  [15:45:55.772]             NULL
  [15:45:55.772]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.772]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.772]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.772]                 label = NULL, ...) 
  [15:45:55.772]             {
  [15:45:55.772]                 if (substitute) 
  [15:45:55.772]                   expr <- substitute(expr)
  [15:45:55.772]                 local <- as.logical(local)
  [15:45:55.772]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.772]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.772]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.772]                   label = label, ...)
  [15:45:55.772]                 if (!future$lazy) 
  [15:45:55.772]                   future <- run(future)
  [15:45:55.772]                 invisible(future)
  [15:45:55.772]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.772]         }
  [15:45:55.772]         base::options(...future.oldOptions)
  [15:45:55.772]     })
  [15:45:55.772]     Sys.time
  [15:45:55.772]     if (base::is.na(TRUE)) {
  [15:45:55.772]     }
  [15:45:55.772]     else {
  [15:45:55.772]         base::sink(type = "output", split = FALSE)
  [15:45:55.772]         if (TRUE) {
  [15:45:55.772]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.772]         }
  [15:45:55.772]         else {
  [15:45:55.772]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.772]         }
  [15:45:55.772]         base::close(...future.stdout)
  [15:45:55.772]         ...future.stdout <- NULL
  [15:45:55.772]     }
  [15:45:55.772]     ...future.result$conditions <- ...future.conditions
  [15:45:55.772]     ...future.result
  [15:45:55.772] }
  [15:45:55.777] plan(): Setting new future strategy stack:
  [15:45:55.778] List of future strategies:
  [15:45:55.778] 1. sequential:
  [15:45:55.778]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.778]    - tweaked: FALSE
  [15:45:55.778]    - call: NULL
  [15:45:55.779] plan(): nbrOfWorkers() = 1
  [15:45:55.780] plan(): Setting new future strategy stack:
  [15:45:55.781] List of future strategies:
  [15:45:55.781] 1. sequential:
  [15:45:55.781]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.781]    - tweaked: FALSE
  [15:45:55.781]    - call: plan(strategy)
  [15:45:55.782] plan(): nbrOfWorkers() = 1
  [15:45:55.783] SequentialFuture started (and completed)
  [15:45:55.786] getGlobalsAndPackages() ...
  [15:45:55.787] Searching for globals...
  [15:45:55.792] - globals found: [1] '{'
  [15:45:55.793] Searching for globals ... DONE
  [15:45:55.793] Resolving globals: FALSE
  [15:45:55.795] 
  [15:45:55.795] 
  [15:45:55.796] getGlobalsAndPackages() ... DONE
  [15:45:55.798] Packages needed by the future expression (n = 0): <none>
  [15:45:55.799] Packages needed by future strategies (n = 0): <none>
  [15:45:55.805] {
  [15:45:55.805]     {
  [15:45:55.805]         ...future.startTime <- base::Sys.time()
  [15:45:55.805]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.805]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.805]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.805]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.805]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.805]         {
  [15:45:55.805]             {
  [15:45:55.805]                 base::local({
  [15:45:55.805]                   has_future <- base::requireNamespace("future", 
  [15:45:55.805]                     quietly = TRUE)
  [15:45:55.805]                   version <- if (has_future) 
  [15:45:55.805]                     utils::packageVersion("future")
  [15:45:55.805]                   else NULL
  [15:45:55.805]                   if (!has_future || version < "1.8.0") {
  [15:45:55.805]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.805]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.805]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.805]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.805]                         "release", "version")], collapse = " "), 
  [15:45:55.805]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.805]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.805]                       info)
  [15:45:55.805]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.805]                     if (!has_future) {
  [15:45:55.805]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.805]                         info)
  [15:45:55.805]                     }
  [15:45:55.805]                     else {
  [15:45:55.805]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.805]                         info, version)
  [15:45:55.805]                     }
  [15:45:55.805]                     base::stop(msg)
  [15:45:55.805]                   }
  [15:45:55.805]                 })
  [15:45:55.805]             }
  [15:45:55.805]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.805]         }
  [15:45:55.805]     }
  [15:45:55.805]     if (base::is.na(TRUE)) {
  [15:45:55.805]     }
  [15:45:55.805]     else {
  [15:45:55.805]         if (TRUE) {
  [15:45:55.805]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.805]                 open = "w")
  [15:45:55.805]         }
  [15:45:55.805]         else {
  [15:45:55.805]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.805]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.805]         }
  [15:45:55.805]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.805]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.805]             base::sink(type = "output", split = FALSE)
  [15:45:55.805]             base::close(...future.stdout)
  [15:45:55.805]         }, add = TRUE)
  [15:45:55.805]     }
  [15:45:55.805]     ...future.frame <- base::sys.nframe()
  [15:45:55.805]     ...future.conditions <- base::list()
  [15:45:55.805]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.805]     ...future.result <- base::tryCatch({
  [15:45:55.805]         base::withCallingHandlers({
  [15:45:55.805]             ...future.value <- base::withVisible(base::local({
  [15:45:55.805]                 4
  [15:45:55.805]             }))
  [15:45:55.805]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.805]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.805]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.805]                 version = "1.8")
  [15:45:55.805]         }, condition = base::local({
  [15:45:55.805]             c <- base::c
  [15:45:55.805]             inherits <- base::inherits
  [15:45:55.805]             invokeRestart <- base::invokeRestart
  [15:45:55.805]             length <- base::length
  [15:45:55.805]             list <- base::list
  [15:45:55.805]             seq.int <- base::seq.int
  [15:45:55.805]             signalCondition <- base::signalCondition
  [15:45:55.805]             sys.calls <- base::sys.calls
  [15:45:55.805]             Sys.time <- base::Sys.time
  [15:45:55.805]             `[[` <- base::`[[`
  [15:45:55.805]             `+` <- base::`+`
  [15:45:55.805]             `<<-` <- base::`<<-`
  [15:45:55.805]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.805]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.805]                   3L)]
  [15:45:55.805]             }
  [15:45:55.805]             function(cond) {
  [15:45:55.805]                 if (inherits(cond, "error")) {
  [15:45:55.805]                   sessionInformation <- function() {
  [15:45:55.805]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.805]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.805]                       search = base::search(), system = base::Sys.info())
  [15:45:55.805]                   }
  [15:45:55.805]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.805]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.805]                     cond$call), session = sessionInformation(), 
  [15:45:55.805]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.805]                   signalCondition(cond)
  [15:45:55.805]                 }
  [15:45:55.805]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.805]                 ))) {
  [15:45:55.805]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.805]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.805]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.805]                   if (!signal) {
  [15:45:55.805]                     muffleCondition <- function (cond) 
  [15:45:55.805]                     {
  [15:45:55.805]                       inherits <- base::inherits
  [15:45:55.805]                       invokeRestart <- base::invokeRestart
  [15:45:55.805]                       muffled <- FALSE
  [15:45:55.805]                       if (inherits(cond, "message")) {
  [15:45:55.805]                         invokeRestart("muffleMessage")
  [15:45:55.805]                         muffled <- TRUE
  [15:45:55.805]                       }
  [15:45:55.805]                       else if (inherits(cond, "warning")) {
  [15:45:55.805]                         invokeRestart("muffleWarning")
  [15:45:55.805]                         muffled <- TRUE
  [15:45:55.805]                       }
  [15:45:55.805]                       else if (inherits(cond, "condition")) {
  [15:45:55.805]                         computeRestarts <- base::computeRestarts
  [15:45:55.805]                         grepl <- base::grepl
  [15:45:55.805]                         is.null <- base::is.null
  [15:45:55.805]                         restarts <- computeRestarts(cond)
  [15:45:55.805]                         for (restart in restarts) {
  [15:45:55.805]                           name <- restart$name
  [15:45:55.805]                           if (is.null(name)) 
  [15:45:55.805]                             next
  [15:45:55.805]                           if (!grepl("^muffle", name)) 
  [15:45:55.805]                             next
  [15:45:55.805]                           invokeRestart(restart)
  [15:45:55.805]                           muffled <- TRUE
  [15:45:55.805]                           break
  [15:45:55.805]                         }
  [15:45:55.805]                       }
  [15:45:55.805]                       invisible(muffled)
  [15:45:55.805]                     }
  [15:45:55.805]                     muffleCondition(cond)
  [15:45:55.805]                   }
  [15:45:55.805]                 }
  [15:45:55.805]             }
  [15:45:55.805]         }))
  [15:45:55.805]     }, error = function(ex) {
  [15:45:55.805]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.805]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.805]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.805]     }, finally = {
  [15:45:55.805]         {
  [15:45:55.805]             NULL
  [15:45:55.805]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.805]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.805]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.805]                 label = NULL, ...) 
  [15:45:55.805]             {
  [15:45:55.805]                 if (substitute) 
  [15:45:55.805]                   expr <- substitute(expr)
  [15:45:55.805]                 local <- as.logical(local)
  [15:45:55.805]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.805]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.805]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.805]                   label = label, ...)
  [15:45:55.805]                 if (!future$lazy) 
  [15:45:55.805]                   future <- run(future)
  [15:45:55.805]                 invisible(future)
  [15:45:55.805]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.805]         }
  [15:45:55.805]         base::options(...future.oldOptions)
  [15:45:55.805]     })
  [15:45:55.805]     Sys.time
  [15:45:55.805]     if (base::is.na(TRUE)) {
  [15:45:55.805]     }
  [15:45:55.805]     else {
  [15:45:55.805]         base::sink(type = "output", split = FALSE)
  [15:45:55.805]         if (TRUE) {
  [15:45:55.805]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.805]         }
  [15:45:55.805]         else {
  [15:45:55.805]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.805]         }
  [15:45:55.805]         base::close(...future.stdout)
  [15:45:55.805]         ...future.stdout <- NULL
  [15:45:55.805]     }
  [15:45:55.805]     ...future.result$conditions <- ...future.conditions
  [15:45:55.805]     ...future.result
  [15:45:55.805] }
  [15:45:55.811] plan(): Setting new future strategy stack:
  [15:45:55.812] List of future strategies:
  [15:45:55.812] 1. sequential:
  [15:45:55.812]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.812]    - tweaked: FALSE
  [15:45:55.812]    - call: NULL
  [15:45:55.813] plan(): nbrOfWorkers() = 1
  [15:45:55.815] plan(): Setting new future strategy stack:
  [15:45:55.815] List of future strategies:
  [15:45:55.815] 1. sequential:
  [15:45:55.815]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.815]    - tweaked: FALSE
  [15:45:55.815]    - call: plan(strategy)
  [15:45:55.816] plan(): nbrOfWorkers() = 1
  [15:45:55.817] SequentialFuture started (and completed)
  <environment: 0x55ca2aaecd08> 
  <environment: 0x55ca2a997720> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:55.825] resolve() on environment ...
  [15:45:55.826]  recursive: 0
  [15:45:55.828]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:55.828] signalConditionsASAP(numeric, pos=1) ...
  [15:45:55.828] - nx: 4
  [15:45:55.829] - relay: TRUE
  [15:45:55.829] - stdout: TRUE
  [15:45:55.829] - signal: TRUE
  [15:45:55.830] - resignal: FALSE
  [15:45:55.830] - force: TRUE
  [15:45:55.830] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.831] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.831]  - until=2
  [15:45:55.831]  - relaying element #2
  [15:45:55.832] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:55.832] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.833] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:55.833]  length: 3 (resolved future 1)
  [15:45:55.833] Future #2
  [15:45:55.834] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:55.834] - nx: 4
  [15:45:55.835] - relay: TRUE
  [15:45:55.835] - stdout: TRUE
  [15:45:55.835] - signal: TRUE
  [15:45:55.836] - resignal: FALSE
  [15:45:55.836] - force: TRUE
  [15:45:55.836] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:55.837] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.837]  - until=2
  [15:45:55.837]  - relaying element #2
  [15:45:55.838] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:55.838] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:55.839] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:55.839]  length: 2 (resolved future 2)
  [15:45:55.840] Future #3
  [15:45:55.840] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:55.840] - nx: 4
  [15:45:55.841] - relay: TRUE
  [15:45:55.841] - stdout: TRUE
  [15:45:55.841] - signal: TRUE
  [15:45:55.842] - resignal: FALSE
  [15:45:55.842] - force: TRUE
  [15:45:55.842] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:55.843] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:55.843]  - until=3
  [15:45:55.843]  - relaying element #3
  [15:45:55.844] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:55.844] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:55.845] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:55.845]  length: 1 (resolved future 3)
  [15:45:55.846] Future #4
  [15:45:55.846] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:55.846] - nx: 4
  [15:45:55.847] - relay: TRUE
  [15:45:55.847] - stdout: TRUE
  [15:45:55.847] - signal: TRUE
  [15:45:55.848] - resignal: FALSE
  [15:45:55.848] - force: TRUE
  [15:45:55.848] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:55.849] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:55.849]  - until=4
  [15:45:55.850]  - relaying element #4
  [15:45:55.854] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.855] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:55.855] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:55.855]  length: 0 (resolved future 4)
  [15:45:55.856] Relaying remaining futures
  [15:45:55.856] signalConditionsASAP(NULL, pos=0) ...
  [15:45:55.857] - nx: 4
  [15:45:55.857] - relay: TRUE
  [15:45:55.857] - stdout: TRUE
  [15:45:55.858] - signal: TRUE
  [15:45:55.858] - resignal: FALSE
  [15:45:55.860] - force: TRUE
  [15:45:55.861] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.861] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:55.862] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.862] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:55.863] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:55.863] resolve() on environment ... DONE
  <environment: 0x55ca2aa84898> 
  Dimensions: c(1, 6)
  [15:45:55.865] getGlobalsAndPackages() ...
  [15:45:55.865] Searching for globals...
  [15:45:55.866] 
  [15:45:55.867] Searching for globals ... DONE
  [15:45:55.867] - globals: [0] <none>
  [15:45:55.867] getGlobalsAndPackages() ... DONE
  [15:45:55.870] Packages needed by the future expression (n = 0): <none>
  [15:45:55.870] Packages needed by future strategies (n = 0): <none>
  [15:45:55.878] {
  [15:45:55.878]     {
  [15:45:55.878]         ...future.startTime <- base::Sys.time()
  [15:45:55.878]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.878]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.878]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.878]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.878]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.878]         {
  [15:45:55.878]             {
  [15:45:55.878]                 base::local({
  [15:45:55.878]                   has_future <- base::requireNamespace("future", 
  [15:45:55.878]                     quietly = TRUE)
  [15:45:55.878]                   version <- if (has_future) 
  [15:45:55.878]                     utils::packageVersion("future")
  [15:45:55.878]                   else NULL
  [15:45:55.878]                   if (!has_future || version < "1.8.0") {
  [15:45:55.878]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.878]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.878]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.878]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.878]                         "release", "version")], collapse = " "), 
  [15:45:55.878]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.878]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.878]                       info)
  [15:45:55.878]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.878]                     if (!has_future) {
  [15:45:55.878]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.878]                         info)
  [15:45:55.878]                     }
  [15:45:55.878]                     else {
  [15:45:55.878]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.878]                         info, version)
  [15:45:55.878]                     }
  [15:45:55.878]                     base::stop(msg)
  [15:45:55.878]                   }
  [15:45:55.878]                 })
  [15:45:55.878]             }
  [15:45:55.878]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.878]         }
  [15:45:55.878]     }
  [15:45:55.878]     if (base::is.na(TRUE)) {
  [15:45:55.878]     }
  [15:45:55.878]     else {
  [15:45:55.878]         if (TRUE) {
  [15:45:55.878]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.878]                 open = "w")
  [15:45:55.878]         }
  [15:45:55.878]         else {
  [15:45:55.878]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.878]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.878]         }
  [15:45:55.878]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.878]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.878]             base::sink(type = "output", split = FALSE)
  [15:45:55.878]             base::close(...future.stdout)
  [15:45:55.878]         }, add = TRUE)
  [15:45:55.878]     }
  [15:45:55.878]     ...future.frame <- base::sys.nframe()
  [15:45:55.878]     ...future.conditions <- base::list()
  [15:45:55.878]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.878]     ...future.result <- base::tryCatch({
  [15:45:55.878]         base::withCallingHandlers({
  [15:45:55.878]             ...future.value <- base::withVisible(base::local(2))
  [15:45:55.878]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.878]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.878]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.878]                 version = "1.8")
  [15:45:55.878]         }, condition = base::local({
  [15:45:55.878]             c <- base::c
  [15:45:55.878]             inherits <- base::inherits
  [15:45:55.878]             invokeRestart <- base::invokeRestart
  [15:45:55.878]             length <- base::length
  [15:45:55.878]             list <- base::list
  [15:45:55.878]             seq.int <- base::seq.int
  [15:45:55.878]             signalCondition <- base::signalCondition
  [15:45:55.878]             sys.calls <- base::sys.calls
  [15:45:55.878]             Sys.time <- base::Sys.time
  [15:45:55.878]             `[[` <- base::`[[`
  [15:45:55.878]             `+` <- base::`+`
  [15:45:55.878]             `<<-` <- base::`<<-`
  [15:45:55.878]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.878]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.878]                   3L)]
  [15:45:55.878]             }
  [15:45:55.878]             function(cond) {
  [15:45:55.878]                 if (inherits(cond, "error")) {
  [15:45:55.878]                   sessionInformation <- function() {
  [15:45:55.878]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.878]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.878]                       search = base::search(), system = base::Sys.info())
  [15:45:55.878]                   }
  [15:45:55.878]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.878]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.878]                     cond$call), session = sessionInformation(), 
  [15:45:55.878]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.878]                   signalCondition(cond)
  [15:45:55.878]                 }
  [15:45:55.878]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.878]                 ))) {
  [15:45:55.878]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.878]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.878]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.878]                   if (!signal) {
  [15:45:55.878]                     muffleCondition <- function (cond) 
  [15:45:55.878]                     {
  [15:45:55.878]                       inherits <- base::inherits
  [15:45:55.878]                       invokeRestart <- base::invokeRestart
  [15:45:55.878]                       muffled <- FALSE
  [15:45:55.878]                       if (inherits(cond, "message")) {
  [15:45:55.878]                         invokeRestart("muffleMessage")
  [15:45:55.878]                         muffled <- TRUE
  [15:45:55.878]                       }
  [15:45:55.878]                       else if (inherits(cond, "warning")) {
  [15:45:55.878]                         invokeRestart("muffleWarning")
  [15:45:55.878]                         muffled <- TRUE
  [15:45:55.878]                       }
  [15:45:55.878]                       else if (inherits(cond, "condition")) {
  [15:45:55.878]                         computeRestarts <- base::computeRestarts
  [15:45:55.878]                         grepl <- base::grepl
  [15:45:55.878]                         is.null <- base::is.null
  [15:45:55.878]                         restarts <- computeRestarts(cond)
  [15:45:55.878]                         for (restart in restarts) {
  [15:45:55.878]                           name <- restart$name
  [15:45:55.878]                           if (is.null(name)) 
  [15:45:55.878]                             next
  [15:45:55.878]                           if (!grepl("^muffle", name)) 
  [15:45:55.878]                             next
  [15:45:55.878]                           invokeRestart(restart)
  [15:45:55.878]                           muffled <- TRUE
  [15:45:55.878]                           break
  [15:45:55.878]                         }
  [15:45:55.878]                       }
  [15:45:55.878]                       invisible(muffled)
  [15:45:55.878]                     }
  [15:45:55.878]                     muffleCondition(cond)
  [15:45:55.878]                   }
  [15:45:55.878]                 }
  [15:45:55.878]             }
  [15:45:55.878]         }))
  [15:45:55.878]     }, error = function(ex) {
  [15:45:55.878]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.878]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.878]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.878]     }, finally = {
  [15:45:55.878]         {
  [15:45:55.878]             NULL
  [15:45:55.878]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.878]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.878]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.878]                 label = NULL, ...) 
  [15:45:55.878]             {
  [15:45:55.878]                 if (substitute) 
  [15:45:55.878]                   expr <- substitute(expr)
  [15:45:55.878]                 local <- as.logical(local)
  [15:45:55.878]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.878]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.878]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.878]                   label = label, ...)
  [15:45:55.878]                 if (!future$lazy) 
  [15:45:55.878]                   future <- run(future)
  [15:45:55.878]                 invisible(future)
  [15:45:55.878]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.878]         }
  [15:45:55.878]         base::options(...future.oldOptions)
  [15:45:55.878]     })
  [15:45:55.878]     Sys.time
  [15:45:55.878]     if (base::is.na(TRUE)) {
  [15:45:55.878]     }
  [15:45:55.878]     else {
  [15:45:55.878]         base::sink(type = "output", split = FALSE)
  [15:45:55.878]         if (TRUE) {
  [15:45:55.878]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.878]         }
  [15:45:55.878]         else {
  [15:45:55.878]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.878]         }
  [15:45:55.878]         base::close(...future.stdout)
  [15:45:55.878]         ...future.stdout <- NULL
  [15:45:55.878]     }
  [15:45:55.878]     ...future.result$conditions <- ...future.conditions
  [15:45:55.878]     ...future.result
  [15:45:55.878] }
  [15:45:55.884] plan(): Setting new future strategy stack:
  [15:45:55.884] List of future strategies:
  [15:45:55.884] 1. sequential:
  [15:45:55.884]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.884]    - tweaked: FALSE
  [15:45:55.884]    - call: NULL
  [15:45:55.885] plan(): nbrOfWorkers() = 1
  [15:45:55.887] plan(): Setting new future strategy stack:
  [15:45:55.887] List of future strategies:
  [15:45:55.887] 1. sequential:
  [15:45:55.887]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.887]    - tweaked: FALSE
  [15:45:55.887]    - call: plan(strategy)
  [15:45:55.889] plan(): nbrOfWorkers() = 1
  [15:45:55.889] SequentialFuture started (and completed)
  [15:45:55.890] getGlobalsAndPackages() ...
  [15:45:55.890] Searching for globals...
  [15:45:55.891] 
  [15:45:55.892] Searching for globals ... DONE
  [15:45:55.892] - globals: [0] <none>
  [15:45:55.892] getGlobalsAndPackages() ... DONE
  [15:45:55.895] Packages needed by the future expression (n = 0): <none>
  [15:45:55.895] Packages needed by future strategies (n = 0): <none>
  [15:45:55.902] {
  [15:45:55.902]     {
  [15:45:55.902]         ...future.startTime <- base::Sys.time()
  [15:45:55.902]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.902]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.902]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.902]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.902]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.902]         {
  [15:45:55.902]             {
  [15:45:55.902]                 base::local({
  [15:45:55.902]                   has_future <- base::requireNamespace("future", 
  [15:45:55.902]                     quietly = TRUE)
  [15:45:55.902]                   version <- if (has_future) 
  [15:45:55.902]                     utils::packageVersion("future")
  [15:45:55.902]                   else NULL
  [15:45:55.902]                   if (!has_future || version < "1.8.0") {
  [15:45:55.902]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.902]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.902]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.902]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.902]                         "release", "version")], collapse = " "), 
  [15:45:55.902]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.902]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.902]                       info)
  [15:45:55.902]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.902]                     if (!has_future) {
  [15:45:55.902]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.902]                         info)
  [15:45:55.902]                     }
  [15:45:55.902]                     else {
  [15:45:55.902]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.902]                         info, version)
  [15:45:55.902]                     }
  [15:45:55.902]                     base::stop(msg)
  [15:45:55.902]                   }
  [15:45:55.902]                 })
  [15:45:55.902]             }
  [15:45:55.902]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.902]         }
  [15:45:55.902]     }
  [15:45:55.902]     if (base::is.na(TRUE)) {
  [15:45:55.902]     }
  [15:45:55.902]     else {
  [15:45:55.902]         if (TRUE) {
  [15:45:55.902]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.902]                 open = "w")
  [15:45:55.902]         }
  [15:45:55.902]         else {
  [15:45:55.902]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.902]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.902]         }
  [15:45:55.902]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.902]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.902]             base::sink(type = "output", split = FALSE)
  [15:45:55.902]             base::close(...future.stdout)
  [15:45:55.902]         }, add = TRUE)
  [15:45:55.902]     }
  [15:45:55.902]     ...future.frame <- base::sys.nframe()
  [15:45:55.902]     ...future.conditions <- base::list()
  [15:45:55.902]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.902]     ...future.result <- base::tryCatch({
  [15:45:55.902]         base::withCallingHandlers({
  [15:45:55.902]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:55.902]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.902]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.902]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.902]                 version = "1.8")
  [15:45:55.902]         }, condition = base::local({
  [15:45:55.902]             c <- base::c
  [15:45:55.902]             inherits <- base::inherits
  [15:45:55.902]             invokeRestart <- base::invokeRestart
  [15:45:55.902]             length <- base::length
  [15:45:55.902]             list <- base::list
  [15:45:55.902]             seq.int <- base::seq.int
  [15:45:55.902]             signalCondition <- base::signalCondition
  [15:45:55.902]             sys.calls <- base::sys.calls
  [15:45:55.902]             Sys.time <- base::Sys.time
  [15:45:55.902]             `[[` <- base::`[[`
  [15:45:55.902]             `+` <- base::`+`
  [15:45:55.902]             `<<-` <- base::`<<-`
  [15:45:55.902]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.902]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.902]                   3L)]
  [15:45:55.902]             }
  [15:45:55.902]             function(cond) {
  [15:45:55.902]                 if (inherits(cond, "error")) {
  [15:45:55.902]                   sessionInformation <- function() {
  [15:45:55.902]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.902]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.902]                       search = base::search(), system = base::Sys.info())
  [15:45:55.902]                   }
  [15:45:55.902]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.902]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.902]                     cond$call), session = sessionInformation(), 
  [15:45:55.902]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.902]                   signalCondition(cond)
  [15:45:55.902]                 }
  [15:45:55.902]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.902]                 ))) {
  [15:45:55.902]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.902]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.902]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.902]                   if (!signal) {
  [15:45:55.902]                     muffleCondition <- function (cond) 
  [15:45:55.902]                     {
  [15:45:55.902]                       inherits <- base::inherits
  [15:45:55.902]                       invokeRestart <- base::invokeRestart
  [15:45:55.902]                       muffled <- FALSE
  [15:45:55.902]                       if (inherits(cond, "message")) {
  [15:45:55.902]                         invokeRestart("muffleMessage")
  [15:45:55.902]                         muffled <- TRUE
  [15:45:55.902]                       }
  [15:45:55.902]                       else if (inherits(cond, "warning")) {
  [15:45:55.902]                         invokeRestart("muffleWarning")
  [15:45:55.902]                         muffled <- TRUE
  [15:45:55.902]                       }
  [15:45:55.902]                       else if (inherits(cond, "condition")) {
  [15:45:55.902]                         computeRestarts <- base::computeRestarts
  [15:45:55.902]                         grepl <- base::grepl
  [15:45:55.902]                         is.null <- base::is.null
  [15:45:55.902]                         restarts <- computeRestarts(cond)
  [15:45:55.902]                         for (restart in restarts) {
  [15:45:55.902]                           name <- restart$name
  [15:45:55.902]                           if (is.null(name)) 
  [15:45:55.902]                             next
  [15:45:55.902]                           if (!grepl("^muffle", name)) 
  [15:45:55.902]                             next
  [15:45:55.902]                           invokeRestart(restart)
  [15:45:55.902]                           muffled <- TRUE
  [15:45:55.902]                           break
  [15:45:55.902]                         }
  [15:45:55.902]                       }
  [15:45:55.902]                       invisible(muffled)
  [15:45:55.902]                     }
  [15:45:55.902]                     muffleCondition(cond)
  [15:45:55.902]                   }
  [15:45:55.902]                 }
  [15:45:55.902]             }
  [15:45:55.902]         }))
  [15:45:55.902]     }, error = function(ex) {
  [15:45:55.902]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.902]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.902]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.902]     }, finally = {
  [15:45:55.902]         {
  [15:45:55.902]             NULL
  [15:45:55.902]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.902]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.902]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.902]                 label = NULL, ...) 
  [15:45:55.902]             {
  [15:45:55.902]                 if (substitute) 
  [15:45:55.902]                   expr <- substitute(expr)
  [15:45:55.902]                 local <- as.logical(local)
  [15:45:55.902]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.902]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.902]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.902]                   label = label, ...)
  [15:45:55.902]                 if (!future$lazy) 
  [15:45:55.902]                   future <- run(future)
  [15:45:55.902]                 invisible(future)
  [15:45:55.902]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.902]         }
  [15:45:55.902]         base::options(...future.oldOptions)
  [15:45:55.902]     })
  [15:45:55.902]     Sys.time
  [15:45:55.902]     if (base::is.na(TRUE)) {
  [15:45:55.902]     }
  [15:45:55.902]     else {
  [15:45:55.902]         base::sink(type = "output", split = FALSE)
  [15:45:55.902]         if (TRUE) {
  [15:45:55.902]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.902]         }
  [15:45:55.902]         else {
  [15:45:55.902]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.902]         }
  [15:45:55.902]         base::close(...future.stdout)
  [15:45:55.902]         ...future.stdout <- NULL
  [15:45:55.902]     }
  [15:45:55.902]     ...future.result$conditions <- ...future.conditions
  [15:45:55.902]     ...future.result
  [15:45:55.902] }
  [15:45:55.908] plan(): Setting new future strategy stack:
  [15:45:55.908] List of future strategies:
  [15:45:55.908] 1. sequential:
  [15:45:55.908]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.908]    - tweaked: FALSE
  [15:45:55.908]    - call: NULL
  [15:45:55.909] plan(): nbrOfWorkers() = 1
  [15:45:55.911] plan(): Setting new future strategy stack:
  [15:45:55.911] List of future strategies:
  [15:45:55.911] 1. sequential:
  [15:45:55.911]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.911]    - tweaked: FALSE
  [15:45:55.911]    - call: plan(strategy)
  [15:45:55.912] plan(): nbrOfWorkers() = 1
  [15:45:55.913] SequentialFuture started (and completed)
  [15:45:55.914] getGlobalsAndPackages() ...
  [15:45:55.915] Searching for globals...
  [15:45:55.916] - globals found: [1] '{'
  [15:45:55.917] Searching for globals ... DONE
  [15:45:55.917] Resolving globals: FALSE
  [15:45:55.918] 
  [15:45:55.918] 
  [15:45:55.919] getGlobalsAndPackages() ... DONE
  [15:45:55.921] Packages needed by the future expression (n = 0): <none>
  [15:45:55.922] Packages needed by future strategies (n = 0): <none>
  [15:45:55.929] {
  [15:45:55.929]     {
  [15:45:55.929]         ...future.startTime <- base::Sys.time()
  [15:45:55.929]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.929]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.929]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.929]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.929]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.929]         {
  [15:45:55.929]             {
  [15:45:55.929]                 base::local({
  [15:45:55.929]                   has_future <- base::requireNamespace("future", 
  [15:45:55.929]                     quietly = TRUE)
  [15:45:55.929]                   version <- if (has_future) 
  [15:45:55.929]                     utils::packageVersion("future")
  [15:45:55.929]                   else NULL
  [15:45:55.929]                   if (!has_future || version < "1.8.0") {
  [15:45:55.929]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.929]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.929]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.929]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.929]                         "release", "version")], collapse = " "), 
  [15:45:55.929]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.929]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.929]                       info)
  [15:45:55.929]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.929]                     if (!has_future) {
  [15:45:55.929]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.929]                         info)
  [15:45:55.929]                     }
  [15:45:55.929]                     else {
  [15:45:55.929]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.929]                         info, version)
  [15:45:55.929]                     }
  [15:45:55.929]                     base::stop(msg)
  [15:45:55.929]                   }
  [15:45:55.929]                 })
  [15:45:55.929]             }
  [15:45:55.929]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.929]         }
  [15:45:55.929]     }
  [15:45:55.929]     if (base::is.na(TRUE)) {
  [15:45:55.929]     }
  [15:45:55.929]     else {
  [15:45:55.929]         if (TRUE) {
  [15:45:55.929]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.929]                 open = "w")
  [15:45:55.929]         }
  [15:45:55.929]         else {
  [15:45:55.929]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.929]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.929]         }
  [15:45:55.929]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.929]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.929]             base::sink(type = "output", split = FALSE)
  [15:45:55.929]             base::close(...future.stdout)
  [15:45:55.929]         }, add = TRUE)
  [15:45:55.929]     }
  [15:45:55.929]     ...future.frame <- base::sys.nframe()
  [15:45:55.929]     ...future.conditions <- base::list()
  [15:45:55.929]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.929]     ...future.result <- base::tryCatch({
  [15:45:55.929]         base::withCallingHandlers({
  [15:45:55.929]             ...future.value <- base::withVisible(base::local({
  [15:45:55.929]                 4
  [15:45:55.929]             }))
  [15:45:55.929]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.929]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.929]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.929]                 version = "1.8")
  [15:45:55.929]         }, condition = base::local({
  [15:45:55.929]             c <- base::c
  [15:45:55.929]             inherits <- base::inherits
  [15:45:55.929]             invokeRestart <- base::invokeRestart
  [15:45:55.929]             length <- base::length
  [15:45:55.929]             list <- base::list
  [15:45:55.929]             seq.int <- base::seq.int
  [15:45:55.929]             signalCondition <- base::signalCondition
  [15:45:55.929]             sys.calls <- base::sys.calls
  [15:45:55.929]             Sys.time <- base::Sys.time
  [15:45:55.929]             `[[` <- base::`[[`
  [15:45:55.929]             `+` <- base::`+`
  [15:45:55.929]             `<<-` <- base::`<<-`
  [15:45:55.929]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.929]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.929]                   3L)]
  [15:45:55.929]             }
  [15:45:55.929]             function(cond) {
  [15:45:55.929]                 if (inherits(cond, "error")) {
  [15:45:55.929]                   sessionInformation <- function() {
  [15:45:55.929]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.929]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.929]                       search = base::search(), system = base::Sys.info())
  [15:45:55.929]                   }
  [15:45:55.929]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.929]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.929]                     cond$call), session = sessionInformation(), 
  [15:45:55.929]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.929]                   signalCondition(cond)
  [15:45:55.929]                 }
  [15:45:55.929]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.929]                 ))) {
  [15:45:55.929]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.929]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.929]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.929]                   if (!signal) {
  [15:45:55.929]                     muffleCondition <- function (cond) 
  [15:45:55.929]                     {
  [15:45:55.929]                       inherits <- base::inherits
  [15:45:55.929]                       invokeRestart <- base::invokeRestart
  [15:45:55.929]                       muffled <- FALSE
  [15:45:55.929]                       if (inherits(cond, "message")) {
  [15:45:55.929]                         invokeRestart("muffleMessage")
  [15:45:55.929]                         muffled <- TRUE
  [15:45:55.929]                       }
  [15:45:55.929]                       else if (inherits(cond, "warning")) {
  [15:45:55.929]                         invokeRestart("muffleWarning")
  [15:45:55.929]                         muffled <- TRUE
  [15:45:55.929]                       }
  [15:45:55.929]                       else if (inherits(cond, "condition")) {
  [15:45:55.929]                         computeRestarts <- base::computeRestarts
  [15:45:55.929]                         grepl <- base::grepl
  [15:45:55.929]                         is.null <- base::is.null
  [15:45:55.929]                         restarts <- computeRestarts(cond)
  [15:45:55.929]                         for (restart in restarts) {
  [15:45:55.929]                           name <- restart$name
  [15:45:55.929]                           if (is.null(name)) 
  [15:45:55.929]                             next
  [15:45:55.929]                           if (!grepl("^muffle", name)) 
  [15:45:55.929]                             next
  [15:45:55.929]                           invokeRestart(restart)
  [15:45:55.929]                           muffled <- TRUE
  [15:45:55.929]                           break
  [15:45:55.929]                         }
  [15:45:55.929]                       }
  [15:45:55.929]                       invisible(muffled)
  [15:45:55.929]                     }
  [15:45:55.929]                     muffleCondition(cond)
  [15:45:55.929]                   }
  [15:45:55.929]                 }
  [15:45:55.929]             }
  [15:45:55.929]         }))
  [15:45:55.929]     }, error = function(ex) {
  [15:45:55.929]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.929]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.929]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.929]     }, finally = {
  [15:45:55.929]         {
  [15:45:55.929]             NULL
  [15:45:55.929]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.929]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.929]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.929]                 label = NULL, ...) 
  [15:45:55.929]             {
  [15:45:55.929]                 if (substitute) 
  [15:45:55.929]                   expr <- substitute(expr)
  [15:45:55.929]                 local <- as.logical(local)
  [15:45:55.929]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.929]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.929]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.929]                   label = label, ...)
  [15:45:55.929]                 if (!future$lazy) 
  [15:45:55.929]                   future <- run(future)
  [15:45:55.929]                 invisible(future)
  [15:45:55.929]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.929]         }
  [15:45:55.929]         base::options(...future.oldOptions)
  [15:45:55.929]     })
  [15:45:55.929]     Sys.time
  [15:45:55.929]     if (base::is.na(TRUE)) {
  [15:45:55.929]     }
  [15:45:55.929]     else {
  [15:45:55.929]         base::sink(type = "output", split = FALSE)
  [15:45:55.929]         if (TRUE) {
  [15:45:55.929]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.929]         }
  [15:45:55.929]         else {
  [15:45:55.929]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.929]         }
  [15:45:55.929]         base::close(...future.stdout)
  [15:45:55.929]         ...future.stdout <- NULL
  [15:45:55.929]     }
  [15:45:55.929]     ...future.result$conditions <- ...future.conditions
  [15:45:55.929]     ...future.result
  [15:45:55.929] }
  [15:45:55.934] plan(): Setting new future strategy stack:
  [15:45:55.935] List of future strategies:
  [15:45:55.935] 1. sequential:
  [15:45:55.935]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.935]    - tweaked: FALSE
  [15:45:55.935]    - call: NULL
  [15:45:55.936] plan(): nbrOfWorkers() = 1
  [15:45:55.938] plan(): Setting new future strategy stack:
  [15:45:55.938] List of future strategies:
  [15:45:55.938] 1. sequential:
  [15:45:55.938]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:55.938]    - tweaked: FALSE
  [15:45:55.938]    - call: plan(strategy)
  [15:45:55.939] plan(): nbrOfWorkers() = 1
  [15:45:55.940] SequentialFuture started (and completed)
  <environment: 0x55ca29a55138> 
  <environment: 0x55ca2b13b2e0> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:55.951] resolve() on environment ...
  [15:45:55.951]  recursive: 0
  [15:45:55.953]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:55.954] signalConditionsASAP(numeric, pos=1) ...
  [15:45:55.954] - nx: 4
  [15:45:55.954] - relay: TRUE
  [15:45:55.955] - stdout: TRUE
  [15:45:55.955] - signal: TRUE
  [15:45:55.955] - resignal: FALSE
  [15:45:55.956] - force: TRUE
  [15:45:55.956] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.956] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.957]  - until=2
  [15:45:55.957]  - relaying element #2
  [15:45:55.958] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:55.958] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.958] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:55.959]  length: 3 (resolved future 1)
  [15:45:55.959] Future #2
  [15:45:55.960] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:55.960] - nx: 4
  [15:45:55.960] - relay: TRUE
  [15:45:55.961] - stdout: TRUE
  [15:45:55.961] - signal: TRUE
  [15:45:55.961] - resignal: FALSE
  [15:45:55.962] - force: TRUE
  [15:45:55.962] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:55.963] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:55.963]  - until=2
  [15:45:55.963]  - relaying element #2
  [15:45:55.964] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:55.964] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:55.965] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:55.965]  length: 2 (resolved future 2)
  [15:45:55.966] Future #3
  [15:45:55.966] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:55.966] - nx: 4
  [15:45:55.967] - relay: TRUE
  [15:45:55.967] - stdout: TRUE
  [15:45:55.967] - signal: TRUE
  [15:45:55.968] - resignal: FALSE
  [15:45:55.968] - force: TRUE
  [15:45:55.968] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:55.969] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:55.969]  - until=3
  [15:45:55.969]  - relaying element #3
  [15:45:55.970] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:55.971] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:55.971] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:55.971]  length: 1 (resolved future 3)
  [15:45:55.972] Future #4
  [15:45:55.972] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:55.973] - nx: 4
  [15:45:55.973] - relay: TRUE
  [15:45:55.973] - stdout: TRUE
  [15:45:55.974] - signal: TRUE
  [15:45:55.974] - resignal: FALSE
  [15:45:55.974] - force: TRUE
  [15:45:55.975] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:55.975] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:55.975]  - until=4
  [15:45:55.976]  - relaying element #4
  [15:45:55.976] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.977] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:55.977] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:55.977]  length: 0 (resolved future 4)
  [15:45:55.978] Relaying remaining futures
  [15:45:55.978] signalConditionsASAP(NULL, pos=0) ...
  [15:45:55.978] - nx: 4
  [15:45:55.979] - relay: TRUE
  [15:45:55.979] - stdout: TRUE
  [15:45:55.979] - signal: TRUE
  [15:45:55.980] - resignal: FALSE
  [15:45:55.980] - force: TRUE
  [15:45:55.980] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.981] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:55.981] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:55.982] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:55.982] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:55.983] resolve() on environment ... DONE
  <environment: 0x55ca2903f560> 
  Dimensions: c(2, 3)
  [15:45:55.984] getGlobalsAndPackages() ...
  [15:45:55.985] Searching for globals...
  [15:45:55.986] 
  [15:45:55.986] Searching for globals ... DONE
  [15:45:55.986] - globals: [0] <none>
  [15:45:55.987] getGlobalsAndPackages() ... DONE
  [15:45:55.989] Packages needed by the future expression (n = 0): <none>
  [15:45:55.990] Packages needed by future strategies (n = 0): <none>
  [15:45:55.996] {
  [15:45:55.996]     {
  [15:45:55.996]         ...future.startTime <- base::Sys.time()
  [15:45:55.996]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:55.996]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:55.996]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:55.996]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:55.996]             future.resolve.recursive = NULL, width = 80L)
  [15:45:55.996]         {
  [15:45:55.996]             {
  [15:45:55.996]                 base::local({
  [15:45:55.996]                   has_future <- base::requireNamespace("future", 
  [15:45:55.996]                     quietly = TRUE)
  [15:45:55.996]                   version <- if (has_future) 
  [15:45:55.996]                     utils::packageVersion("future")
  [15:45:55.996]                   else NULL
  [15:45:55.996]                   if (!has_future || version < "1.8.0") {
  [15:45:55.996]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:55.996]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:55.996]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:55.996]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:55.996]                         "release", "version")], collapse = " "), 
  [15:45:55.996]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:55.996]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:55.996]                       info)
  [15:45:55.996]                     info <- base::paste(info, collapse = "; ")
  [15:45:55.996]                     if (!has_future) {
  [15:45:55.996]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:55.996]                         info)
  [15:45:55.996]                     }
  [15:45:55.996]                     else {
  [15:45:55.996]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:55.996]                         info, version)
  [15:45:55.996]                     }
  [15:45:55.996]                     base::stop(msg)
  [15:45:55.996]                   }
  [15:45:55.996]                 })
  [15:45:55.996]             }
  [15:45:55.996]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:55.996]         }
  [15:45:55.996]     }
  [15:45:55.996]     if (base::is.na(TRUE)) {
  [15:45:55.996]     }
  [15:45:55.996]     else {
  [15:45:55.996]         if (TRUE) {
  [15:45:55.996]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:55.996]                 open = "w")
  [15:45:55.996]         }
  [15:45:55.996]         else {
  [15:45:55.996]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:55.996]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:55.996]         }
  [15:45:55.996]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:55.996]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:55.996]             base::sink(type = "output", split = FALSE)
  [15:45:55.996]             base::close(...future.stdout)
  [15:45:55.996]         }, add = TRUE)
  [15:45:55.996]     }
  [15:45:55.996]     ...future.frame <- base::sys.nframe()
  [15:45:55.996]     ...future.conditions <- base::list()
  [15:45:55.996]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:55.996]     ...future.result <- base::tryCatch({
  [15:45:55.996]         base::withCallingHandlers({
  [15:45:55.996]             ...future.value <- base::withVisible(base::local(2))
  [15:45:55.996]             future::FutureResult(value = ...future.value$value, 
  [15:45:55.996]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.996]                   ...future.rng), started = ...future.startTime, 
  [15:45:55.996]                 version = "1.8")
  [15:45:55.996]         }, condition = base::local({
  [15:45:55.996]             c <- base::c
  [15:45:55.996]             inherits <- base::inherits
  [15:45:55.996]             invokeRestart <- base::invokeRestart
  [15:45:55.996]             length <- base::length
  [15:45:55.996]             list <- base::list
  [15:45:55.996]             seq.int <- base::seq.int
  [15:45:55.996]             signalCondition <- base::signalCondition
  [15:45:55.996]             sys.calls <- base::sys.calls
  [15:45:55.996]             Sys.time <- base::Sys.time
  [15:45:55.996]             `[[` <- base::`[[`
  [15:45:55.996]             `+` <- base::`+`
  [15:45:55.996]             `<<-` <- base::`<<-`
  [15:45:55.996]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:55.996]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:55.996]                   3L)]
  [15:45:55.996]             }
  [15:45:55.996]             function(cond) {
  [15:45:55.996]                 if (inherits(cond, "error")) {
  [15:45:55.996]                   sessionInformation <- function() {
  [15:45:55.996]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:55.996]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:55.996]                       search = base::search(), system = base::Sys.info())
  [15:45:55.996]                   }
  [15:45:55.996]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.996]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:55.996]                     cond$call), session = sessionInformation(), 
  [15:45:55.996]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:55.996]                   signalCondition(cond)
  [15:45:55.996]                 }
  [15:45:55.996]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:55.996]                 ))) {
  [15:45:55.996]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:55.996]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:55.996]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:55.996]                   if (!signal) {
  [15:45:55.996]                     muffleCondition <- function (cond) 
  [15:45:55.996]                     {
  [15:45:55.996]                       inherits <- base::inherits
  [15:45:55.996]                       invokeRestart <- base::invokeRestart
  [15:45:55.996]                       muffled <- FALSE
  [15:45:55.996]                       if (inherits(cond, "message")) {
  [15:45:55.996]                         invokeRestart("muffleMessage")
  [15:45:55.996]                         muffled <- TRUE
  [15:45:55.996]                       }
  [15:45:55.996]                       else if (inherits(cond, "warning")) {
  [15:45:55.996]                         invokeRestart("muffleWarning")
  [15:45:55.996]                         muffled <- TRUE
  [15:45:55.996]                       }
  [15:45:55.996]                       else if (inherits(cond, "condition")) {
  [15:45:55.996]                         computeRestarts <- base::computeRestarts
  [15:45:55.996]                         grepl <- base::grepl
  [15:45:55.996]                         is.null <- base::is.null
  [15:45:55.996]                         restarts <- computeRestarts(cond)
  [15:45:55.996]                         for (restart in restarts) {
  [15:45:55.996]                           name <- restart$name
  [15:45:55.996]                           if (is.null(name)) 
  [15:45:55.996]                             next
  [15:45:55.996]                           if (!grepl("^muffle", name)) 
  [15:45:55.996]                             next
  [15:45:55.996]                           invokeRestart(restart)
  [15:45:55.996]                           muffled <- TRUE
  [15:45:55.996]                           break
  [15:45:55.996]                         }
  [15:45:55.996]                       }
  [15:45:55.996]                       invisible(muffled)
  [15:45:55.996]                     }
  [15:45:55.996]                     muffleCondition(cond)
  [15:45:55.996]                   }
  [15:45:55.996]                 }
  [15:45:55.996]             }
  [15:45:55.996]         }))
  [15:45:55.996]     }, error = function(ex) {
  [15:45:55.996]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:55.996]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:55.996]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:55.996]     }, finally = {
  [15:45:55.996]         {
  [15:45:55.996]             NULL
  [15:45:55.996]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:55.996]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:55.996]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:55.996]                 label = NULL, ...) 
  [15:45:55.996]             {
  [15:45:55.996]                 if (substitute) 
  [15:45:55.996]                   expr <- substitute(expr)
  [15:45:55.996]                 local <- as.logical(local)
  [15:45:55.996]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:55.996]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:55.996]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:55.996]                   label = label, ...)
  [15:45:55.996]                 if (!future$lazy) 
  [15:45:55.996]                   future <- run(future)
  [15:45:55.996]                 invisible(future)
  [15:45:55.996]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:55.996]         }
  [15:45:55.996]         base::options(...future.oldOptions)
  [15:45:55.996]     })
  [15:45:55.996]     Sys.time
  [15:45:55.996]     if (base::is.na(TRUE)) {
  [15:45:55.996]     }
  [15:45:55.996]     else {
  [15:45:55.996]         base::sink(type = "output", split = FALSE)
  [15:45:55.996]         if (TRUE) {
  [15:45:55.996]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:55.996]         }
  [15:45:55.996]         else {
  [15:45:55.996]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:55.996]         }
  [15:45:55.996]         base::close(...future.stdout)
  [15:45:55.996]         ...future.stdout <- NULL
  [15:45:55.996]     }
  [15:45:55.996]     ...future.result$conditions <- ...future.conditions
  [15:45:55.996]     ...future.result
  [15:45:55.996] }
  [15:45:56.002] plan(): Setting new future strategy stack:
  [15:45:56.002] List of future strategies:
  [15:45:56.002] 1. sequential:
  [15:45:56.002]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.002]    - tweaked: FALSE
  [15:45:56.002]    - call: NULL
  [15:45:56.003] plan(): nbrOfWorkers() = 1
  [15:45:56.005] plan(): Setting new future strategy stack:
  [15:45:56.005] List of future strategies:
  [15:45:56.005] 1. sequential:
  [15:45:56.005]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.005]    - tweaked: FALSE
  [15:45:56.005]    - call: plan(strategy)
  [15:45:56.007] plan(): nbrOfWorkers() = 1
  [15:45:56.007] SequentialFuture started (and completed)
  [15:45:56.008] getGlobalsAndPackages() ...
  [15:45:56.008] Searching for globals...
  [15:45:56.009] 
  [15:45:56.010] Searching for globals ... DONE
  [15:45:56.010] - globals: [0] <none>
  [15:45:56.010] getGlobalsAndPackages() ... DONE
  [15:45:56.013] Packages needed by the future expression (n = 0): <none>
  [15:45:56.013] Packages needed by future strategies (n = 0): <none>
  [15:45:56.020] {
  [15:45:56.020]     {
  [15:45:56.020]         ...future.startTime <- base::Sys.time()
  [15:45:56.020]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.020]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.020]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.020]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.020]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.020]         {
  [15:45:56.020]             {
  [15:45:56.020]                 base::local({
  [15:45:56.020]                   has_future <- base::requireNamespace("future", 
  [15:45:56.020]                     quietly = TRUE)
  [15:45:56.020]                   version <- if (has_future) 
  [15:45:56.020]                     utils::packageVersion("future")
  [15:45:56.020]                   else NULL
  [15:45:56.020]                   if (!has_future || version < "1.8.0") {
  [15:45:56.020]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.020]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.020]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.020]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.020]                         "release", "version")], collapse = " "), 
  [15:45:56.020]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.020]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.020]                       info)
  [15:45:56.020]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.020]                     if (!has_future) {
  [15:45:56.020]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.020]                         info)
  [15:45:56.020]                     }
  [15:45:56.020]                     else {
  [15:45:56.020]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.020]                         info, version)
  [15:45:56.020]                     }
  [15:45:56.020]                     base::stop(msg)
  [15:45:56.020]                   }
  [15:45:56.020]                 })
  [15:45:56.020]             }
  [15:45:56.020]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.020]         }
  [15:45:56.020]     }
  [15:45:56.020]     if (base::is.na(TRUE)) {
  [15:45:56.020]     }
  [15:45:56.020]     else {
  [15:45:56.020]         if (TRUE) {
  [15:45:56.020]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.020]                 open = "w")
  [15:45:56.020]         }
  [15:45:56.020]         else {
  [15:45:56.020]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.020]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.020]         }
  [15:45:56.020]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.020]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.020]             base::sink(type = "output", split = FALSE)
  [15:45:56.020]             base::close(...future.stdout)
  [15:45:56.020]         }, add = TRUE)
  [15:45:56.020]     }
  [15:45:56.020]     ...future.frame <- base::sys.nframe()
  [15:45:56.020]     ...future.conditions <- base::list()
  [15:45:56.020]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.020]     ...future.result <- base::tryCatch({
  [15:45:56.020]         base::withCallingHandlers({
  [15:45:56.020]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:56.020]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.020]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.020]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.020]                 version = "1.8")
  [15:45:56.020]         }, condition = base::local({
  [15:45:56.020]             c <- base::c
  [15:45:56.020]             inherits <- base::inherits
  [15:45:56.020]             invokeRestart <- base::invokeRestart
  [15:45:56.020]             length <- base::length
  [15:45:56.020]             list <- base::list
  [15:45:56.020]             seq.int <- base::seq.int
  [15:45:56.020]             signalCondition <- base::signalCondition
  [15:45:56.020]             sys.calls <- base::sys.calls
  [15:45:56.020]             Sys.time <- base::Sys.time
  [15:45:56.020]             `[[` <- base::`[[`
  [15:45:56.020]             `+` <- base::`+`
  [15:45:56.020]             `<<-` <- base::`<<-`
  [15:45:56.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.020]                   3L)]
  [15:45:56.020]             }
  [15:45:56.020]             function(cond) {
  [15:45:56.020]                 if (inherits(cond, "error")) {
  [15:45:56.020]                   sessionInformation <- function() {
  [15:45:56.020]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.020]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.020]                       search = base::search(), system = base::Sys.info())
  [15:45:56.020]                   }
  [15:45:56.020]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.020]                     cond$call), session = sessionInformation(), 
  [15:45:56.020]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.020]                   signalCondition(cond)
  [15:45:56.020]                 }
  [15:45:56.020]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.020]                 ))) {
  [15:45:56.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.020]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.020]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.020]                   if (!signal) {
  [15:45:56.020]                     muffleCondition <- function (cond) 
  [15:45:56.020]                     {
  [15:45:56.020]                       inherits <- base::inherits
  [15:45:56.020]                       invokeRestart <- base::invokeRestart
  [15:45:56.020]                       muffled <- FALSE
  [15:45:56.020]                       if (inherits(cond, "message")) {
  [15:45:56.020]                         invokeRestart("muffleMessage")
  [15:45:56.020]                         muffled <- TRUE
  [15:45:56.020]                       }
  [15:45:56.020]                       else if (inherits(cond, "warning")) {
  [15:45:56.020]                         invokeRestart("muffleWarning")
  [15:45:56.020]                         muffled <- TRUE
  [15:45:56.020]                       }
  [15:45:56.020]                       else if (inherits(cond, "condition")) {
  [15:45:56.020]                         computeRestarts <- base::computeRestarts
  [15:45:56.020]                         grepl <- base::grepl
  [15:45:56.020]                         is.null <- base::is.null
  [15:45:56.020]                         restarts <- computeRestarts(cond)
  [15:45:56.020]                         for (restart in restarts) {
  [15:45:56.020]                           name <- restart$name
  [15:45:56.020]                           if (is.null(name)) 
  [15:45:56.020]                             next
  [15:45:56.020]                           if (!grepl("^muffle", name)) 
  [15:45:56.020]                             next
  [15:45:56.020]                           invokeRestart(restart)
  [15:45:56.020]                           muffled <- TRUE
  [15:45:56.020]                           break
  [15:45:56.020]                         }
  [15:45:56.020]                       }
  [15:45:56.020]                       invisible(muffled)
  [15:45:56.020]                     }
  [15:45:56.020]                     muffleCondition(cond)
  [15:45:56.020]                   }
  [15:45:56.020]                 }
  [15:45:56.020]             }
  [15:45:56.020]         }))
  [15:45:56.020]     }, error = function(ex) {
  [15:45:56.020]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.020]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.020]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.020]     }, finally = {
  [15:45:56.020]         {
  [15:45:56.020]             NULL
  [15:45:56.020]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.020]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.020]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.020]                 label = NULL, ...) 
  [15:45:56.020]             {
  [15:45:56.020]                 if (substitute) 
  [15:45:56.020]                   expr <- substitute(expr)
  [15:45:56.020]                 local <- as.logical(local)
  [15:45:56.020]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.020]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.020]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.020]                   label = label, ...)
  [15:45:56.020]                 if (!future$lazy) 
  [15:45:56.020]                   future <- run(future)
  [15:45:56.020]                 invisible(future)
  [15:45:56.020]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.020]         }
  [15:45:56.020]         base::options(...future.oldOptions)
  [15:45:56.020]     })
  [15:45:56.020]     Sys.time
  [15:45:56.020]     if (base::is.na(TRUE)) {
  [15:45:56.020]     }
  [15:45:56.020]     else {
  [15:45:56.020]         base::sink(type = "output", split = FALSE)
  [15:45:56.020]         if (TRUE) {
  [15:45:56.020]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.020]         }
  [15:45:56.020]         else {
  [15:45:56.020]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.020]         }
  [15:45:56.020]         base::close(...future.stdout)
  [15:45:56.020]         ...future.stdout <- NULL
  [15:45:56.020]     }
  [15:45:56.020]     ...future.result$conditions <- ...future.conditions
  [15:45:56.020]     ...future.result
  [15:45:56.020] }
  [15:45:56.026] plan(): Setting new future strategy stack:
  [15:45:56.026] List of future strategies:
  [15:45:56.026] 1. sequential:
  [15:45:56.026]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.026]    - tweaked: FALSE
  [15:45:56.026]    - call: NULL
  [15:45:56.028] plan(): nbrOfWorkers() = 1
  [15:45:56.029] plan(): Setting new future strategy stack:
  [15:45:56.030] List of future strategies:
  [15:45:56.030] 1. sequential:
  [15:45:56.030]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.030]    - tweaked: FALSE
  [15:45:56.030]    - call: plan(strategy)
  [15:45:56.031] plan(): nbrOfWorkers() = 1
  [15:45:56.035] SequentialFuture started (and completed)
  [15:45:56.036] getGlobalsAndPackages() ...
  [15:45:56.037] Searching for globals...
  [15:45:56.038] - globals found: [1] '{'
  [15:45:56.039] Searching for globals ... DONE
  [15:45:56.039] Resolving globals: FALSE
  [15:45:56.040] 
  [15:45:56.041] 
  [15:45:56.041] getGlobalsAndPackages() ... DONE
  [15:45:56.044] Packages needed by the future expression (n = 0): <none>
  [15:45:56.044] Packages needed by future strategies (n = 0): <none>
  [15:45:56.051] {
  [15:45:56.051]     {
  [15:45:56.051]         ...future.startTime <- base::Sys.time()
  [15:45:56.051]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.051]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.051]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.051]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.051]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.051]         {
  [15:45:56.051]             {
  [15:45:56.051]                 base::local({
  [15:45:56.051]                   has_future <- base::requireNamespace("future", 
  [15:45:56.051]                     quietly = TRUE)
  [15:45:56.051]                   version <- if (has_future) 
  [15:45:56.051]                     utils::packageVersion("future")
  [15:45:56.051]                   else NULL
  [15:45:56.051]                   if (!has_future || version < "1.8.0") {
  [15:45:56.051]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.051]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.051]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.051]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.051]                         "release", "version")], collapse = " "), 
  [15:45:56.051]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.051]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.051]                       info)
  [15:45:56.051]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.051]                     if (!has_future) {
  [15:45:56.051]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.051]                         info)
  [15:45:56.051]                     }
  [15:45:56.051]                     else {
  [15:45:56.051]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.051]                         info, version)
  [15:45:56.051]                     }
  [15:45:56.051]                     base::stop(msg)
  [15:45:56.051]                   }
  [15:45:56.051]                 })
  [15:45:56.051]             }
  [15:45:56.051]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.051]         }
  [15:45:56.051]     }
  [15:45:56.051]     if (base::is.na(TRUE)) {
  [15:45:56.051]     }
  [15:45:56.051]     else {
  [15:45:56.051]         if (TRUE) {
  [15:45:56.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.051]                 open = "w")
  [15:45:56.051]         }
  [15:45:56.051]         else {
  [15:45:56.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.051]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.051]         }
  [15:45:56.051]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.051]             base::sink(type = "output", split = FALSE)
  [15:45:56.051]             base::close(...future.stdout)
  [15:45:56.051]         }, add = TRUE)
  [15:45:56.051]     }
  [15:45:56.051]     ...future.frame <- base::sys.nframe()
  [15:45:56.051]     ...future.conditions <- base::list()
  [15:45:56.051]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.051]     ...future.result <- base::tryCatch({
  [15:45:56.051]         base::withCallingHandlers({
  [15:45:56.051]             ...future.value <- base::withVisible(base::local({
  [15:45:56.051]                 4
  [15:45:56.051]             }))
  [15:45:56.051]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.051]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.051]                 version = "1.8")
  [15:45:56.051]         }, condition = base::local({
  [15:45:56.051]             c <- base::c
  [15:45:56.051]             inherits <- base::inherits
  [15:45:56.051]             invokeRestart <- base::invokeRestart
  [15:45:56.051]             length <- base::length
  [15:45:56.051]             list <- base::list
  [15:45:56.051]             seq.int <- base::seq.int
  [15:45:56.051]             signalCondition <- base::signalCondition
  [15:45:56.051]             sys.calls <- base::sys.calls
  [15:45:56.051]             Sys.time <- base::Sys.time
  [15:45:56.051]             `[[` <- base::`[[`
  [15:45:56.051]             `+` <- base::`+`
  [15:45:56.051]             `<<-` <- base::`<<-`
  [15:45:56.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.051]                   3L)]
  [15:45:56.051]             }
  [15:45:56.051]             function(cond) {
  [15:45:56.051]                 if (inherits(cond, "error")) {
  [15:45:56.051]                   sessionInformation <- function() {
  [15:45:56.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.051]                       search = base::search(), system = base::Sys.info())
  [15:45:56.051]                   }
  [15:45:56.051]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.051]                     cond$call), session = sessionInformation(), 
  [15:45:56.051]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.051]                   signalCondition(cond)
  [15:45:56.051]                 }
  [15:45:56.051]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.051]                 ))) {
  [15:45:56.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.051]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.051]                   if (!signal) {
  [15:45:56.051]                     muffleCondition <- function (cond) 
  [15:45:56.051]                     {
  [15:45:56.051]                       inherits <- base::inherits
  [15:45:56.051]                       invokeRestart <- base::invokeRestart
  [15:45:56.051]                       muffled <- FALSE
  [15:45:56.051]                       if (inherits(cond, "message")) {
  [15:45:56.051]                         invokeRestart("muffleMessage")
  [15:45:56.051]                         muffled <- TRUE
  [15:45:56.051]                       }
  [15:45:56.051]                       else if (inherits(cond, "warning")) {
  [15:45:56.051]                         invokeRestart("muffleWarning")
  [15:45:56.051]                         muffled <- TRUE
  [15:45:56.051]                       }
  [15:45:56.051]                       else if (inherits(cond, "condition")) {
  [15:45:56.051]                         computeRestarts <- base::computeRestarts
  [15:45:56.051]                         grepl <- base::grepl
  [15:45:56.051]                         is.null <- base::is.null
  [15:45:56.051]                         restarts <- computeRestarts(cond)
  [15:45:56.051]                         for (restart in restarts) {
  [15:45:56.051]                           name <- restart$name
  [15:45:56.051]                           if (is.null(name)) 
  [15:45:56.051]                             next
  [15:45:56.051]                           if (!grepl("^muffle", name)) 
  [15:45:56.051]                             next
  [15:45:56.051]                           invokeRestart(restart)
  [15:45:56.051]                           muffled <- TRUE
  [15:45:56.051]                           break
  [15:45:56.051]                         }
  [15:45:56.051]                       }
  [15:45:56.051]                       invisible(muffled)
  [15:45:56.051]                     }
  [15:45:56.051]                     muffleCondition(cond)
  [15:45:56.051]                   }
  [15:45:56.051]                 }
  [15:45:56.051]             }
  [15:45:56.051]         }))
  [15:45:56.051]     }, error = function(ex) {
  [15:45:56.051]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.051]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.051]     }, finally = {
  [15:45:56.051]         {
  [15:45:56.051]             NULL
  [15:45:56.051]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.051]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.051]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.051]                 label = NULL, ...) 
  [15:45:56.051]             {
  [15:45:56.051]                 if (substitute) 
  [15:45:56.051]                   expr <- substitute(expr)
  [15:45:56.051]                 local <- as.logical(local)
  [15:45:56.051]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.051]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.051]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.051]                   label = label, ...)
  [15:45:56.051]                 if (!future$lazy) 
  [15:45:56.051]                   future <- run(future)
  [15:45:56.051]                 invisible(future)
  [15:45:56.051]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.051]         }
  [15:45:56.051]         base::options(...future.oldOptions)
  [15:45:56.051]     })
  [15:45:56.051]     Sys.time
  [15:45:56.051]     if (base::is.na(TRUE)) {
  [15:45:56.051]     }
  [15:45:56.051]     else {
  [15:45:56.051]         base::sink(type = "output", split = FALSE)
  [15:45:56.051]         if (TRUE) {
  [15:45:56.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.051]         }
  [15:45:56.051]         else {
  [15:45:56.051]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.051]         }
  [15:45:56.051]         base::close(...future.stdout)
  [15:45:56.051]         ...future.stdout <- NULL
  [15:45:56.051]     }
  [15:45:56.051]     ...future.result$conditions <- ...future.conditions
  [15:45:56.051]     ...future.result
  [15:45:56.051] }
  [15:45:56.057] plan(): Setting new future strategy stack:
  [15:45:56.057] List of future strategies:
  [15:45:56.057] 1. sequential:
  [15:45:56.057]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.057]    - tweaked: FALSE
  [15:45:56.057]    - call: NULL
  [15:45:56.058] plan(): nbrOfWorkers() = 1
  [15:45:56.060] plan(): Setting new future strategy stack:
  [15:45:56.060] List of future strategies:
  [15:45:56.060] 1. sequential:
  [15:45:56.060]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.060]    - tweaked: FALSE
  [15:45:56.060]    - call: plan(strategy)
  [15:45:56.061] plan(): nbrOfWorkers() = 1
  [15:45:56.062] SequentialFuture started (and completed)
  <environment: 0x55ca2a5266e8> 
  <environment: 0x55ca2971b850> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:56.070] resolve() on environment ...
  [15:45:56.070]  recursive: 0
  [15:45:56.072]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:56.073] signalConditionsASAP(numeric, pos=1) ...
  [15:45:56.073] - nx: 4
  [15:45:56.073] - relay: TRUE
  [15:45:56.074] - stdout: TRUE
  [15:45:56.074] - signal: TRUE
  [15:45:56.074] - resignal: FALSE
  [15:45:56.075] - force: TRUE
  [15:45:56.075] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.075] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.076]  - until=2
  [15:45:56.076]  - relaying element #2
  [15:45:56.076] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.077] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.077] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:56.077]  length: 3 (resolved future 1)
  [15:45:56.078] Future #2
  [15:45:56.080] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:56.080] - nx: 4
  [15:45:56.080] - relay: TRUE
  [15:45:56.081] - stdout: TRUE
  [15:45:56.081] - signal: TRUE
  [15:45:56.081] - resignal: FALSE
  [15:45:56.082] - force: TRUE
  [15:45:56.082] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.082] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.083]  - until=2
  [15:45:56.084]  - relaying element #2
  [15:45:56.085] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.085] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.086] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:56.086]  length: 2 (resolved future 2)
  [15:45:56.086] Future #3
  [15:45:56.087] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:56.087] - nx: 4
  [15:45:56.088] - relay: TRUE
  [15:45:56.088] - stdout: TRUE
  [15:45:56.088] - signal: TRUE
  [15:45:56.089] - resignal: FALSE
  [15:45:56.089] - force: TRUE
  [15:45:56.089] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.090] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.090]  - until=3
  [15:45:56.090]  - relaying element #3
  [15:45:56.091] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.091] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.092] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:56.092]  length: 1 (resolved future 3)
  [15:45:56.092] Future #4
  [15:45:56.093] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:56.093] - nx: 4
  [15:45:56.094] - relay: TRUE
  [15:45:56.094] - stdout: TRUE
  [15:45:56.094] - signal: TRUE
  [15:45:56.095] - resignal: FALSE
  [15:45:56.095] - force: TRUE
  [15:45:56.095] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.096] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.096]  - until=4
  [15:45:56.096]  - relaying element #4
  [15:45:56.097] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.097] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.098] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:56.098]  length: 0 (resolved future 4)
  [15:45:56.099] Relaying remaining futures
  [15:45:56.099] signalConditionsASAP(NULL, pos=0) ...
  [15:45:56.099] - nx: 4
  [15:45:56.100] - relay: TRUE
  [15:45:56.100] - stdout: TRUE
  [15:45:56.100] - signal: TRUE
  [15:45:56.101] - resignal: FALSE
  [15:45:56.101] - force: TRUE
  [15:45:56.101] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.102] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:56.102] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.103] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.103] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:56.103] resolve() on environment ... DONE
  <environment: 0x55ca2a4d6f98> 
  Dimensions: c(2, 3, 1)
  [15:45:56.105] getGlobalsAndPackages() ...
  [15:45:56.105] Searching for globals...
  [15:45:56.106] 
  [15:45:56.107] Searching for globals ... DONE
  [15:45:56.107] - globals: [0] <none>
  [15:45:56.107] getGlobalsAndPackages() ... DONE
  [15:45:56.110] Packages needed by the future expression (n = 0): <none>
  [15:45:56.110] Packages needed by future strategies (n = 0): <none>
  [15:45:56.117] {
  [15:45:56.117]     {
  [15:45:56.117]         ...future.startTime <- base::Sys.time()
  [15:45:56.117]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.117]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.117]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.117]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.117]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.117]         {
  [15:45:56.117]             {
  [15:45:56.117]                 base::local({
  [15:45:56.117]                   has_future <- base::requireNamespace("future", 
  [15:45:56.117]                     quietly = TRUE)
  [15:45:56.117]                   version <- if (has_future) 
  [15:45:56.117]                     utils::packageVersion("future")
  [15:45:56.117]                   else NULL
  [15:45:56.117]                   if (!has_future || version < "1.8.0") {
  [15:45:56.117]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.117]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.117]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.117]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.117]                         "release", "version")], collapse = " "), 
  [15:45:56.117]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.117]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.117]                       info)
  [15:45:56.117]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.117]                     if (!has_future) {
  [15:45:56.117]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.117]                         info)
  [15:45:56.117]                     }
  [15:45:56.117]                     else {
  [15:45:56.117]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.117]                         info, version)
  [15:45:56.117]                     }
  [15:45:56.117]                     base::stop(msg)
  [15:45:56.117]                   }
  [15:45:56.117]                 })
  [15:45:56.117]             }
  [15:45:56.117]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.117]         }
  [15:45:56.117]     }
  [15:45:56.117]     if (base::is.na(TRUE)) {
  [15:45:56.117]     }
  [15:45:56.117]     else {
  [15:45:56.117]         if (TRUE) {
  [15:45:56.117]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.117]                 open = "w")
  [15:45:56.117]         }
  [15:45:56.117]         else {
  [15:45:56.117]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.117]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.117]         }
  [15:45:56.117]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.117]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.117]             base::sink(type = "output", split = FALSE)
  [15:45:56.117]             base::close(...future.stdout)
  [15:45:56.117]         }, add = TRUE)
  [15:45:56.117]     }
  [15:45:56.117]     ...future.frame <- base::sys.nframe()
  [15:45:56.117]     ...future.conditions <- base::list()
  [15:45:56.117]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.117]     ...future.result <- base::tryCatch({
  [15:45:56.117]         base::withCallingHandlers({
  [15:45:56.117]             ...future.value <- base::withVisible(base::local(2))
  [15:45:56.117]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.117]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.117]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.117]                 version = "1.8")
  [15:45:56.117]         }, condition = base::local({
  [15:45:56.117]             c <- base::c
  [15:45:56.117]             inherits <- base::inherits
  [15:45:56.117]             invokeRestart <- base::invokeRestart
  [15:45:56.117]             length <- base::length
  [15:45:56.117]             list <- base::list
  [15:45:56.117]             seq.int <- base::seq.int
  [15:45:56.117]             signalCondition <- base::signalCondition
  [15:45:56.117]             sys.calls <- base::sys.calls
  [15:45:56.117]             Sys.time <- base::Sys.time
  [15:45:56.117]             `[[` <- base::`[[`
  [15:45:56.117]             `+` <- base::`+`
  [15:45:56.117]             `<<-` <- base::`<<-`
  [15:45:56.117]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.117]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.117]                   3L)]
  [15:45:56.117]             }
  [15:45:56.117]             function(cond) {
  [15:45:56.117]                 if (inherits(cond, "error")) {
  [15:45:56.117]                   sessionInformation <- function() {
  [15:45:56.117]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.117]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.117]                       search = base::search(), system = base::Sys.info())
  [15:45:56.117]                   }
  [15:45:56.117]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.117]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.117]                     cond$call), session = sessionInformation(), 
  [15:45:56.117]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.117]                   signalCondition(cond)
  [15:45:56.117]                 }
  [15:45:56.117]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.117]                 ))) {
  [15:45:56.117]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.117]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.117]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.117]                   if (!signal) {
  [15:45:56.117]                     muffleCondition <- function (cond) 
  [15:45:56.117]                     {
  [15:45:56.117]                       inherits <- base::inherits
  [15:45:56.117]                       invokeRestart <- base::invokeRestart
  [15:45:56.117]                       muffled <- FALSE
  [15:45:56.117]                       if (inherits(cond, "message")) {
  [15:45:56.117]                         invokeRestart("muffleMessage")
  [15:45:56.117]                         muffled <- TRUE
  [15:45:56.117]                       }
  [15:45:56.117]                       else if (inherits(cond, "warning")) {
  [15:45:56.117]                         invokeRestart("muffleWarning")
  [15:45:56.117]                         muffled <- TRUE
  [15:45:56.117]                       }
  [15:45:56.117]                       else if (inherits(cond, "condition")) {
  [15:45:56.117]                         computeRestarts <- base::computeRestarts
  [15:45:56.117]                         grepl <- base::grepl
  [15:45:56.117]                         is.null <- base::is.null
  [15:45:56.117]                         restarts <- computeRestarts(cond)
  [15:45:56.117]                         for (restart in restarts) {
  [15:45:56.117]                           name <- restart$name
  [15:45:56.117]                           if (is.null(name)) 
  [15:45:56.117]                             next
  [15:45:56.117]                           if (!grepl("^muffle", name)) 
  [15:45:56.117]                             next
  [15:45:56.117]                           invokeRestart(restart)
  [15:45:56.117]                           muffled <- TRUE
  [15:45:56.117]                           break
  [15:45:56.117]                         }
  [15:45:56.117]                       }
  [15:45:56.117]                       invisible(muffled)
  [15:45:56.117]                     }
  [15:45:56.117]                     muffleCondition(cond)
  [15:45:56.117]                   }
  [15:45:56.117]                 }
  [15:45:56.117]             }
  [15:45:56.117]         }))
  [15:45:56.117]     }, error = function(ex) {
  [15:45:56.117]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.117]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.117]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.117]     }, finally = {
  [15:45:56.117]         {
  [15:45:56.117]             NULL
  [15:45:56.117]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.117]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.117]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.117]                 label = NULL, ...) 
  [15:45:56.117]             {
  [15:45:56.117]                 if (substitute) 
  [15:45:56.117]                   expr <- substitute(expr)
  [15:45:56.117]                 local <- as.logical(local)
  [15:45:56.117]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.117]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.117]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.117]                   label = label, ...)
  [15:45:56.117]                 if (!future$lazy) 
  [15:45:56.117]                   future <- run(future)
  [15:45:56.117]                 invisible(future)
  [15:45:56.117]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.117]         }
  [15:45:56.117]         base::options(...future.oldOptions)
  [15:45:56.117]     })
  [15:45:56.117]     Sys.time
  [15:45:56.117]     if (base::is.na(TRUE)) {
  [15:45:56.117]     }
  [15:45:56.117]     else {
  [15:45:56.117]         base::sink(type = "output", split = FALSE)
  [15:45:56.117]         if (TRUE) {
  [15:45:56.117]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.117]         }
  [15:45:56.117]         else {
  [15:45:56.117]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.117]         }
  [15:45:56.117]         base::close(...future.stdout)
  [15:45:56.117]         ...future.stdout <- NULL
  [15:45:56.117]     }
  [15:45:56.117]     ...future.result$conditions <- ...future.conditions
  [15:45:56.117]     ...future.result
  [15:45:56.117] }
  [15:45:56.126] plan(): Setting new future strategy stack:
  [15:45:56.126] List of future strategies:
  [15:45:56.126] 1. sequential:
  [15:45:56.126]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.126]    - tweaked: FALSE
  [15:45:56.126]    - call: NULL
  [15:45:56.129] plan(): nbrOfWorkers() = 1
  [15:45:56.130] plan(): Setting new future strategy stack:
  [15:45:56.131] List of future strategies:
  [15:45:56.131] 1. sequential:
  [15:45:56.131]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.131]    - tweaked: FALSE
  [15:45:56.131]    - call: plan(strategy)
  [15:45:56.132] plan(): nbrOfWorkers() = 1
  [15:45:56.133] SequentialFuture started (and completed)
  [15:45:56.133] getGlobalsAndPackages() ...
  [15:45:56.134] Searching for globals...
  [15:45:56.134] 
  [15:45:56.135] Searching for globals ... DONE
  [15:45:56.135] - globals: [0] <none>
  [15:45:56.136] getGlobalsAndPackages() ... DONE
  [15:45:56.138] Packages needed by the future expression (n = 0): <none>
  [15:45:56.138] Packages needed by future strategies (n = 0): <none>
  [15:45:56.145] {
  [15:45:56.145]     {
  [15:45:56.145]         ...future.startTime <- base::Sys.time()
  [15:45:56.145]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.145]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.145]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.145]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.145]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.145]         {
  [15:45:56.145]             {
  [15:45:56.145]                 base::local({
  [15:45:56.145]                   has_future <- base::requireNamespace("future", 
  [15:45:56.145]                     quietly = TRUE)
  [15:45:56.145]                   version <- if (has_future) 
  [15:45:56.145]                     utils::packageVersion("future")
  [15:45:56.145]                   else NULL
  [15:45:56.145]                   if (!has_future || version < "1.8.0") {
  [15:45:56.145]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.145]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.145]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.145]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.145]                         "release", "version")], collapse = " "), 
  [15:45:56.145]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.145]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.145]                       info)
  [15:45:56.145]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.145]                     if (!has_future) {
  [15:45:56.145]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.145]                         info)
  [15:45:56.145]                     }
  [15:45:56.145]                     else {
  [15:45:56.145]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.145]                         info, version)
  [15:45:56.145]                     }
  [15:45:56.145]                     base::stop(msg)
  [15:45:56.145]                   }
  [15:45:56.145]                 })
  [15:45:56.145]             }
  [15:45:56.145]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.145]         }
  [15:45:56.145]     }
  [15:45:56.145]     if (base::is.na(TRUE)) {
  [15:45:56.145]     }
  [15:45:56.145]     else {
  [15:45:56.145]         if (TRUE) {
  [15:45:56.145]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.145]                 open = "w")
  [15:45:56.145]         }
  [15:45:56.145]         else {
  [15:45:56.145]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.145]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.145]         }
  [15:45:56.145]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.145]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.145]             base::sink(type = "output", split = FALSE)
  [15:45:56.145]             base::close(...future.stdout)
  [15:45:56.145]         }, add = TRUE)
  [15:45:56.145]     }
  [15:45:56.145]     ...future.frame <- base::sys.nframe()
  [15:45:56.145]     ...future.conditions <- base::list()
  [15:45:56.145]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.145]     ...future.result <- base::tryCatch({
  [15:45:56.145]         base::withCallingHandlers({
  [15:45:56.145]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:56.145]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.145]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.145]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.145]                 version = "1.8")
  [15:45:56.145]         }, condition = base::local({
  [15:45:56.145]             c <- base::c
  [15:45:56.145]             inherits <- base::inherits
  [15:45:56.145]             invokeRestart <- base::invokeRestart
  [15:45:56.145]             length <- base::length
  [15:45:56.145]             list <- base::list
  [15:45:56.145]             seq.int <- base::seq.int
  [15:45:56.145]             signalCondition <- base::signalCondition
  [15:45:56.145]             sys.calls <- base::sys.calls
  [15:45:56.145]             Sys.time <- base::Sys.time
  [15:45:56.145]             `[[` <- base::`[[`
  [15:45:56.145]             `+` <- base::`+`
  [15:45:56.145]             `<<-` <- base::`<<-`
  [15:45:56.145]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.145]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.145]                   3L)]
  [15:45:56.145]             }
  [15:45:56.145]             function(cond) {
  [15:45:56.145]                 if (inherits(cond, "error")) {
  [15:45:56.145]                   sessionInformation <- function() {
  [15:45:56.145]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.145]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.145]                       search = base::search(), system = base::Sys.info())
  [15:45:56.145]                   }
  [15:45:56.145]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.145]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.145]                     cond$call), session = sessionInformation(), 
  [15:45:56.145]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.145]                   signalCondition(cond)
  [15:45:56.145]                 }
  [15:45:56.145]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.145]                 ))) {
  [15:45:56.145]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.145]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.145]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.145]                   if (!signal) {
  [15:45:56.145]                     muffleCondition <- function (cond) 
  [15:45:56.145]                     {
  [15:45:56.145]                       inherits <- base::inherits
  [15:45:56.145]                       invokeRestart <- base::invokeRestart
  [15:45:56.145]                       muffled <- FALSE
  [15:45:56.145]                       if (inherits(cond, "message")) {
  [15:45:56.145]                         invokeRestart("muffleMessage")
  [15:45:56.145]                         muffled <- TRUE
  [15:45:56.145]                       }
  [15:45:56.145]                       else if (inherits(cond, "warning")) {
  [15:45:56.145]                         invokeRestart("muffleWarning")
  [15:45:56.145]                         muffled <- TRUE
  [15:45:56.145]                       }
  [15:45:56.145]                       else if (inherits(cond, "condition")) {
  [15:45:56.145]                         computeRestarts <- base::computeRestarts
  [15:45:56.145]                         grepl <- base::grepl
  [15:45:56.145]                         is.null <- base::is.null
  [15:45:56.145]                         restarts <- computeRestarts(cond)
  [15:45:56.145]                         for (restart in restarts) {
  [15:45:56.145]                           name <- restart$name
  [15:45:56.145]                           if (is.null(name)) 
  [15:45:56.145]                             next
  [15:45:56.145]                           if (!grepl("^muffle", name)) 
  [15:45:56.145]                             next
  [15:45:56.145]                           invokeRestart(restart)
  [15:45:56.145]                           muffled <- TRUE
  [15:45:56.145]                           break
  [15:45:56.145]                         }
  [15:45:56.145]                       }
  [15:45:56.145]                       invisible(muffled)
  [15:45:56.145]                     }
  [15:45:56.145]                     muffleCondition(cond)
  [15:45:56.145]                   }
  [15:45:56.145]                 }
  [15:45:56.145]             }
  [15:45:56.145]         }))
  [15:45:56.145]     }, error = function(ex) {
  [15:45:56.145]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.145]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.145]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.145]     }, finally = {
  [15:45:56.145]         {
  [15:45:56.145]             NULL
  [15:45:56.145]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.145]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.145]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.145]                 label = NULL, ...) 
  [15:45:56.145]             {
  [15:45:56.145]                 if (substitute) 
  [15:45:56.145]                   expr <- substitute(expr)
  [15:45:56.145]                 local <- as.logical(local)
  [15:45:56.145]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.145]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.145]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.145]                   label = label, ...)
  [15:45:56.145]                 if (!future$lazy) 
  [15:45:56.145]                   future <- run(future)
  [15:45:56.145]                 invisible(future)
  [15:45:56.145]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.145]         }
  [15:45:56.145]         base::options(...future.oldOptions)
  [15:45:56.145]     })
  [15:45:56.145]     Sys.time
  [15:45:56.145]     if (base::is.na(TRUE)) {
  [15:45:56.145]     }
  [15:45:56.145]     else {
  [15:45:56.145]         base::sink(type = "output", split = FALSE)
  [15:45:56.145]         if (TRUE) {
  [15:45:56.145]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.145]         }
  [15:45:56.145]         else {
  [15:45:56.145]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.145]         }
  [15:45:56.145]         base::close(...future.stdout)
  [15:45:56.145]         ...future.stdout <- NULL
  [15:45:56.145]     }
  [15:45:56.145]     ...future.result$conditions <- ...future.conditions
  [15:45:56.145]     ...future.result
  [15:45:56.145] }
  [15:45:56.150] plan(): Setting new future strategy stack:
  [15:45:56.151] List of future strategies:
  [15:45:56.151] 1. sequential:
  [15:45:56.151]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.151]    - tweaked: FALSE
  [15:45:56.151]    - call: NULL
  [15:45:56.152] plan(): nbrOfWorkers() = 1
  [15:45:56.153] plan(): Setting new future strategy stack:
  [15:45:56.154] List of future strategies:
  [15:45:56.154] 1. sequential:
  [15:45:56.154]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.154]    - tweaked: FALSE
  [15:45:56.154]    - call: plan(strategy)
  [15:45:56.155] plan(): nbrOfWorkers() = 1
  [15:45:56.156] SequentialFuture started (and completed)
  [15:45:56.157] getGlobalsAndPackages() ...
  [15:45:56.157] Searching for globals...
  [15:45:56.158] - globals found: [1] '{'
  [15:45:56.159] Searching for globals ... DONE
  [15:45:56.159] Resolving globals: FALSE
  [15:45:56.160] 
  [15:45:56.161] 
  [15:45:56.161] getGlobalsAndPackages() ... DONE
  [15:45:56.163] Packages needed by the future expression (n = 0): <none>
  [15:45:56.164] Packages needed by future strategies (n = 0): <none>
  [15:45:56.170] {
  [15:45:56.170]     {
  [15:45:56.170]         ...future.startTime <- base::Sys.time()
  [15:45:56.170]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.170]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.170]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.170]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.170]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.170]         {
  [15:45:56.170]             {
  [15:45:56.170]                 base::local({
  [15:45:56.170]                   has_future <- base::requireNamespace("future", 
  [15:45:56.170]                     quietly = TRUE)
  [15:45:56.170]                   version <- if (has_future) 
  [15:45:56.170]                     utils::packageVersion("future")
  [15:45:56.170]                   else NULL
  [15:45:56.170]                   if (!has_future || version < "1.8.0") {
  [15:45:56.170]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.170]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.170]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.170]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.170]                         "release", "version")], collapse = " "), 
  [15:45:56.170]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.170]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.170]                       info)
  [15:45:56.170]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.170]                     if (!has_future) {
  [15:45:56.170]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.170]                         info)
  [15:45:56.170]                     }
  [15:45:56.170]                     else {
  [15:45:56.170]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.170]                         info, version)
  [15:45:56.170]                     }
  [15:45:56.170]                     base::stop(msg)
  [15:45:56.170]                   }
  [15:45:56.170]                 })
  [15:45:56.170]             }
  [15:45:56.170]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.170]         }
  [15:45:56.170]     }
  [15:45:56.170]     if (base::is.na(TRUE)) {
  [15:45:56.170]     }
  [15:45:56.170]     else {
  [15:45:56.170]         if (TRUE) {
  [15:45:56.170]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.170]                 open = "w")
  [15:45:56.170]         }
  [15:45:56.170]         else {
  [15:45:56.170]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.170]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.170]         }
  [15:45:56.170]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.170]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.170]             base::sink(type = "output", split = FALSE)
  [15:45:56.170]             base::close(...future.stdout)
  [15:45:56.170]         }, add = TRUE)
  [15:45:56.170]     }
  [15:45:56.170]     ...future.frame <- base::sys.nframe()
  [15:45:56.170]     ...future.conditions <- base::list()
  [15:45:56.170]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.170]     ...future.result <- base::tryCatch({
  [15:45:56.170]         base::withCallingHandlers({
  [15:45:56.170]             ...future.value <- base::withVisible(base::local({
  [15:45:56.170]                 4
  [15:45:56.170]             }))
  [15:45:56.170]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.170]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.170]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.170]                 version = "1.8")
  [15:45:56.170]         }, condition = base::local({
  [15:45:56.170]             c <- base::c
  [15:45:56.170]             inherits <- base::inherits
  [15:45:56.170]             invokeRestart <- base::invokeRestart
  [15:45:56.170]             length <- base::length
  [15:45:56.170]             list <- base::list
  [15:45:56.170]             seq.int <- base::seq.int
  [15:45:56.170]             signalCondition <- base::signalCondition
  [15:45:56.170]             sys.calls <- base::sys.calls
  [15:45:56.170]             Sys.time <- base::Sys.time
  [15:45:56.170]             `[[` <- base::`[[`
  [15:45:56.170]             `+` <- base::`+`
  [15:45:56.170]             `<<-` <- base::`<<-`
  [15:45:56.170]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.170]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.170]                   3L)]
  [15:45:56.170]             }
  [15:45:56.170]             function(cond) {
  [15:45:56.170]                 if (inherits(cond, "error")) {
  [15:45:56.170]                   sessionInformation <- function() {
  [15:45:56.170]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.170]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.170]                       search = base::search(), system = base::Sys.info())
  [15:45:56.170]                   }
  [15:45:56.170]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.170]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.170]                     cond$call), session = sessionInformation(), 
  [15:45:56.170]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.170]                   signalCondition(cond)
  [15:45:56.170]                 }
  [15:45:56.170]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.170]                 ))) {
  [15:45:56.170]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.170]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.170]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.170]                   if (!signal) {
  [15:45:56.170]                     muffleCondition <- function (cond) 
  [15:45:56.170]                     {
  [15:45:56.170]                       inherits <- base::inherits
  [15:45:56.170]                       invokeRestart <- base::invokeRestart
  [15:45:56.170]                       muffled <- FALSE
  [15:45:56.170]                       if (inherits(cond, "message")) {
  [15:45:56.170]                         invokeRestart("muffleMessage")
  [15:45:56.170]                         muffled <- TRUE
  [15:45:56.170]                       }
  [15:45:56.170]                       else if (inherits(cond, "warning")) {
  [15:45:56.170]                         invokeRestart("muffleWarning")
  [15:45:56.170]                         muffled <- TRUE
  [15:45:56.170]                       }
  [15:45:56.170]                       else if (inherits(cond, "condition")) {
  [15:45:56.170]                         computeRestarts <- base::computeRestarts
  [15:45:56.170]                         grepl <- base::grepl
  [15:45:56.170]                         is.null <- base::is.null
  [15:45:56.170]                         restarts <- computeRestarts(cond)
  [15:45:56.170]                         for (restart in restarts) {
  [15:45:56.170]                           name <- restart$name
  [15:45:56.170]                           if (is.null(name)) 
  [15:45:56.170]                             next
  [15:45:56.170]                           if (!grepl("^muffle", name)) 
  [15:45:56.170]                             next
  [15:45:56.170]                           invokeRestart(restart)
  [15:45:56.170]                           muffled <- TRUE
  [15:45:56.170]                           break
  [15:45:56.170]                         }
  [15:45:56.170]                       }
  [15:45:56.170]                       invisible(muffled)
  [15:45:56.170]                     }
  [15:45:56.170]                     muffleCondition(cond)
  [15:45:56.170]                   }
  [15:45:56.170]                 }
  [15:45:56.170]             }
  [15:45:56.170]         }))
  [15:45:56.170]     }, error = function(ex) {
  [15:45:56.170]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.170]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.170]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.170]     }, finally = {
  [15:45:56.170]         {
  [15:45:56.170]             NULL
  [15:45:56.170]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.170]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.170]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.170]                 label = NULL, ...) 
  [15:45:56.170]             {
  [15:45:56.170]                 if (substitute) 
  [15:45:56.170]                   expr <- substitute(expr)
  [15:45:56.170]                 local <- as.logical(local)
  [15:45:56.170]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.170]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.170]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.170]                   label = label, ...)
  [15:45:56.170]                 if (!future$lazy) 
  [15:45:56.170]                   future <- run(future)
  [15:45:56.170]                 invisible(future)
  [15:45:56.170]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.170]         }
  [15:45:56.170]         base::options(...future.oldOptions)
  [15:45:56.170]     })
  [15:45:56.170]     Sys.time
  [15:45:56.170]     if (base::is.na(TRUE)) {
  [15:45:56.170]     }
  [15:45:56.170]     else {
  [15:45:56.170]         base::sink(type = "output", split = FALSE)
  [15:45:56.170]         if (TRUE) {
  [15:45:56.170]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.170]         }
  [15:45:56.170]         else {
  [15:45:56.170]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.170]         }
  [15:45:56.170]         base::close(...future.stdout)
  [15:45:56.170]         ...future.stdout <- NULL
  [15:45:56.170]     }
  [15:45:56.170]     ...future.result$conditions <- ...future.conditions
  [15:45:56.170]     ...future.result
  [15:45:56.170] }
  [15:45:56.176] plan(): Setting new future strategy stack:
  [15:45:56.177] List of future strategies:
  [15:45:56.177] 1. sequential:
  [15:45:56.177]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.177]    - tweaked: FALSE
  [15:45:56.177]    - call: NULL
  [15:45:56.178] plan(): nbrOfWorkers() = 1
  [15:45:56.179] plan(): Setting new future strategy stack:
  [15:45:56.180] List of future strategies:
  [15:45:56.180] 1. sequential:
  [15:45:56.180]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.180]    - tweaked: FALSE
  [15:45:56.180]    - call: plan(strategy)
  [15:45:56.181] plan(): nbrOfWorkers() = 1
  [15:45:56.182] SequentialFuture started (and completed)
  <environment: 0x55ca2ab7bc18> 
  <environment: 0x55ca2aa68d90> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:56.189] resolve() on environment ...
  [15:45:56.190]  recursive: 0
  [15:45:56.192]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:56.192] signalConditionsASAP(numeric, pos=1) ...
  [15:45:56.192] - nx: 4
  [15:45:56.193] - relay: TRUE
  [15:45:56.193] - stdout: TRUE
  [15:45:56.193] - signal: TRUE
  [15:45:56.194] - resignal: FALSE
  [15:45:56.194] - force: TRUE
  [15:45:56.195] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.195] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.195]  - until=2
  [15:45:56.196]  - relaying element #2
  [15:45:56.196] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.196] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.197] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:56.197]  length: 3 (resolved future 1)
  [15:45:56.198] Future #2
  [15:45:56.198] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:56.198] - nx: 4
  [15:45:56.199] - relay: TRUE
  [15:45:56.199] - stdout: TRUE
  [15:45:56.199] - signal: TRUE
  [15:45:56.200] - resignal: FALSE
  [15:45:56.200] - force: TRUE
  [15:45:56.200] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.201] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.201]  - until=2
  [15:45:56.202]  - relaying element #2
  [15:45:56.202] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.203] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.203] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:56.203]  length: 2 (resolved future 2)
  [15:45:56.204] Future #3
  [15:45:56.204] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:56.205] - nx: 4
  [15:45:56.205] - relay: TRUE
  [15:45:56.205] - stdout: TRUE
  [15:45:56.206] - signal: TRUE
  [15:45:56.206] - resignal: FALSE
  [15:45:56.206] - force: TRUE
  [15:45:56.207] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.210] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.211]  - until=3
  [15:45:56.212]  - relaying element #3
  [15:45:56.212] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.213] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.213] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:56.214]  length: 1 (resolved future 3)
  [15:45:56.214] Future #4
  [15:45:56.215] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:56.215] - nx: 4
  [15:45:56.215] - relay: TRUE
  [15:45:56.216] - stdout: TRUE
  [15:45:56.216] - signal: TRUE
  [15:45:56.216] - resignal: FALSE
  [15:45:56.217] - force: TRUE
  [15:45:56.217] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.217] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.218]  - until=4
  [15:45:56.218]  - relaying element #4
  [15:45:56.219] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.219] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.220] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:56.220]  length: 0 (resolved future 4)
  [15:45:56.220] Relaying remaining futures
  [15:45:56.221] signalConditionsASAP(NULL, pos=0) ...
  [15:45:56.221] - nx: 4
  [15:45:56.221] - relay: TRUE
  [15:45:56.222] - stdout: TRUE
  [15:45:56.222] - signal: TRUE
  [15:45:56.222] - resignal: FALSE
  [15:45:56.223] - force: TRUE
  [15:45:56.223] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.223] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:56.224] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.224] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.225] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:56.225] resolve() on environment ... DONE
  <environment: 0x55ca2ab41d20> 
  Dimensions: c(2, 1, 3, 1)
  [15:45:56.227] getGlobalsAndPackages() ...
  [15:45:56.227] Searching for globals...
  [15:45:56.228] 
  [15:45:56.229] Searching for globals ... DONE
  [15:45:56.229] - globals: [0] <none>
  [15:45:56.229] getGlobalsAndPackages() ... DONE
  [15:45:56.231] Packages needed by the future expression (n = 0): <none>
  [15:45:56.232] Packages needed by future strategies (n = 0): <none>
  [15:45:56.239] {
  [15:45:56.239]     {
  [15:45:56.239]         ...future.startTime <- base::Sys.time()
  [15:45:56.239]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.239]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.239]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.239]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.239]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.239]         {
  [15:45:56.239]             {
  [15:45:56.239]                 base::local({
  [15:45:56.239]                   has_future <- base::requireNamespace("future", 
  [15:45:56.239]                     quietly = TRUE)
  [15:45:56.239]                   version <- if (has_future) 
  [15:45:56.239]                     utils::packageVersion("future")
  [15:45:56.239]                   else NULL
  [15:45:56.239]                   if (!has_future || version < "1.8.0") {
  [15:45:56.239]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.239]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.239]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.239]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.239]                         "release", "version")], collapse = " "), 
  [15:45:56.239]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.239]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.239]                       info)
  [15:45:56.239]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.239]                     if (!has_future) {
  [15:45:56.239]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.239]                         info)
  [15:45:56.239]                     }
  [15:45:56.239]                     else {
  [15:45:56.239]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.239]                         info, version)
  [15:45:56.239]                     }
  [15:45:56.239]                     base::stop(msg)
  [15:45:56.239]                   }
  [15:45:56.239]                 })
  [15:45:56.239]             }
  [15:45:56.239]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.239]         }
  [15:45:56.239]     }
  [15:45:56.239]     if (base::is.na(TRUE)) {
  [15:45:56.239]     }
  [15:45:56.239]     else {
  [15:45:56.239]         if (TRUE) {
  [15:45:56.239]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.239]                 open = "w")
  [15:45:56.239]         }
  [15:45:56.239]         else {
  [15:45:56.239]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.239]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.239]         }
  [15:45:56.239]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.239]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.239]             base::sink(type = "output", split = FALSE)
  [15:45:56.239]             base::close(...future.stdout)
  [15:45:56.239]         }, add = TRUE)
  [15:45:56.239]     }
  [15:45:56.239]     ...future.frame <- base::sys.nframe()
  [15:45:56.239]     ...future.conditions <- base::list()
  [15:45:56.239]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.239]     ...future.result <- base::tryCatch({
  [15:45:56.239]         base::withCallingHandlers({
  [15:45:56.239]             ...future.value <- base::withVisible(base::local(2))
  [15:45:56.239]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.239]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.239]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.239]                 version = "1.8")
  [15:45:56.239]         }, condition = base::local({
  [15:45:56.239]             c <- base::c
  [15:45:56.239]             inherits <- base::inherits
  [15:45:56.239]             invokeRestart <- base::invokeRestart
  [15:45:56.239]             length <- base::length
  [15:45:56.239]             list <- base::list
  [15:45:56.239]             seq.int <- base::seq.int
  [15:45:56.239]             signalCondition <- base::signalCondition
  [15:45:56.239]             sys.calls <- base::sys.calls
  [15:45:56.239]             Sys.time <- base::Sys.time
  [15:45:56.239]             `[[` <- base::`[[`
  [15:45:56.239]             `+` <- base::`+`
  [15:45:56.239]             `<<-` <- base::`<<-`
  [15:45:56.239]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.239]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.239]                   3L)]
  [15:45:56.239]             }
  [15:45:56.239]             function(cond) {
  [15:45:56.239]                 if (inherits(cond, "error")) {
  [15:45:56.239]                   sessionInformation <- function() {
  [15:45:56.239]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.239]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.239]                       search = base::search(), system = base::Sys.info())
  [15:45:56.239]                   }
  [15:45:56.239]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.239]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.239]                     cond$call), session = sessionInformation(), 
  [15:45:56.239]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.239]                   signalCondition(cond)
  [15:45:56.239]                 }
  [15:45:56.239]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.239]                 ))) {
  [15:45:56.239]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.239]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.239]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.239]                   if (!signal) {
  [15:45:56.239]                     muffleCondition <- function (cond) 
  [15:45:56.239]                     {
  [15:45:56.239]                       inherits <- base::inherits
  [15:45:56.239]                       invokeRestart <- base::invokeRestart
  [15:45:56.239]                       muffled <- FALSE
  [15:45:56.239]                       if (inherits(cond, "message")) {
  [15:45:56.239]                         invokeRestart("muffleMessage")
  [15:45:56.239]                         muffled <- TRUE
  [15:45:56.239]                       }
  [15:45:56.239]                       else if (inherits(cond, "warning")) {
  [15:45:56.239]                         invokeRestart("muffleWarning")
  [15:45:56.239]                         muffled <- TRUE
  [15:45:56.239]                       }
  [15:45:56.239]                       else if (inherits(cond, "condition")) {
  [15:45:56.239]                         computeRestarts <- base::computeRestarts
  [15:45:56.239]                         grepl <- base::grepl
  [15:45:56.239]                         is.null <- base::is.null
  [15:45:56.239]                         restarts <- computeRestarts(cond)
  [15:45:56.239]                         for (restart in restarts) {
  [15:45:56.239]                           name <- restart$name
  [15:45:56.239]                           if (is.null(name)) 
  [15:45:56.239]                             next
  [15:45:56.239]                           if (!grepl("^muffle", name)) 
  [15:45:56.239]                             next
  [15:45:56.239]                           invokeRestart(restart)
  [15:45:56.239]                           muffled <- TRUE
  [15:45:56.239]                           break
  [15:45:56.239]                         }
  [15:45:56.239]                       }
  [15:45:56.239]                       invisible(muffled)
  [15:45:56.239]                     }
  [15:45:56.239]                     muffleCondition(cond)
  [15:45:56.239]                   }
  [15:45:56.239]                 }
  [15:45:56.239]             }
  [15:45:56.239]         }))
  [15:45:56.239]     }, error = function(ex) {
  [15:45:56.239]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.239]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.239]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.239]     }, finally = {
  [15:45:56.239]         {
  [15:45:56.239]             NULL
  [15:45:56.239]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.239]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.239]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.239]                 label = NULL, ...) 
  [15:45:56.239]             {
  [15:45:56.239]                 if (substitute) 
  [15:45:56.239]                   expr <- substitute(expr)
  [15:45:56.239]                 local <- as.logical(local)
  [15:45:56.239]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.239]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.239]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.239]                   label = label, ...)
  [15:45:56.239]                 if (!future$lazy) 
  [15:45:56.239]                   future <- run(future)
  [15:45:56.239]                 invisible(future)
  [15:45:56.239]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.239]         }
  [15:45:56.239]         base::options(...future.oldOptions)
  [15:45:56.239]     })
  [15:45:56.239]     Sys.time
  [15:45:56.239]     if (base::is.na(TRUE)) {
  [15:45:56.239]     }
  [15:45:56.239]     else {
  [15:45:56.239]         base::sink(type = "output", split = FALSE)
  [15:45:56.239]         if (TRUE) {
  [15:45:56.239]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.239]         }
  [15:45:56.239]         else {
  [15:45:56.239]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.239]         }
  [15:45:56.239]         base::close(...future.stdout)
  [15:45:56.239]         ...future.stdout <- NULL
  [15:45:56.239]     }
  [15:45:56.239]     ...future.result$conditions <- ...future.conditions
  [15:45:56.239]     ...future.result
  [15:45:56.239] }
  [15:45:56.244] plan(): Setting new future strategy stack:
  [15:45:56.245] List of future strategies:
  [15:45:56.245] 1. sequential:
  [15:45:56.245]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.245]    - tweaked: FALSE
  [15:45:56.245]    - call: NULL
  [15:45:56.246] plan(): nbrOfWorkers() = 1
  [15:45:56.247] plan(): Setting new future strategy stack:
  [15:45:56.247] List of future strategies:
  [15:45:56.247] 1. sequential:
  [15:45:56.247]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.247]    - tweaked: FALSE
  [15:45:56.247]    - call: plan(strategy)
  [15:45:56.249] plan(): nbrOfWorkers() = 1
  [15:45:56.249] SequentialFuture started (and completed)
  [15:45:56.250] getGlobalsAndPackages() ...
  [15:45:56.250] Searching for globals...
  [15:45:56.251] 
  [15:45:56.251] Searching for globals ... DONE
  [15:45:56.252] - globals: [0] <none>
  [15:45:56.252] getGlobalsAndPackages() ... DONE
  [15:45:56.255] Packages needed by the future expression (n = 0): <none>
  [15:45:56.255] Packages needed by future strategies (n = 0): <none>
  [15:45:56.262] {
  [15:45:56.262]     {
  [15:45:56.262]         ...future.startTime <- base::Sys.time()
  [15:45:56.262]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.262]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.262]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.262]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.262]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.262]         {
  [15:45:56.262]             {
  [15:45:56.262]                 base::local({
  [15:45:56.262]                   has_future <- base::requireNamespace("future", 
  [15:45:56.262]                     quietly = TRUE)
  [15:45:56.262]                   version <- if (has_future) 
  [15:45:56.262]                     utils::packageVersion("future")
  [15:45:56.262]                   else NULL
  [15:45:56.262]                   if (!has_future || version < "1.8.0") {
  [15:45:56.262]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.262]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.262]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.262]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.262]                         "release", "version")], collapse = " "), 
  [15:45:56.262]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.262]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.262]                       info)
  [15:45:56.262]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.262]                     if (!has_future) {
  [15:45:56.262]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.262]                         info)
  [15:45:56.262]                     }
  [15:45:56.262]                     else {
  [15:45:56.262]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.262]                         info, version)
  [15:45:56.262]                     }
  [15:45:56.262]                     base::stop(msg)
  [15:45:56.262]                   }
  [15:45:56.262]                 })
  [15:45:56.262]             }
  [15:45:56.262]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.262]         }
  [15:45:56.262]     }
  [15:45:56.262]     if (base::is.na(TRUE)) {
  [15:45:56.262]     }
  [15:45:56.262]     else {
  [15:45:56.262]         if (TRUE) {
  [15:45:56.262]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.262]                 open = "w")
  [15:45:56.262]         }
  [15:45:56.262]         else {
  [15:45:56.262]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.262]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.262]         }
  [15:45:56.262]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.262]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.262]             base::sink(type = "output", split = FALSE)
  [15:45:56.262]             base::close(...future.stdout)
  [15:45:56.262]         }, add = TRUE)
  [15:45:56.262]     }
  [15:45:56.262]     ...future.frame <- base::sys.nframe()
  [15:45:56.262]     ...future.conditions <- base::list()
  [15:45:56.262]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.262]     ...future.result <- base::tryCatch({
  [15:45:56.262]         base::withCallingHandlers({
  [15:45:56.262]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:56.262]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.262]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.262]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.262]                 version = "1.8")
  [15:45:56.262]         }, condition = base::local({
  [15:45:56.262]             c <- base::c
  [15:45:56.262]             inherits <- base::inherits
  [15:45:56.262]             invokeRestart <- base::invokeRestart
  [15:45:56.262]             length <- base::length
  [15:45:56.262]             list <- base::list
  [15:45:56.262]             seq.int <- base::seq.int
  [15:45:56.262]             signalCondition <- base::signalCondition
  [15:45:56.262]             sys.calls <- base::sys.calls
  [15:45:56.262]             Sys.time <- base::Sys.time
  [15:45:56.262]             `[[` <- base::`[[`
  [15:45:56.262]             `+` <- base::`+`
  [15:45:56.262]             `<<-` <- base::`<<-`
  [15:45:56.262]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.262]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.262]                   3L)]
  [15:45:56.262]             }
  [15:45:56.262]             function(cond) {
  [15:45:56.262]                 if (inherits(cond, "error")) {
  [15:45:56.262]                   sessionInformation <- function() {
  [15:45:56.262]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.262]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.262]                       search = base::search(), system = base::Sys.info())
  [15:45:56.262]                   }
  [15:45:56.262]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.262]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.262]                     cond$call), session = sessionInformation(), 
  [15:45:56.262]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.262]                   signalCondition(cond)
  [15:45:56.262]                 }
  [15:45:56.262]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.262]                 ))) {
  [15:45:56.262]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.262]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.262]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.262]                   if (!signal) {
  [15:45:56.262]                     muffleCondition <- function (cond) 
  [15:45:56.262]                     {
  [15:45:56.262]                       inherits <- base::inherits
  [15:45:56.262]                       invokeRestart <- base::invokeRestart
  [15:45:56.262]                       muffled <- FALSE
  [15:45:56.262]                       if (inherits(cond, "message")) {
  [15:45:56.262]                         invokeRestart("muffleMessage")
  [15:45:56.262]                         muffled <- TRUE
  [15:45:56.262]                       }
  [15:45:56.262]                       else if (inherits(cond, "warning")) {
  [15:45:56.262]                         invokeRestart("muffleWarning")
  [15:45:56.262]                         muffled <- TRUE
  [15:45:56.262]                       }
  [15:45:56.262]                       else if (inherits(cond, "condition")) {
  [15:45:56.262]                         computeRestarts <- base::computeRestarts
  [15:45:56.262]                         grepl <- base::grepl
  [15:45:56.262]                         is.null <- base::is.null
  [15:45:56.262]                         restarts <- computeRestarts(cond)
  [15:45:56.262]                         for (restart in restarts) {
  [15:45:56.262]                           name <- restart$name
  [15:45:56.262]                           if (is.null(name)) 
  [15:45:56.262]                             next
  [15:45:56.262]                           if (!grepl("^muffle", name)) 
  [15:45:56.262]                             next
  [15:45:56.262]                           invokeRestart(restart)
  [15:45:56.262]                           muffled <- TRUE
  [15:45:56.262]                           break
  [15:45:56.262]                         }
  [15:45:56.262]                       }
  [15:45:56.262]                       invisible(muffled)
  [15:45:56.262]                     }
  [15:45:56.262]                     muffleCondition(cond)
  [15:45:56.262]                   }
  [15:45:56.262]                 }
  [15:45:56.262]             }
  [15:45:56.262]         }))
  [15:45:56.262]     }, error = function(ex) {
  [15:45:56.262]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.262]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.262]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.262]     }, finally = {
  [15:45:56.262]         {
  [15:45:56.262]             NULL
  [15:45:56.262]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.262]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.262]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.262]                 label = NULL, ...) 
  [15:45:56.262]             {
  [15:45:56.262]                 if (substitute) 
  [15:45:56.262]                   expr <- substitute(expr)
  [15:45:56.262]                 local <- as.logical(local)
  [15:45:56.262]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.262]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.262]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.262]                   label = label, ...)
  [15:45:56.262]                 if (!future$lazy) 
  [15:45:56.262]                   future <- run(future)
  [15:45:56.262]                 invisible(future)
  [15:45:56.262]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.262]         }
  [15:45:56.262]         base::options(...future.oldOptions)
  [15:45:56.262]     })
  [15:45:56.262]     Sys.time
  [15:45:56.262]     if (base::is.na(TRUE)) {
  [15:45:56.262]     }
  [15:45:56.262]     else {
  [15:45:56.262]         base::sink(type = "output", split = FALSE)
  [15:45:56.262]         if (TRUE) {
  [15:45:56.262]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.262]         }
  [15:45:56.262]         else {
  [15:45:56.262]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.262]         }
  [15:45:56.262]         base::close(...future.stdout)
  [15:45:56.262]         ...future.stdout <- NULL
  [15:45:56.262]     }
  [15:45:56.262]     ...future.result$conditions <- ...future.conditions
  [15:45:56.262]     ...future.result
  [15:45:56.262] }
  [15:45:56.267] plan(): Setting new future strategy stack:
  [15:45:56.268] List of future strategies:
  [15:45:56.268] 1. sequential:
  [15:45:56.268]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.268]    - tweaked: FALSE
  [15:45:56.268]    - call: NULL
  [15:45:56.269] plan(): nbrOfWorkers() = 1
  [15:45:56.270] plan(): Setting new future strategy stack:
  [15:45:56.271] List of future strategies:
  [15:45:56.271] 1. sequential:
  [15:45:56.271]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.271]    - tweaked: FALSE
  [15:45:56.271]    - call: plan(strategy)
  [15:45:56.272] plan(): nbrOfWorkers() = 1
  [15:45:56.273] SequentialFuture started (and completed)
  [15:45:56.274] getGlobalsAndPackages() ...
  [15:45:56.274] Searching for globals...
  [15:45:56.276] - globals found: [1] '{'
  [15:45:56.276] Searching for globals ... DONE
  [15:45:56.277] Resolving globals: FALSE
  [15:45:56.277] 
  [15:45:56.278] 
  [15:45:56.278] getGlobalsAndPackages() ... DONE
  [15:45:56.281] Packages needed by the future expression (n = 0): <none>
  [15:45:56.281] Packages needed by future strategies (n = 0): <none>
  [15:45:56.290] {
  [15:45:56.290]     {
  [15:45:56.290]         ...future.startTime <- base::Sys.time()
  [15:45:56.290]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:56.290]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:56.290]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:56.290]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:56.290]             future.resolve.recursive = NULL, width = 80L)
  [15:45:56.290]         {
  [15:45:56.290]             {
  [15:45:56.290]                 base::local({
  [15:45:56.290]                   has_future <- base::requireNamespace("future", 
  [15:45:56.290]                     quietly = TRUE)
  [15:45:56.290]                   version <- if (has_future) 
  [15:45:56.290]                     utils::packageVersion("future")
  [15:45:56.290]                   else NULL
  [15:45:56.290]                   if (!has_future || version < "1.8.0") {
  [15:45:56.290]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:56.290]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:56.290]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:56.290]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:56.290]                         "release", "version")], collapse = " "), 
  [15:45:56.290]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:56.290]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:56.290]                       info)
  [15:45:56.290]                     info <- base::paste(info, collapse = "; ")
  [15:45:56.290]                     if (!has_future) {
  [15:45:56.290]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:56.290]                         info)
  [15:45:56.290]                     }
  [15:45:56.290]                     else {
  [15:45:56.290]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:56.290]                         info, version)
  [15:45:56.290]                     }
  [15:45:56.290]                     base::stop(msg)
  [15:45:56.290]                   }
  [15:45:56.290]                 })
  [15:45:56.290]             }
  [15:45:56.290]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:56.290]         }
  [15:45:56.290]     }
  [15:45:56.290]     if (base::is.na(TRUE)) {
  [15:45:56.290]     }
  [15:45:56.290]     else {
  [15:45:56.290]         if (TRUE) {
  [15:45:56.290]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:56.290]                 open = "w")
  [15:45:56.290]         }
  [15:45:56.290]         else {
  [15:45:56.290]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:56.290]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:56.290]         }
  [15:45:56.290]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:56.290]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:56.290]             base::sink(type = "output", split = FALSE)
  [15:45:56.290]             base::close(...future.stdout)
  [15:45:56.290]         }, add = TRUE)
  [15:45:56.290]     }
  [15:45:56.290]     ...future.frame <- base::sys.nframe()
  [15:45:56.290]     ...future.conditions <- base::list()
  [15:45:56.290]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:56.290]     ...future.result <- base::tryCatch({
  [15:45:56.290]         base::withCallingHandlers({
  [15:45:56.290]             ...future.value <- base::withVisible(base::local({
  [15:45:56.290]                 4
  [15:45:56.290]             }))
  [15:45:56.290]             future::FutureResult(value = ...future.value$value, 
  [15:45:56.290]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.290]                   ...future.rng), started = ...future.startTime, 
  [15:45:56.290]                 version = "1.8")
  [15:45:56.290]         }, condition = base::local({
  [15:45:56.290]             c <- base::c
  [15:45:56.290]             inherits <- base::inherits
  [15:45:56.290]             invokeRestart <- base::invokeRestart
  [15:45:56.290]             length <- base::length
  [15:45:56.290]             list <- base::list
  [15:45:56.290]             seq.int <- base::seq.int
  [15:45:56.290]             signalCondition <- base::signalCondition
  [15:45:56.290]             sys.calls <- base::sys.calls
  [15:45:56.290]             Sys.time <- base::Sys.time
  [15:45:56.290]             `[[` <- base::`[[`
  [15:45:56.290]             `+` <- base::`+`
  [15:45:56.290]             `<<-` <- base::`<<-`
  [15:45:56.290]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:56.290]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:56.290]                   3L)]
  [15:45:56.290]             }
  [15:45:56.290]             function(cond) {
  [15:45:56.290]                 if (inherits(cond, "error")) {
  [15:45:56.290]                   sessionInformation <- function() {
  [15:45:56.290]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:56.290]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:56.290]                       search = base::search(), system = base::Sys.info())
  [15:45:56.290]                   }
  [15:45:56.290]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.290]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:56.290]                     cond$call), session = sessionInformation(), 
  [15:45:56.290]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:56.290]                   signalCondition(cond)
  [15:45:56.290]                 }
  [15:45:56.290]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:56.290]                 ))) {
  [15:45:56.290]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:56.290]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:56.290]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:56.290]                   if (!signal) {
  [15:45:56.290]                     muffleCondition <- function (cond) 
  [15:45:56.290]                     {
  [15:45:56.290]                       inherits <- base::inherits
  [15:45:56.290]                       invokeRestart <- base::invokeRestart
  [15:45:56.290]                       muffled <- FALSE
  [15:45:56.290]                       if (inherits(cond, "message")) {
  [15:45:56.290]                         invokeRestart("muffleMessage")
  [15:45:56.290]                         muffled <- TRUE
  [15:45:56.290]                       }
  [15:45:56.290]                       else if (inherits(cond, "warning")) {
  [15:45:56.290]                         invokeRestart("muffleWarning")
  [15:45:56.290]                         muffled <- TRUE
  [15:45:56.290]                       }
  [15:45:56.290]                       else if (inherits(cond, "condition")) {
  [15:45:56.290]                         computeRestarts <- base::computeRestarts
  [15:45:56.290]                         grepl <- base::grepl
  [15:45:56.290]                         is.null <- base::is.null
  [15:45:56.290]                         restarts <- computeRestarts(cond)
  [15:45:56.290]                         for (restart in restarts) {
  [15:45:56.290]                           name <- restart$name
  [15:45:56.290]                           if (is.null(name)) 
  [15:45:56.290]                             next
  [15:45:56.290]                           if (!grepl("^muffle", name)) 
  [15:45:56.290]                             next
  [15:45:56.290]                           invokeRestart(restart)
  [15:45:56.290]                           muffled <- TRUE
  [15:45:56.290]                           break
  [15:45:56.290]                         }
  [15:45:56.290]                       }
  [15:45:56.290]                       invisible(muffled)
  [15:45:56.290]                     }
  [15:45:56.290]                     muffleCondition(cond)
  [15:45:56.290]                   }
  [15:45:56.290]                 }
  [15:45:56.290]             }
  [15:45:56.290]         }))
  [15:45:56.290]     }, error = function(ex) {
  [15:45:56.290]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:56.290]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:56.290]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:56.290]     }, finally = {
  [15:45:56.290]         {
  [15:45:56.290]             NULL
  [15:45:56.290]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:56.290]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:56.290]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:56.290]                 label = NULL, ...) 
  [15:45:56.290]             {
  [15:45:56.290]                 if (substitute) 
  [15:45:56.290]                   expr <- substitute(expr)
  [15:45:56.290]                 local <- as.logical(local)
  [15:45:56.290]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:56.290]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:56.290]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:56.290]                   label = label, ...)
  [15:45:56.290]                 if (!future$lazy) 
  [15:45:56.290]                   future <- run(future)
  [15:45:56.290]                 invisible(future)
  [15:45:56.290]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:56.290]         }
  [15:45:56.290]         base::options(...future.oldOptions)
  [15:45:56.290]     })
  [15:45:56.290]     Sys.time
  [15:45:56.290]     if (base::is.na(TRUE)) {
  [15:45:56.290]     }
  [15:45:56.290]     else {
  [15:45:56.290]         base::sink(type = "output", split = FALSE)
  [15:45:56.290]         if (TRUE) {
  [15:45:56.290]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:56.290]         }
  [15:45:56.290]         else {
  [15:45:56.290]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:56.290]         }
  [15:45:56.290]         base::close(...future.stdout)
  [15:45:56.290]         ...future.stdout <- NULL
  [15:45:56.290]     }
  [15:45:56.290]     ...future.result$conditions <- ...future.conditions
  [15:45:56.290]     ...future.result
  [15:45:56.290] }
  [15:45:56.299] plan(): Setting new future strategy stack:
  [15:45:56.299] List of future strategies:
  [15:45:56.299] 1. sequential:
  [15:45:56.299]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.299]    - tweaked: FALSE
  [15:45:56.299]    - call: NULL
  [15:45:56.301] plan(): nbrOfWorkers() = 1
  [15:45:56.302] plan(): Setting new future strategy stack:
  [15:45:56.303] List of future strategies:
  [15:45:56.303] 1. sequential:
  [15:45:56.303]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:56.303]    - tweaked: FALSE
  [15:45:56.303]    - call: plan(strategy)
  [15:45:56.304] plan(): nbrOfWorkers() = 1
  [15:45:56.305] SequentialFuture started (and completed)
  <environment: 0x55ca292fa570> 
  <environment: 0x55ca29869418> 
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:56.312] resolve() on environment ...
  [15:45:56.313]  recursive: 0
  [15:45:56.314]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:56.315] signalConditionsASAP(numeric, pos=1) ...
  [15:45:56.315] - nx: 4
  [15:45:56.315] - relay: TRUE
  [15:45:56.316] - stdout: TRUE
  [15:45:56.316] - signal: TRUE
  [15:45:56.316] - resignal: FALSE
  [15:45:56.317] - force: TRUE
  [15:45:56.317] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.317] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.318]  - until=2
  [15:45:56.318]  - relaying element #2
  [15:45:56.318] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.319] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.319] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:56.320]  length: 3 (resolved future 1)
  [15:45:56.320] Future #2
  [15:45:56.321] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:56.321] - nx: 4
  [15:45:56.321] - relay: TRUE
  [15:45:56.322] - stdout: TRUE
  [15:45:56.322] - signal: TRUE
  [15:45:56.322] - resignal: FALSE
  [15:45:56.323] - force: TRUE
  [15:45:56.323] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:56.323] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:56.324]  - until=2
  [15:45:56.324]  - relaying element #2
  [15:45:56.325] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.325] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.325] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:56.326]  length: 2 (resolved future 2)
  [15:45:56.326] Future #3
  [15:45:56.327] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:56.327] - nx: 4
  [15:45:56.328] - relay: TRUE
  [15:45:56.328] - stdout: TRUE
  [15:45:56.328] - signal: TRUE
  [15:45:56.329] - resignal: FALSE
  [15:45:56.329] - force: TRUE
  [15:45:56.329] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:56.329] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:56.330]  - until=3
  [15:45:56.330]  - relaying element #3
  [15:45:56.331] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.331] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.332] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:56.332]  length: 1 (resolved future 3)
  [15:45:56.332] Future #4
  [15:45:56.333] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:56.333] - nx: 4
  [15:45:56.334] - relay: TRUE
  [15:45:56.334] - stdout: TRUE
  [15:45:56.334] - signal: TRUE
  [15:45:56.335] - resignal: FALSE
  [15:45:56.335] - force: TRUE
  [15:45:56.335] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:56.336] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:56.336]  - until=4
  [15:45:56.336]  - relaying element #4
  [15:45:56.337] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.337] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.338] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:56.338]  length: 0 (resolved future 4)
  [15:45:56.338] Relaying remaining futures
  [15:45:56.339] signalConditionsASAP(NULL, pos=0) ...
  [15:45:56.339] - nx: 4
  [15:45:56.339] - relay: TRUE
  [15:45:56.340] - stdout: TRUE
  [15:45:56.340] - signal: TRUE
  [15:45:56.340] - resignal: FALSE
  [15:45:56.341] - force: TRUE
  [15:45:56.341] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.341] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:56.342] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:56.342] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:56.343] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:56.343] resolve() on environment ... DONE
  <environment: 0x55ca292d2140> 
  Type of future: cluster
  [15:45:56.345] plan(): Setting new future strategy stack:
  [15:45:56.345] List of future strategies:
  [15:45:56.345] 1. cluster:
  [15:45:56.345]    - 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, ...)
  [15:45:56.345]    - tweaked: FALSE
  [15:45:56.345]    - call: plan(strategy)
  [15:45:56.348] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [15:45:56.348] cluster:
  [15:45:56.348] - 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, ...)
  [15:45:56.348] - tweaked: FALSE
  [15:45:56.348] - call: plan(strategy)
  [15:45:56.349] getGlobalsAndPackages() ...
  [15:45:56.349] Not searching for globals
  [15:45:56.350] - globals: [0] <none>
  [15:45:56.350] getGlobalsAndPackages() ... DONE
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 36306
  [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/Rtmp4zIndi/future.parent=13636.3544eb58551.pid")), silent = TRUE)' -e "file.exists('/tmp/Rtmp4zIndi/future.parent=13636.3544eb58551.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:13636' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/Rtmp4zIndi/future.parent=13636.3544eb58551.pid")), silent = TRUE)' -e 'workRSOCK <- tryCatch(parallel:::.slaveRSOCK, error=function(e) parallel:::.workRSOCK); workRSOCK()' MASTER=localhost PORT=36306 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
  [15:45:57.882] Packages needed by the future expression (n = 0): <none>
  [15:45:57.882] Packages needed by future strategies (n = 0): <none>
  [15:45:57.889] {
  [15:45:57.889]     {
  [15:45:57.889]         ...future.startTime <- base::Sys.time()
  [15:45:57.889]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:57.889]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:57.889]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:57.889]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:57.889]             future.resolve.recursive = NULL, width = 80L)
  [15:45:57.889]         {
  [15:45:57.889]             {
  [15:45:57.889]                 base::local({
  [15:45:57.889]                   has_future <- base::requireNamespace("future", 
  [15:45:57.889]                     quietly = TRUE)
  [15:45:57.889]                   version <- if (has_future) 
  [15:45:57.889]                     utils::packageVersion("future")
  [15:45:57.889]                   else NULL
  [15:45:57.889]                   if (!has_future || version < "1.8.0") {
  [15:45:57.889]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:57.889]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:57.889]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:57.889]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:57.889]                         "release", "version")], collapse = " "), 
  [15:45:57.889]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:57.889]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:57.889]                       info)
  [15:45:57.889]                     info <- base::paste(info, collapse = "; ")
  [15:45:57.889]                     if (!has_future) {
  [15:45:57.889]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:57.889]                         info)
  [15:45:57.889]                     }
  [15:45:57.889]                     else {
  [15:45:57.889]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:57.889]                         info, version)
  [15:45:57.889]                     }
  [15:45:57.889]                     base::stop(msg)
  [15:45:57.889]                   }
  [15:45:57.889]                 })
  [15:45:57.889]             }
  [15:45:57.889]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:57.889]         }
  [15:45:57.889]     }
  [15:45:57.889]     if (base::is.na(TRUE)) {
  [15:45:57.889]     }
  [15:45:57.889]     else {
  [15:45:57.889]         if (TRUE) {
  [15:45:57.889]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:57.889]                 open = "w")
  [15:45:57.889]         }
  [15:45:57.889]         else {
  [15:45:57.889]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:57.889]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:57.889]         }
  [15:45:57.889]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:57.889]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:57.889]             base::sink(type = "output", split = FALSE)
  [15:45:57.889]             base::close(...future.stdout)
  [15:45:57.889]         }, add = TRUE)
  [15:45:57.889]     }
  [15:45:57.889]     ...future.frame <- base::sys.nframe()
  [15:45:57.889]     ...future.conditions <- base::list()
  [15:45:57.889]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:57.889]     ...future.result <- base::tryCatch({
  [15:45:57.889]         base::withCallingHandlers({
  [15:45:57.889]             ...future.value <- base::withVisible(base::local({
  [15:45:57.889]                 ...future.sendCondition <- local({
  [15:45:57.889]                   sendCondition <- NULL
  [15:45:57.889]                   function(frame = 1L) {
  [15:45:57.889]                     if (is.function(sendCondition)) 
  [15:45:57.889]                       return(sendCondition)
  [15:45:57.889]                     ns <- getNamespace("parallel")
  [15:45:57.889]                     if (exists("sendData", mode = "function", 
  [15:45:57.889]                       envir = ns)) {
  [15:45:57.889]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:57.889]                         envir = ns)
  [15:45:57.889]                       envir <- sys.frame(frame)
  [15:45:57.889]                       master <- NULL
  [15:45:57.889]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:57.889]                         !identical(envir, emptyenv())) {
  [15:45:57.889]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:57.889]                           inherits = FALSE)) {
  [15:45:57.889]                           master <- get("master", mode = "list", 
  [15:45:57.889]                             envir = envir, inherits = FALSE)
  [15:45:57.889]                           if (inherits(master, "SOCKnode")) {
  [15:45:57.889]                             sendCondition <<- function(cond) {
  [15:45:57.889]                               data <- list(type = "VALUE", value = cond, 
  [15:45:57.889]                                 success = TRUE)
  [15:45:57.889]                               parallel_sendData(master, data)
  [15:45:57.889]                             }
  [15:45:57.889]                             return(sendCondition)
  [15:45:57.889]                           }
  [15:45:57.889]                         }
  [15:45:57.889]                         frame <- frame + 1L
  [15:45:57.889]                         envir <- sys.frame(frame)
  [15:45:57.889]                       }
  [15:45:57.889]                     }
  [15:45:57.889]                     sendCondition <<- function(cond) NULL
  [15:45:57.889]                   }
  [15:45:57.889]                 })
  [15:45:57.889]                 withCallingHandlers({
  [15:45:57.889]                   NA
  [15:45:57.889]                 }, immediateCondition = function(cond) {
  [15:45:57.889]                   sendCondition <- ...future.sendCondition()
  [15:45:57.889]                   sendCondition(cond)
  [15:45:57.889]                   muffleCondition <- function (cond) 
  [15:45:57.889]                   {
  [15:45:57.889]                     inherits <- base::inherits
  [15:45:57.889]                     invokeRestart <- base::invokeRestart
  [15:45:57.889]                     muffled <- FALSE
  [15:45:57.889]                     if (inherits(cond, "message")) {
  [15:45:57.889]                       invokeRestart("muffleMessage")
  [15:45:57.889]                       muffled <- TRUE
  [15:45:57.889]                     }
  [15:45:57.889]                     else if (inherits(cond, "warning")) {
  [15:45:57.889]                       invokeRestart("muffleWarning")
  [15:45:57.889]                       muffled <- TRUE
  [15:45:57.889]                     }
  [15:45:57.889]                     else if (inherits(cond, "condition")) {
  [15:45:57.889]                       computeRestarts <- base::computeRestarts
  [15:45:57.889]                       grepl <- base::grepl
  [15:45:57.889]                       is.null <- base::is.null
  [15:45:57.889]                       restarts <- computeRestarts(cond)
  [15:45:57.889]                       for (restart in restarts) {
  [15:45:57.889]                         name <- restart$name
  [15:45:57.889]                         if (is.null(name)) 
  [15:45:57.889]                           next
  [15:45:57.889]                         if (!grepl("^muffle", name)) 
  [15:45:57.889]                           next
  [15:45:57.889]                         invokeRestart(restart)
  [15:45:57.889]                         muffled <- TRUE
  [15:45:57.889]                         break
  [15:45:57.889]                       }
  [15:45:57.889]                     }
  [15:45:57.889]                     invisible(muffled)
  [15:45:57.889]                   }
  [15:45:57.889]                   muffleCondition(cond)
  [15:45:57.889]                 })
  [15:45:57.889]             }))
  [15:45:57.889]             future::FutureResult(value = ...future.value$value, 
  [15:45:57.889]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:57.889]                   ...future.rng), started = ...future.startTime, 
  [15:45:57.889]                 version = "1.8")
  [15:45:57.889]         }, condition = base::local({
  [15:45:57.889]             c <- base::c
  [15:45:57.889]             inherits <- base::inherits
  [15:45:57.889]             invokeRestart <- base::invokeRestart
  [15:45:57.889]             length <- base::length
  [15:45:57.889]             list <- base::list
  [15:45:57.889]             seq.int <- base::seq.int
  [15:45:57.889]             signalCondition <- base::signalCondition
  [15:45:57.889]             sys.calls <- base::sys.calls
  [15:45:57.889]             Sys.time <- base::Sys.time
  [15:45:57.889]             `[[` <- base::`[[`
  [15:45:57.889]             `+` <- base::`+`
  [15:45:57.889]             `<<-` <- base::`<<-`
  [15:45:57.889]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:57.889]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:57.889]                   3L)]
  [15:45:57.889]             }
  [15:45:57.889]             function(cond) {
  [15:45:57.889]                 if (inherits(cond, "error")) {
  [15:45:57.889]                   sessionInformation <- function() {
  [15:45:57.889]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:57.889]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:57.889]                       search = base::search(), system = base::Sys.info())
  [15:45:57.889]                   }
  [15:45:57.889]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:57.889]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:57.889]                     cond$call), session = sessionInformation(), 
  [15:45:57.889]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:57.889]                   signalCondition(cond)
  [15:45:57.889]                 }
  [15:45:57.889]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:57.889]                 ))) {
  [15:45:57.889]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:57.889]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:57.889]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:57.889]                   if (!signal) {
  [15:45:57.889]                     muffleCondition <- function (cond) 
  [15:45:57.889]                     {
  [15:45:57.889]                       inherits <- base::inherits
  [15:45:57.889]                       invokeRestart <- base::invokeRestart
  [15:45:57.889]                       muffled <- FALSE
  [15:45:57.889]                       if (inherits(cond, "message")) {
  [15:45:57.889]                         invokeRestart("muffleMessage")
  [15:45:57.889]                         muffled <- TRUE
  [15:45:57.889]                       }
  [15:45:57.889]                       else if (inherits(cond, "warning")) {
  [15:45:57.889]                         invokeRestart("muffleWarning")
  [15:45:57.889]                         muffled <- TRUE
  [15:45:57.889]                       }
  [15:45:57.889]                       else if (inherits(cond, "condition")) {
  [15:45:57.889]                         computeRestarts <- base::computeRestarts
  [15:45:57.889]                         grepl <- base::grepl
  [15:45:57.889]                         is.null <- base::is.null
  [15:45:57.889]                         restarts <- computeRestarts(cond)
  [15:45:57.889]                         for (restart in restarts) {
  [15:45:57.889]                           name <- restart$name
  [15:45:57.889]                           if (is.null(name)) 
  [15:45:57.889]                             next
  [15:45:57.889]                           if (!grepl("^muffle", name)) 
  [15:45:57.889]                             next
  [15:45:57.889]                           invokeRestart(restart)
  [15:45:57.889]                           muffled <- TRUE
  [15:45:57.889]                           break
  [15:45:57.889]                         }
  [15:45:57.889]                       }
  [15:45:57.889]                       invisible(muffled)
  [15:45:57.889]                     }
  [15:45:57.889]                     muffleCondition(cond)
  [15:45:57.889]                   }
  [15:45:57.889]                 }
  [15:45:57.889]             }
  [15:45:57.889]         }))
  [15:45:57.889]     }, error = function(ex) {
  [15:45:57.889]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:57.889]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:57.889]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:57.889]     }, finally = {
  [15:45:57.889]         {
  [15:45:57.889]             NULL
  [15:45:57.889]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:57.889]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:57.889]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:57.889]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:57.889]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:57.889]                 ...) 
  [15:45:57.889]             {
  [15:45:57.889]                 if (substitute) 
  [15:45:57.889]                   expr <- substitute(expr)
  [15:45:57.889]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:57.889]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:57.889]                   globals = globals, persistent = persistent, 
  [15:45:57.889]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:57.889]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:57.889]                   label = label, ...)
  [15:45:57.889]                 if (!future$lazy) 
  [15:45:57.889]                   future <- run(future)
  [15:45:57.889]                 invisible(future)
  [15:45:57.889]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:57.889]         }
  [15:45:57.889]         base::options(...future.oldOptions)
  [15:45:57.889]     })
  [15:45:57.889]     Sys.time
  [15:45:57.889]     if (base::is.na(TRUE)) {
  [15:45:57.889]     }
  [15:45:57.889]     else {
  [15:45:57.889]         base::sink(type = "output", split = FALSE)
  [15:45:57.889]         if (TRUE) {
  [15:45:57.889]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:57.889]         }
  [15:45:57.889]         else {
  [15:45:57.889]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:57.889]         }
  [15:45:57.889]         base::close(...future.stdout)
  [15:45:57.889]         ...future.stdout <- NULL
  [15:45:57.889]     }
  [15:45:57.889]     ...future.result$conditions <- ...future.conditions
  [15:45:57.889]     ...future.result
  [15:45:57.889] }
  [15:45:57.897] ClusterFuture started
  [15:45:57.898] result() for ClusterFuture ...
  [15:45:57.898] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:57.898] - Validating connection of ClusterFuture
  [15:45:58.047] - received message: FutureResult
  [15:45:58.047] - Received FutureResult
  [15:45:58.048] - Erased future from FutureRegistry
  [15:45:58.048] result() for ClusterFuture ...
  [15:45:58.048] - result already collected: FutureResult
  [15:45:58.049] result() for ClusterFuture ... done
  [15:45:58.049] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.050] result() for ClusterFuture ... done
  [15:45:58.050] result() for ClusterFuture ...
  [15:45:58.054] - result already collected: FutureResult
  [15:45:58.054] result() for ClusterFuture ... done
  [15:45:58.054] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [15:45:58.056] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [15:45:58.057] getGlobalsAndPackages() ...
  [15:45:58.057] Searching for globals...
  [15:45:58.058] 
  [15:45:58.059] Searching for globals ... DONE
  [15:45:58.059] - globals: [0] <none>
  [15:45:58.059] getGlobalsAndPackages() ... DONE
  [15:45:58.069] Packages needed by the future expression (n = 0): <none>
  [15:45:58.070] Packages needed by future strategies (n = 0): <none>
  [15:45:58.076] {
  [15:45:58.076]     {
  [15:45:58.076]         ...future.startTime <- base::Sys.time()
  [15:45:58.076]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.076]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.076]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.076]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.076]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.076]         {
  [15:45:58.076]             {
  [15:45:58.076]                 base::local({
  [15:45:58.076]                   has_future <- base::requireNamespace("future", 
  [15:45:58.076]                     quietly = TRUE)
  [15:45:58.076]                   version <- if (has_future) 
  [15:45:58.076]                     utils::packageVersion("future")
  [15:45:58.076]                   else NULL
  [15:45:58.076]                   if (!has_future || version < "1.8.0") {
  [15:45:58.076]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.076]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.076]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.076]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.076]                         "release", "version")], collapse = " "), 
  [15:45:58.076]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.076]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.076]                       info)
  [15:45:58.076]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.076]                     if (!has_future) {
  [15:45:58.076]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.076]                         info)
  [15:45:58.076]                     }
  [15:45:58.076]                     else {
  [15:45:58.076]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.076]                         info, version)
  [15:45:58.076]                     }
  [15:45:58.076]                     base::stop(msg)
  [15:45:58.076]                   }
  [15:45:58.076]                 })
  [15:45:58.076]             }
  [15:45:58.076]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.076]         }
  [15:45:58.076]     }
  [15:45:58.076]     if (base::is.na(TRUE)) {
  [15:45:58.076]     }
  [15:45:58.076]     else {
  [15:45:58.076]         if (TRUE) {
  [15:45:58.076]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.076]                 open = "w")
  [15:45:58.076]         }
  [15:45:58.076]         else {
  [15:45:58.076]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.076]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.076]         }
  [15:45:58.076]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.076]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.076]             base::sink(type = "output", split = FALSE)
  [15:45:58.076]             base::close(...future.stdout)
  [15:45:58.076]         }, add = TRUE)
  [15:45:58.076]     }
  [15:45:58.076]     ...future.frame <- base::sys.nframe()
  [15:45:58.076]     ...future.conditions <- base::list()
  [15:45:58.076]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.076]     ...future.result <- base::tryCatch({
  [15:45:58.076]         base::withCallingHandlers({
  [15:45:58.076]             ...future.value <- base::withVisible(base::local({
  [15:45:58.076]                 ...future.sendCondition <- local({
  [15:45:58.076]                   sendCondition <- NULL
  [15:45:58.076]                   function(frame = 1L) {
  [15:45:58.076]                     if (is.function(sendCondition)) 
  [15:45:58.076]                       return(sendCondition)
  [15:45:58.076]                     ns <- getNamespace("parallel")
  [15:45:58.076]                     if (exists("sendData", mode = "function", 
  [15:45:58.076]                       envir = ns)) {
  [15:45:58.076]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.076]                         envir = ns)
  [15:45:58.076]                       envir <- sys.frame(frame)
  [15:45:58.076]                       master <- NULL
  [15:45:58.076]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.076]                         !identical(envir, emptyenv())) {
  [15:45:58.076]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.076]                           inherits = FALSE)) {
  [15:45:58.076]                           master <- get("master", mode = "list", 
  [15:45:58.076]                             envir = envir, inherits = FALSE)
  [15:45:58.076]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.076]                             sendCondition <<- function(cond) {
  [15:45:58.076]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.076]                                 success = TRUE)
  [15:45:58.076]                               parallel_sendData(master, data)
  [15:45:58.076]                             }
  [15:45:58.076]                             return(sendCondition)
  [15:45:58.076]                           }
  [15:45:58.076]                         }
  [15:45:58.076]                         frame <- frame + 1L
  [15:45:58.076]                         envir <- sys.frame(frame)
  [15:45:58.076]                       }
  [15:45:58.076]                     }
  [15:45:58.076]                     sendCondition <<- function(cond) NULL
  [15:45:58.076]                   }
  [15:45:58.076]                 })
  [15:45:58.076]                 withCallingHandlers({
  [15:45:58.076]                   2
  [15:45:58.076]                 }, immediateCondition = function(cond) {
  [15:45:58.076]                   sendCondition <- ...future.sendCondition()
  [15:45:58.076]                   sendCondition(cond)
  [15:45:58.076]                   muffleCondition <- function (cond) 
  [15:45:58.076]                   {
  [15:45:58.076]                     inherits <- base::inherits
  [15:45:58.076]                     invokeRestart <- base::invokeRestart
  [15:45:58.076]                     muffled <- FALSE
  [15:45:58.076]                     if (inherits(cond, "message")) {
  [15:45:58.076]                       invokeRestart("muffleMessage")
  [15:45:58.076]                       muffled <- TRUE
  [15:45:58.076]                     }
  [15:45:58.076]                     else if (inherits(cond, "warning")) {
  [15:45:58.076]                       invokeRestart("muffleWarning")
  [15:45:58.076]                       muffled <- TRUE
  [15:45:58.076]                     }
  [15:45:58.076]                     else if (inherits(cond, "condition")) {
  [15:45:58.076]                       computeRestarts <- base::computeRestarts
  [15:45:58.076]                       grepl <- base::grepl
  [15:45:58.076]                       is.null <- base::is.null
  [15:45:58.076]                       restarts <- computeRestarts(cond)
  [15:45:58.076]                       for (restart in restarts) {
  [15:45:58.076]                         name <- restart$name
  [15:45:58.076]                         if (is.null(name)) 
  [15:45:58.076]                           next
  [15:45:58.076]                         if (!grepl("^muffle", name)) 
  [15:45:58.076]                           next
  [15:45:58.076]                         invokeRestart(restart)
  [15:45:58.076]                         muffled <- TRUE
  [15:45:58.076]                         break
  [15:45:58.076]                       }
  [15:45:58.076]                     }
  [15:45:58.076]                     invisible(muffled)
  [15:45:58.076]                   }
  [15:45:58.076]                   muffleCondition(cond)
  [15:45:58.076]                 })
  [15:45:58.076]             }))
  [15:45:58.076]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.076]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.076]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.076]                 version = "1.8")
  [15:45:58.076]         }, condition = base::local({
  [15:45:58.076]             c <- base::c
  [15:45:58.076]             inherits <- base::inherits
  [15:45:58.076]             invokeRestart <- base::invokeRestart
  [15:45:58.076]             length <- base::length
  [15:45:58.076]             list <- base::list
  [15:45:58.076]             seq.int <- base::seq.int
  [15:45:58.076]             signalCondition <- base::signalCondition
  [15:45:58.076]             sys.calls <- base::sys.calls
  [15:45:58.076]             Sys.time <- base::Sys.time
  [15:45:58.076]             `[[` <- base::`[[`
  [15:45:58.076]             `+` <- base::`+`
  [15:45:58.076]             `<<-` <- base::`<<-`
  [15:45:58.076]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.076]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.076]                   3L)]
  [15:45:58.076]             }
  [15:45:58.076]             function(cond) {
  [15:45:58.076]                 if (inherits(cond, "error")) {
  [15:45:58.076]                   sessionInformation <- function() {
  [15:45:58.076]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.076]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.076]                       search = base::search(), system = base::Sys.info())
  [15:45:58.076]                   }
  [15:45:58.076]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.076]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.076]                     cond$call), session = sessionInformation(), 
  [15:45:58.076]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.076]                   signalCondition(cond)
  [15:45:58.076]                 }
  [15:45:58.076]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.076]                 ))) {
  [15:45:58.076]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.076]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.076]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.076]                   if (!signal) {
  [15:45:58.076]                     muffleCondition <- function (cond) 
  [15:45:58.076]                     {
  [15:45:58.076]                       inherits <- base::inherits
  [15:45:58.076]                       invokeRestart <- base::invokeRestart
  [15:45:58.076]                       muffled <- FALSE
  [15:45:58.076]                       if (inherits(cond, "message")) {
  [15:45:58.076]                         invokeRestart("muffleMessage")
  [15:45:58.076]                         muffled <- TRUE
  [15:45:58.076]                       }
  [15:45:58.076]                       else if (inherits(cond, "warning")) {
  [15:45:58.076]                         invokeRestart("muffleWarning")
  [15:45:58.076]                         muffled <- TRUE
  [15:45:58.076]                       }
  [15:45:58.076]                       else if (inherits(cond, "condition")) {
  [15:45:58.076]                         computeRestarts <- base::computeRestarts
  [15:45:58.076]                         grepl <- base::grepl
  [15:45:58.076]                         is.null <- base::is.null
  [15:45:58.076]                         restarts <- computeRestarts(cond)
  [15:45:58.076]                         for (restart in restarts) {
  [15:45:58.076]                           name <- restart$name
  [15:45:58.076]                           if (is.null(name)) 
  [15:45:58.076]                             next
  [15:45:58.076]                           if (!grepl("^muffle", name)) 
  [15:45:58.076]                             next
  [15:45:58.076]                           invokeRestart(restart)
  [15:45:58.076]                           muffled <- TRUE
  [15:45:58.076]                           break
  [15:45:58.076]                         }
  [15:45:58.076]                       }
  [15:45:58.076]                       invisible(muffled)
  [15:45:58.076]                     }
  [15:45:58.076]                     muffleCondition(cond)
  [15:45:58.076]                   }
  [15:45:58.076]                 }
  [15:45:58.076]             }
  [15:45:58.076]         }))
  [15:45:58.076]     }, error = function(ex) {
  [15:45:58.076]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.076]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.076]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.076]     }, finally = {
  [15:45:58.076]         {
  [15:45:58.076]             NULL
  [15:45:58.076]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.076]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.076]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.076]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.076]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.076]                 ...) 
  [15:45:58.076]             {
  [15:45:58.076]                 if (substitute) 
  [15:45:58.076]                   expr <- substitute(expr)
  [15:45:58.076]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.076]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.076]                   globals = globals, persistent = persistent, 
  [15:45:58.076]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.076]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.076]                   label = label, ...)
  [15:45:58.076]                 if (!future$lazy) 
  [15:45:58.076]                   future <- run(future)
  [15:45:58.076]                 invisible(future)
  [15:45:58.076]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.076]         }
  [15:45:58.076]         base::options(...future.oldOptions)
  [15:45:58.076]     })
  [15:45:58.076]     Sys.time
  [15:45:58.076]     if (base::is.na(TRUE)) {
  [15:45:58.076]     }
  [15:45:58.076]     else {
  [15:45:58.076]         base::sink(type = "output", split = FALSE)
  [15:45:58.076]         if (TRUE) {
  [15:45:58.076]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.076]         }
  [15:45:58.076]         else {
  [15:45:58.076]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.076]         }
  [15:45:58.076]         base::close(...future.stdout)
  [15:45:58.076]         ...future.stdout <- NULL
  [15:45:58.076]     }
  [15:45:58.076]     ...future.result$conditions <- ...future.conditions
  [15:45:58.076]     ...future.result
  [15:45:58.076] }
  [15:45:58.100] ClusterFuture started
  [15:45:58.100] getGlobalsAndPackages() ...
  [15:45:58.100] Searching for globals...
  [15:45:58.101] 
  [15:45:58.102] Searching for globals ... DONE
  [15:45:58.102] - globals: [0] <none>
  [15:45:58.102] getGlobalsAndPackages() ... DONE
  [15:45:58.108] Packages needed by the future expression (n = 0): <none>
  [15:45:58.108] Packages needed by future strategies (n = 0): <none>
  [15:45:58.132] {
  [15:45:58.132]     {
  [15:45:58.132]         ...future.startTime <- base::Sys.time()
  [15:45:58.132]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.132]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.132]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.132]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.132]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.132]         {
  [15:45:58.132]             {
  [15:45:58.132]                 base::local({
  [15:45:58.132]                   has_future <- base::requireNamespace("future", 
  [15:45:58.132]                     quietly = TRUE)
  [15:45:58.132]                   version <- if (has_future) 
  [15:45:58.132]                     utils::packageVersion("future")
  [15:45:58.132]                   else NULL
  [15:45:58.132]                   if (!has_future || version < "1.8.0") {
  [15:45:58.132]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.132]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.132]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.132]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.132]                         "release", "version")], collapse = " "), 
  [15:45:58.132]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.132]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.132]                       info)
  [15:45:58.132]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.132]                     if (!has_future) {
  [15:45:58.132]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.132]                         info)
  [15:45:58.132]                     }
  [15:45:58.132]                     else {
  [15:45:58.132]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.132]                         info, version)
  [15:45:58.132]                     }
  [15:45:58.132]                     base::stop(msg)
  [15:45:58.132]                   }
  [15:45:58.132]                 })
  [15:45:58.132]             }
  [15:45:58.132]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.132]         }
  [15:45:58.132]     }
  [15:45:58.132]     if (base::is.na(TRUE)) {
  [15:45:58.132]     }
  [15:45:58.132]     else {
  [15:45:58.132]         if (TRUE) {
  [15:45:58.132]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.132]                 open = "w")
  [15:45:58.132]         }
  [15:45:58.132]         else {
  [15:45:58.132]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.132]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.132]         }
  [15:45:58.132]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.132]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.132]             base::sink(type = "output", split = FALSE)
  [15:45:58.132]             base::close(...future.stdout)
  [15:45:58.132]         }, add = TRUE)
  [15:45:58.132]     }
  [15:45:58.132]     ...future.frame <- base::sys.nframe()
  [15:45:58.132]     ...future.conditions <- base::list()
  [15:45:58.132]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.132]     ...future.result <- base::tryCatch({
  [15:45:58.132]         base::withCallingHandlers({
  [15:45:58.132]             ...future.value <- base::withVisible(base::local({
  [15:45:58.132]                 ...future.sendCondition <- local({
  [15:45:58.132]                   sendCondition <- NULL
  [15:45:58.132]                   function(frame = 1L) {
  [15:45:58.132]                     if (is.function(sendCondition)) 
  [15:45:58.132]                       return(sendCondition)
  [15:45:58.132]                     ns <- getNamespace("parallel")
  [15:45:58.132]                     if (exists("sendData", mode = "function", 
  [15:45:58.132]                       envir = ns)) {
  [15:45:58.132]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.132]                         envir = ns)
  [15:45:58.132]                       envir <- sys.frame(frame)
  [15:45:58.132]                       master <- NULL
  [15:45:58.132]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.132]                         !identical(envir, emptyenv())) {
  [15:45:58.132]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.132]                           inherits = FALSE)) {
  [15:45:58.132]                           master <- get("master", mode = "list", 
  [15:45:58.132]                             envir = envir, inherits = FALSE)
  [15:45:58.132]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.132]                             sendCondition <<- function(cond) {
  [15:45:58.132]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.132]                                 success = TRUE)
  [15:45:58.132]                               parallel_sendData(master, data)
  [15:45:58.132]                             }
  [15:45:58.132]                             return(sendCondition)
  [15:45:58.132]                           }
  [15:45:58.132]                         }
  [15:45:58.132]                         frame <- frame + 1L
  [15:45:58.132]                         envir <- sys.frame(frame)
  [15:45:58.132]                       }
  [15:45:58.132]                     }
  [15:45:58.132]                     sendCondition <<- function(cond) NULL
  [15:45:58.132]                   }
  [15:45:58.132]                 })
  [15:45:58.132]                 withCallingHandlers({
  [15:45:58.132]                   NULL
  [15:45:58.132]                 }, immediateCondition = function(cond) {
  [15:45:58.132]                   sendCondition <- ...future.sendCondition()
  [15:45:58.132]                   sendCondition(cond)
  [15:45:58.132]                   muffleCondition <- function (cond) 
  [15:45:58.132]                   {
  [15:45:58.132]                     inherits <- base::inherits
  [15:45:58.132]                     invokeRestart <- base::invokeRestart
  [15:45:58.132]                     muffled <- FALSE
  [15:45:58.132]                     if (inherits(cond, "message")) {
  [15:45:58.132]                       invokeRestart("muffleMessage")
  [15:45:58.132]                       muffled <- TRUE
  [15:45:58.132]                     }
  [15:45:58.132]                     else if (inherits(cond, "warning")) {
  [15:45:58.132]                       invokeRestart("muffleWarning")
  [15:45:58.132]                       muffled <- TRUE
  [15:45:58.132]                     }
  [15:45:58.132]                     else if (inherits(cond, "condition")) {
  [15:45:58.132]                       computeRestarts <- base::computeRestarts
  [15:45:58.132]                       grepl <- base::grepl
  [15:45:58.132]                       is.null <- base::is.null
  [15:45:58.132]                       restarts <- computeRestarts(cond)
  [15:45:58.132]                       for (restart in restarts) {
  [15:45:58.132]                         name <- restart$name
  [15:45:58.132]                         if (is.null(name)) 
  [15:45:58.132]                           next
  [15:45:58.132]                         if (!grepl("^muffle", name)) 
  [15:45:58.132]                           next
  [15:45:58.132]                         invokeRestart(restart)
  [15:45:58.132]                         muffled <- TRUE
  [15:45:58.132]                         break
  [15:45:58.132]                       }
  [15:45:58.132]                     }
  [15:45:58.132]                     invisible(muffled)
  [15:45:58.132]                   }
  [15:45:58.132]                   muffleCondition(cond)
  [15:45:58.132]                 })
  [15:45:58.132]             }))
  [15:45:58.132]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.132]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.132]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.132]                 version = "1.8")
  [15:45:58.132]         }, condition = base::local({
  [15:45:58.132]             c <- base::c
  [15:45:58.132]             inherits <- base::inherits
  [15:45:58.132]             invokeRestart <- base::invokeRestart
  [15:45:58.132]             length <- base::length
  [15:45:58.132]             list <- base::list
  [15:45:58.132]             seq.int <- base::seq.int
  [15:45:58.132]             signalCondition <- base::signalCondition
  [15:45:58.132]             sys.calls <- base::sys.calls
  [15:45:58.132]             Sys.time <- base::Sys.time
  [15:45:58.132]             `[[` <- base::`[[`
  [15:45:58.132]             `+` <- base::`+`
  [15:45:58.132]             `<<-` <- base::`<<-`
  [15:45:58.132]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.132]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.132]                   3L)]
  [15:45:58.132]             }
  [15:45:58.132]             function(cond) {
  [15:45:58.132]                 if (inherits(cond, "error")) {
  [15:45:58.132]                   sessionInformation <- function() {
  [15:45:58.132]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.132]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.132]                       search = base::search(), system = base::Sys.info())
  [15:45:58.132]                   }
  [15:45:58.132]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.132]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.132]                     cond$call), session = sessionInformation(), 
  [15:45:58.132]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.132]                   signalCondition(cond)
  [15:45:58.132]                 }
  [15:45:58.132]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.132]                 ))) {
  [15:45:58.132]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.132]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.132]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.132]                   if (!signal) {
  [15:45:58.132]                     muffleCondition <- function (cond) 
  [15:45:58.132]                     {
  [15:45:58.132]                       inherits <- base::inherits
  [15:45:58.132]                       invokeRestart <- base::invokeRestart
  [15:45:58.132]                       muffled <- FALSE
  [15:45:58.132]                       if (inherits(cond, "message")) {
  [15:45:58.132]                         invokeRestart("muffleMessage")
  [15:45:58.132]                         muffled <- TRUE
  [15:45:58.132]                       }
  [15:45:58.132]                       else if (inherits(cond, "warning")) {
  [15:45:58.132]                         invokeRestart("muffleWarning")
  [15:45:58.132]                         muffled <- TRUE
  [15:45:58.132]                       }
  [15:45:58.132]                       else if (inherits(cond, "condition")) {
  [15:45:58.132]                         computeRestarts <- base::computeRestarts
  [15:45:58.132]                         grepl <- base::grepl
  [15:45:58.132]                         is.null <- base::is.null
  [15:45:58.132]                         restarts <- computeRestarts(cond)
  [15:45:58.132]                         for (restart in restarts) {
  [15:45:58.132]                           name <- restart$name
  [15:45:58.132]                           if (is.null(name)) 
  [15:45:58.132]                             next
  [15:45:58.132]                           if (!grepl("^muffle", name)) 
  [15:45:58.132]                             next
  [15:45:58.132]                           invokeRestart(restart)
  [15:45:58.132]                           muffled <- TRUE
  [15:45:58.132]                           break
  [15:45:58.132]                         }
  [15:45:58.132]                       }
  [15:45:58.132]                       invisible(muffled)
  [15:45:58.132]                     }
  [15:45:58.132]                     muffleCondition(cond)
  [15:45:58.132]                   }
  [15:45:58.132]                 }
  [15:45:58.132]             }
  [15:45:58.132]         }))
  [15:45:58.132]     }, error = function(ex) {
  [15:45:58.132]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.132]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.132]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.132]     }, finally = {
  [15:45:58.132]         {
  [15:45:58.132]             NULL
  [15:45:58.132]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.132]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.132]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.132]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.132]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.132]                 ...) 
  [15:45:58.132]             {
  [15:45:58.132]                 if (substitute) 
  [15:45:58.132]                   expr <- substitute(expr)
  [15:45:58.132]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.132]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.132]                   globals = globals, persistent = persistent, 
  [15:45:58.132]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.132]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.132]                   label = label, ...)
  [15:45:58.132]                 if (!future$lazy) 
  [15:45:58.132]                   future <- run(future)
  [15:45:58.132]                 invisible(future)
  [15:45:58.132]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.132]         }
  [15:45:58.132]         base::options(...future.oldOptions)
  [15:45:58.132]     })
  [15:45:58.132]     Sys.time
  [15:45:58.132]     if (base::is.na(TRUE)) {
  [15:45:58.132]     }
  [15:45:58.132]     else {
  [15:45:58.132]         base::sink(type = "output", split = FALSE)
  [15:45:58.132]         if (TRUE) {
  [15:45:58.132]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.132]         }
  [15:45:58.132]         else {
  [15:45:58.132]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.132]         }
  [15:45:58.132]         base::close(...future.stdout)
  [15:45:58.132]         ...future.stdout <- NULL
  [15:45:58.132]     }
  [15:45:58.132]     ...future.result$conditions <- ...future.conditions
  [15:45:58.132]     ...future.result
  [15:45:58.132] }
  [15:45:58.138] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.151] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.152] - Validating connection of ClusterFuture
  [15:45:58.152] - received message: FutureResult
  [15:45:58.153] - Received FutureResult
  [15:45:58.153] - Erased future from FutureRegistry
  [15:45:58.153] result() for ClusterFuture ...
  [15:45:58.154] - result already collected: FutureResult
  [15:45:58.154] result() for ClusterFuture ... done
  [15:45:58.154] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.155] result() for ClusterFuture ...
  [15:45:58.155] - result already collected: FutureResult
  [15:45:58.156] result() for ClusterFuture ... done
  [15:45:58.156] result() for ClusterFuture ...
  [15:45:58.156] - result already collected: FutureResult
  [15:45:58.157] result() for ClusterFuture ... done
  [15:45:58.171] ClusterFuture started
  [15:45:58.173] getGlobalsAndPackages() ...
  [15:45:58.173] Searching for globals...
  [15:45:58.175] - globals found: [1] '{'
  [15:45:58.175] Searching for globals ... DONE
  [15:45:58.176] Resolving globals: FALSE
  [15:45:58.176] 
  [15:45:58.177] 
  [15:45:58.177] getGlobalsAndPackages() ... DONE
  [15:45:58.183] Packages needed by the future expression (n = 0): <none>
  [15:45:58.184] Packages needed by future strategies (n = 0): <none>
  [15:45:58.207] {
  [15:45:58.207]     {
  [15:45:58.207]         ...future.startTime <- base::Sys.time()
  [15:45:58.207]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.207]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.207]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.207]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.207]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.207]         {
  [15:45:58.207]             {
  [15:45:58.207]                 base::local({
  [15:45:58.207]                   has_future <- base::requireNamespace("future", 
  [15:45:58.207]                     quietly = TRUE)
  [15:45:58.207]                   version <- if (has_future) 
  [15:45:58.207]                     utils::packageVersion("future")
  [15:45:58.207]                   else NULL
  [15:45:58.207]                   if (!has_future || version < "1.8.0") {
  [15:45:58.207]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.207]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.207]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.207]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.207]                         "release", "version")], collapse = " "), 
  [15:45:58.207]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.207]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.207]                       info)
  [15:45:58.207]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.207]                     if (!has_future) {
  [15:45:58.207]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.207]                         info)
  [15:45:58.207]                     }
  [15:45:58.207]                     else {
  [15:45:58.207]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.207]                         info, version)
  [15:45:58.207]                     }
  [15:45:58.207]                     base::stop(msg)
  [15:45:58.207]                   }
  [15:45:58.207]                 })
  [15:45:58.207]             }
  [15:45:58.207]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.207]         }
  [15:45:58.207]     }
  [15:45:58.207]     if (base::is.na(TRUE)) {
  [15:45:58.207]     }
  [15:45:58.207]     else {
  [15:45:58.207]         if (TRUE) {
  [15:45:58.207]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.207]                 open = "w")
  [15:45:58.207]         }
  [15:45:58.207]         else {
  [15:45:58.207]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.207]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.207]         }
  [15:45:58.207]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.207]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.207]             base::sink(type = "output", split = FALSE)
  [15:45:58.207]             base::close(...future.stdout)
  [15:45:58.207]         }, add = TRUE)
  [15:45:58.207]     }
  [15:45:58.207]     ...future.frame <- base::sys.nframe()
  [15:45:58.207]     ...future.conditions <- base::list()
  [15:45:58.207]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.207]     ...future.result <- base::tryCatch({
  [15:45:58.207]         base::withCallingHandlers({
  [15:45:58.207]             ...future.value <- base::withVisible(base::local({
  [15:45:58.207]                 ...future.sendCondition <- local({
  [15:45:58.207]                   sendCondition <- NULL
  [15:45:58.207]                   function(frame = 1L) {
  [15:45:58.207]                     if (is.function(sendCondition)) 
  [15:45:58.207]                       return(sendCondition)
  [15:45:58.207]                     ns <- getNamespace("parallel")
  [15:45:58.207]                     if (exists("sendData", mode = "function", 
  [15:45:58.207]                       envir = ns)) {
  [15:45:58.207]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.207]                         envir = ns)
  [15:45:58.207]                       envir <- sys.frame(frame)
  [15:45:58.207]                       master <- NULL
  [15:45:58.207]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.207]                         !identical(envir, emptyenv())) {
  [15:45:58.207]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.207]                           inherits = FALSE)) {
  [15:45:58.207]                           master <- get("master", mode = "list", 
  [15:45:58.207]                             envir = envir, inherits = FALSE)
  [15:45:58.207]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.207]                             sendCondition <<- function(cond) {
  [15:45:58.207]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.207]                                 success = TRUE)
  [15:45:58.207]                               parallel_sendData(master, data)
  [15:45:58.207]                             }
  [15:45:58.207]                             return(sendCondition)
  [15:45:58.207]                           }
  [15:45:58.207]                         }
  [15:45:58.207]                         frame <- frame + 1L
  [15:45:58.207]                         envir <- sys.frame(frame)
  [15:45:58.207]                       }
  [15:45:58.207]                     }
  [15:45:58.207]                     sendCondition <<- function(cond) NULL
  [15:45:58.207]                   }
  [15:45:58.207]                 })
  [15:45:58.207]                 withCallingHandlers({
  [15:45:58.207]                   {
  [15:45:58.207]                     4
  [15:45:58.207]                   }
  [15:45:58.207]                 }, immediateCondition = function(cond) {
  [15:45:58.207]                   sendCondition <- ...future.sendCondition()
  [15:45:58.207]                   sendCondition(cond)
  [15:45:58.207]                   muffleCondition <- function (cond) 
  [15:45:58.207]                   {
  [15:45:58.207]                     inherits <- base::inherits
  [15:45:58.207]                     invokeRestart <- base::invokeRestart
  [15:45:58.207]                     muffled <- FALSE
  [15:45:58.207]                     if (inherits(cond, "message")) {
  [15:45:58.207]                       invokeRestart("muffleMessage")
  [15:45:58.207]                       muffled <- TRUE
  [15:45:58.207]                     }
  [15:45:58.207]                     else if (inherits(cond, "warning")) {
  [15:45:58.207]                       invokeRestart("muffleWarning")
  [15:45:58.207]                       muffled <- TRUE
  [15:45:58.207]                     }
  [15:45:58.207]                     else if (inherits(cond, "condition")) {
  [15:45:58.207]                       computeRestarts <- base::computeRestarts
  [15:45:58.207]                       grepl <- base::grepl
  [15:45:58.207]                       is.null <- base::is.null
  [15:45:58.207]                       restarts <- computeRestarts(cond)
  [15:45:58.207]                       for (restart in restarts) {
  [15:45:58.207]                         name <- restart$name
  [15:45:58.207]                         if (is.null(name)) 
  [15:45:58.207]                           next
  [15:45:58.207]                         if (!grepl("^muffle", name)) 
  [15:45:58.207]                           next
  [15:45:58.207]                         invokeRestart(restart)
  [15:45:58.207]                         muffled <- TRUE
  [15:45:58.207]                         break
  [15:45:58.207]                       }
  [15:45:58.207]                     }
  [15:45:58.207]                     invisible(muffled)
  [15:45:58.207]                   }
  [15:45:58.207]                   muffleCondition(cond)
  [15:45:58.207]                 })
  [15:45:58.207]             }))
  [15:45:58.207]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.207]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.207]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.207]                 version = "1.8")
  [15:45:58.207]         }, condition = base::local({
  [15:45:58.207]             c <- base::c
  [15:45:58.207]             inherits <- base::inherits
  [15:45:58.207]             invokeRestart <- base::invokeRestart
  [15:45:58.207]             length <- base::length
  [15:45:58.207]             list <- base::list
  [15:45:58.207]             seq.int <- base::seq.int
  [15:45:58.207]             signalCondition <- base::signalCondition
  [15:45:58.207]             sys.calls <- base::sys.calls
  [15:45:58.207]             Sys.time <- base::Sys.time
  [15:45:58.207]             `[[` <- base::`[[`
  [15:45:58.207]             `+` <- base::`+`
  [15:45:58.207]             `<<-` <- base::`<<-`
  [15:45:58.207]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.207]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.207]                   3L)]
  [15:45:58.207]             }
  [15:45:58.207]             function(cond) {
  [15:45:58.207]                 if (inherits(cond, "error")) {
  [15:45:58.207]                   sessionInformation <- function() {
  [15:45:58.207]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.207]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.207]                       search = base::search(), system = base::Sys.info())
  [15:45:58.207]                   }
  [15:45:58.207]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.207]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.207]                     cond$call), session = sessionInformation(), 
  [15:45:58.207]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.207]                   signalCondition(cond)
  [15:45:58.207]                 }
  [15:45:58.207]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.207]                 ))) {
  [15:45:58.207]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.207]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.207]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.207]                   if (!signal) {
  [15:45:58.207]                     muffleCondition <- function (cond) 
  [15:45:58.207]                     {
  [15:45:58.207]                       inherits <- base::inherits
  [15:45:58.207]                       invokeRestart <- base::invokeRestart
  [15:45:58.207]                       muffled <- FALSE
  [15:45:58.207]                       if (inherits(cond, "message")) {
  [15:45:58.207]                         invokeRestart("muffleMessage")
  [15:45:58.207]                         muffled <- TRUE
  [15:45:58.207]                       }
  [15:45:58.207]                       else if (inherits(cond, "warning")) {
  [15:45:58.207]                         invokeRestart("muffleWarning")
  [15:45:58.207]                         muffled <- TRUE
  [15:45:58.207]                       }
  [15:45:58.207]                       else if (inherits(cond, "condition")) {
  [15:45:58.207]                         computeRestarts <- base::computeRestarts
  [15:45:58.207]                         grepl <- base::grepl
  [15:45:58.207]                         is.null <- base::is.null
  [15:45:58.207]                         restarts <- computeRestarts(cond)
  [15:45:58.207]                         for (restart in restarts) {
  [15:45:58.207]                           name <- restart$name
  [15:45:58.207]                           if (is.null(name)) 
  [15:45:58.207]                             next
  [15:45:58.207]                           if (!grepl("^muffle", name)) 
  [15:45:58.207]                             next
  [15:45:58.207]                           invokeRestart(restart)
  [15:45:58.207]                           muffled <- TRUE
  [15:45:58.207]                           break
  [15:45:58.207]                         }
  [15:45:58.207]                       }
  [15:45:58.207]                       invisible(muffled)
  [15:45:58.207]                     }
  [15:45:58.207]                     muffleCondition(cond)
  [15:45:58.207]                   }
  [15:45:58.207]                 }
  [15:45:58.207]             }
  [15:45:58.207]         }))
  [15:45:58.207]     }, error = function(ex) {
  [15:45:58.207]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.207]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.207]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.207]     }, finally = {
  [15:45:58.207]         {
  [15:45:58.207]             NULL
  [15:45:58.207]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.207]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.207]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.207]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.207]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.207]                 ...) 
  [15:45:58.207]             {
  [15:45:58.207]                 if (substitute) 
  [15:45:58.207]                   expr <- substitute(expr)
  [15:45:58.207]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.207]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.207]                   globals = globals, persistent = persistent, 
  [15:45:58.207]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.207]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.207]                   label = label, ...)
  [15:45:58.207]                 if (!future$lazy) 
  [15:45:58.207]                   future <- run(future)
  [15:45:58.207]                 invisible(future)
  [15:45:58.207]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.207]         }
  [15:45:58.207]         base::options(...future.oldOptions)
  [15:45:58.207]     })
  [15:45:58.207]     Sys.time
  [15:45:58.207]     if (base::is.na(TRUE)) {
  [15:45:58.207]     }
  [15:45:58.207]     else {
  [15:45:58.207]         base::sink(type = "output", split = FALSE)
  [15:45:58.207]         if (TRUE) {
  [15:45:58.207]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.207]         }
  [15:45:58.207]         else {
  [15:45:58.207]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.207]         }
  [15:45:58.207]         base::close(...future.stdout)
  [15:45:58.207]         ...future.stdout <- NULL
  [15:45:58.207]     }
  [15:45:58.207]     ...future.result$conditions <- ...future.conditions
  [15:45:58.207]     ...future.result
  [15:45:58.207] }
  [15:45:58.212] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.236] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.236] - Validating connection of ClusterFuture
  [15:45:58.237] - received message: FutureResult
  [15:45:58.237] - Received FutureResult
  [15:45:58.238] - Erased future from FutureRegistry
  [15:45:58.238] result() for ClusterFuture ...
  [15:45:58.239] - result already collected: FutureResult
  [15:45:58.239] result() for ClusterFuture ... done
  [15:45:58.240] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.240] result() for ClusterFuture ...
  [15:45:58.241] - result already collected: FutureResult
  [15:45:58.241] result() for ClusterFuture ... done
  [15:45:58.242] result() for ClusterFuture ...
  [15:45:58.242] - result already collected: FutureResult
  [15:45:58.256] result() for ClusterFuture ... done
  [15:45:58.259] ClusterFuture started
  <environment: 0x55ca2b1402d8> 
  <environment: 0x55ca29891540> 
  [15:45:58.303] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.304] - Validating connection of ClusterFuture
  [15:45:58.304] - received message: FutureResult
  [15:45:58.305] - Received FutureResult
  [15:45:58.305] - Erased future from FutureRegistry
  [15:45:58.306] result() for ClusterFuture ...
  [15:45:58.306] - result already collected: FutureResult
  [15:45:58.306] result() for ClusterFuture ... done
  [15:45:58.307] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:58.311] resolve() on environment ...
  [15:45:58.311]  recursive: 0
  [15:45:58.313]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:58.313] signalConditionsASAP(numeric, pos=1) ...
  [15:45:58.313] - nx: 4
  [15:45:58.314] - relay: TRUE
  [15:45:58.314] - stdout: TRUE
  [15:45:58.314] - signal: TRUE
  [15:45:58.315] - resignal: FALSE
  [15:45:58.315] - force: TRUE
  [15:45:58.315] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.316] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.316]  - until=2
  [15:45:58.316]  - relaying element #2
  [15:45:58.317] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.317] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.317] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:58.318]  length: 3 (resolved future 1)
  [15:45:58.318] Future #2
  [15:45:58.322] result() for ClusterFuture ...
  [15:45:58.323] - result already collected: FutureResult
  [15:45:58.323] result() for ClusterFuture ... done
  [15:45:58.324] result() for ClusterFuture ...
  [15:45:58.324] - result already collected: FutureResult
  [15:45:58.324] result() for ClusterFuture ... done
  [15:45:58.325] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:58.325] - nx: 4
  [15:45:58.325] - relay: TRUE
  [15:45:58.326] - stdout: TRUE
  [15:45:58.326] - signal: TRUE
  [15:45:58.326] - resignal: FALSE
  [15:45:58.327] - force: TRUE
  [15:45:58.327] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.327] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.328]  - until=2
  [15:45:58.328]  - relaying element #2
  [15:45:58.328] result() for ClusterFuture ...
  [15:45:58.329] - result already collected: FutureResult
  [15:45:58.329] result() for ClusterFuture ... done
  [15:45:58.330] result() for ClusterFuture ...
  [15:45:58.330] - result already collected: FutureResult
  [15:45:58.330] result() for ClusterFuture ... done
  [15:45:58.331] result() for ClusterFuture ...
  [15:45:58.331] - result already collected: FutureResult
  [15:45:58.331] result() for ClusterFuture ... done
  [15:45:58.332] result() for ClusterFuture ...
  [15:45:58.332] - result already collected: FutureResult
  [15:45:58.333] result() for ClusterFuture ... done
  [15:45:58.333] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.333] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.334] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:58.334]  length: 2 (resolved future 2)
  [15:45:58.338] Future #3
  [15:45:58.339] result() for ClusterFuture ...
  [15:45:58.339] - result already collected: FutureResult
  [15:45:58.340] result() for ClusterFuture ... done
  [15:45:58.340] result() for ClusterFuture ...
  [15:45:58.340] - result already collected: FutureResult
  [15:45:58.341] result() for ClusterFuture ... done
  [15:45:58.341] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:58.342] - nx: 4
  [15:45:58.342] - relay: TRUE
  [15:45:58.342] - stdout: TRUE
  [15:45:58.343] - signal: TRUE
  [15:45:58.343] - resignal: FALSE
  [15:45:58.343] - force: TRUE
  [15:45:58.344] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.344] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.344]  - until=3
  [15:45:58.345]  - relaying element #3
  [15:45:58.345] result() for ClusterFuture ...
  [15:45:58.345] - result already collected: FutureResult
  [15:45:58.346] result() for ClusterFuture ... done
  [15:45:58.346] result() for ClusterFuture ...
  [15:45:58.348] - result already collected: FutureResult
  [15:45:58.348] result() for ClusterFuture ... done
  [15:45:58.349] result() for ClusterFuture ...
  [15:45:58.349] - result already collected: FutureResult
  [15:45:58.350] result() for ClusterFuture ... done
  [15:45:58.350] result() for ClusterFuture ...
  [15:45:58.350] - result already collected: FutureResult
  [15:45:58.351] result() for ClusterFuture ... done
  [15:45:58.351] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.351] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.352] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:58.352]  length: 1 (resolved future 3)
  [15:45:58.353] Future #4
  [15:45:58.353] result() for ClusterFuture ...
  [15:45:58.353] - result already collected: FutureResult
  [15:45:58.354] result() for ClusterFuture ... done
  [15:45:58.354] result() for ClusterFuture ...
  [15:45:58.355] - result already collected: FutureResult
  [15:45:58.356] result() for ClusterFuture ... done
  [15:45:58.356] signalConditionsASAP(ClusterFuture, pos=4) ...
  [15:45:58.357] - nx: 4
  [15:45:58.357] - relay: TRUE
  [15:45:58.357] - stdout: TRUE
  [15:45:58.358] - signal: TRUE
  [15:45:58.358] - resignal: FALSE
  [15:45:58.358] - force: TRUE
  [15:45:58.359] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.359] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.359]  - until=4
  [15:45:58.360]  - relaying element #4
  [15:45:58.360] result() for ClusterFuture ...
  [15:45:58.361] - result already collected: FutureResult
  [15:45:58.361] result() for ClusterFuture ... done
  [15:45:58.361] result() for ClusterFuture ...
  [15:45:58.362] - result already collected: FutureResult
  [15:45:58.362] result() for ClusterFuture ... done
  [15:45:58.363] result() for ClusterFuture ...
  [15:45:58.363] - result already collected: FutureResult
  [15:45:58.363] result() for ClusterFuture ... done
  [15:45:58.364] result() for ClusterFuture ...
  [15:45:58.364] - result already collected: FutureResult
  [15:45:58.364] result() for ClusterFuture ... done
  [15:45:58.365] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.365] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.365] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [15:45:58.366]  length: 0 (resolved future 4)
  [15:45:58.366] Relaying remaining futures
  [15:45:58.366] signalConditionsASAP(NULL, pos=0) ...
  [15:45:58.367] - nx: 4
  [15:45:58.367] - relay: TRUE
  [15:45:58.367] - stdout: TRUE
  [15:45:58.368] - signal: TRUE
  [15:45:58.368] - resignal: FALSE
  [15:45:58.368] - force: TRUE
  [15:45:58.369] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.369] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:58.370] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.370] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.370] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:58.371] resolve() on environment ... DONE
  [15:45:58.371] result() for ClusterFuture ...
  [15:45:58.372] - result already collected: FutureResult
  [15:45:58.372] result() for ClusterFuture ... done
  [15:45:58.372] result() for ClusterFuture ...
  [15:45:58.373] - result already collected: FutureResult
  [15:45:58.373] result() for ClusterFuture ... done
  [15:45:58.374] result() for ClusterFuture ...
  [15:45:58.374] - result already collected: FutureResult
  [15:45:58.374] result() for ClusterFuture ... done
  [15:45:58.375] result() for ClusterFuture ...
  [15:45:58.375] - result already collected: FutureResult
  [15:45:58.375] result() for ClusterFuture ... done
  [15:45:58.376] result() for ClusterFuture ...
  [15:45:58.376] - result already collected: FutureResult
  [15:45:58.376] result() for ClusterFuture ... done
  [15:45:58.377] result() for ClusterFuture ...
  [15:45:58.377] - result already collected: FutureResult
  [15:45:58.378] result() for ClusterFuture ... done
  <environment: 0x55ca28f67390> 
  Dimensions: c(1, 6)
  [15:45:58.379] getGlobalsAndPackages() ...
  [15:45:58.380] Searching for globals...
  [15:45:58.380] 
  [15:45:58.381] Searching for globals ... DONE
  [15:45:58.381] - globals: [0] <none>
  [15:45:58.382] getGlobalsAndPackages() ... DONE
  [15:45:58.407] Packages needed by the future expression (n = 0): <none>
  [15:45:58.408] Packages needed by future strategies (n = 0): <none>
  [15:45:58.414] {
  [15:45:58.414]     {
  [15:45:58.414]         ...future.startTime <- base::Sys.time()
  [15:45:58.414]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.414]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.414]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.414]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.414]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.414]         {
  [15:45:58.414]             {
  [15:45:58.414]                 base::local({
  [15:45:58.414]                   has_future <- base::requireNamespace("future", 
  [15:45:58.414]                     quietly = TRUE)
  [15:45:58.414]                   version <- if (has_future) 
  [15:45:58.414]                     utils::packageVersion("future")
  [15:45:58.414]                   else NULL
  [15:45:58.414]                   if (!has_future || version < "1.8.0") {
  [15:45:58.414]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.414]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.414]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.414]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.414]                         "release", "version")], collapse = " "), 
  [15:45:58.414]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.414]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.414]                       info)
  [15:45:58.414]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.414]                     if (!has_future) {
  [15:45:58.414]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.414]                         info)
  [15:45:58.414]                     }
  [15:45:58.414]                     else {
  [15:45:58.414]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.414]                         info, version)
  [15:45:58.414]                     }
  [15:45:58.414]                     base::stop(msg)
  [15:45:58.414]                   }
  [15:45:58.414]                 })
  [15:45:58.414]             }
  [15:45:58.414]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.414]         }
  [15:45:58.414]     }
  [15:45:58.414]     if (base::is.na(TRUE)) {
  [15:45:58.414]     }
  [15:45:58.414]     else {
  [15:45:58.414]         if (TRUE) {
  [15:45:58.414]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.414]                 open = "w")
  [15:45:58.414]         }
  [15:45:58.414]         else {
  [15:45:58.414]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.414]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.414]         }
  [15:45:58.414]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.414]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.414]             base::sink(type = "output", split = FALSE)
  [15:45:58.414]             base::close(...future.stdout)
  [15:45:58.414]         }, add = TRUE)
  [15:45:58.414]     }
  [15:45:58.414]     ...future.frame <- base::sys.nframe()
  [15:45:58.414]     ...future.conditions <- base::list()
  [15:45:58.414]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.414]     ...future.result <- base::tryCatch({
  [15:45:58.414]         base::withCallingHandlers({
  [15:45:58.414]             ...future.value <- base::withVisible(base::local({
  [15:45:58.414]                 ...future.sendCondition <- local({
  [15:45:58.414]                   sendCondition <- NULL
  [15:45:58.414]                   function(frame = 1L) {
  [15:45:58.414]                     if (is.function(sendCondition)) 
  [15:45:58.414]                       return(sendCondition)
  [15:45:58.414]                     ns <- getNamespace("parallel")
  [15:45:58.414]                     if (exists("sendData", mode = "function", 
  [15:45:58.414]                       envir = ns)) {
  [15:45:58.414]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.414]                         envir = ns)
  [15:45:58.414]                       envir <- sys.frame(frame)
  [15:45:58.414]                       master <- NULL
  [15:45:58.414]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.414]                         !identical(envir, emptyenv())) {
  [15:45:58.414]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.414]                           inherits = FALSE)) {
  [15:45:58.414]                           master <- get("master", mode = "list", 
  [15:45:58.414]                             envir = envir, inherits = FALSE)
  [15:45:58.414]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.414]                             sendCondition <<- function(cond) {
  [15:45:58.414]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.414]                                 success = TRUE)
  [15:45:58.414]                               parallel_sendData(master, data)
  [15:45:58.414]                             }
  [15:45:58.414]                             return(sendCondition)
  [15:45:58.414]                           }
  [15:45:58.414]                         }
  [15:45:58.414]                         frame <- frame + 1L
  [15:45:58.414]                         envir <- sys.frame(frame)
  [15:45:58.414]                       }
  [15:45:58.414]                     }
  [15:45:58.414]                     sendCondition <<- function(cond) NULL
  [15:45:58.414]                   }
  [15:45:58.414]                 })
  [15:45:58.414]                 withCallingHandlers({
  [15:45:58.414]                   2
  [15:45:58.414]                 }, immediateCondition = function(cond) {
  [15:45:58.414]                   sendCondition <- ...future.sendCondition()
  [15:45:58.414]                   sendCondition(cond)
  [15:45:58.414]                   muffleCondition <- function (cond) 
  [15:45:58.414]                   {
  [15:45:58.414]                     inherits <- base::inherits
  [15:45:58.414]                     invokeRestart <- base::invokeRestart
  [15:45:58.414]                     muffled <- FALSE
  [15:45:58.414]                     if (inherits(cond, "message")) {
  [15:45:58.414]                       invokeRestart("muffleMessage")
  [15:45:58.414]                       muffled <- TRUE
  [15:45:58.414]                     }
  [15:45:58.414]                     else if (inherits(cond, "warning")) {
  [15:45:58.414]                       invokeRestart("muffleWarning")
  [15:45:58.414]                       muffled <- TRUE
  [15:45:58.414]                     }
  [15:45:58.414]                     else if (inherits(cond, "condition")) {
  [15:45:58.414]                       computeRestarts <- base::computeRestarts
  [15:45:58.414]                       grepl <- base::grepl
  [15:45:58.414]                       is.null <- base::is.null
  [15:45:58.414]                       restarts <- computeRestarts(cond)
  [15:45:58.414]                       for (restart in restarts) {
  [15:45:58.414]                         name <- restart$name
  [15:45:58.414]                         if (is.null(name)) 
  [15:45:58.414]                           next
  [15:45:58.414]                         if (!grepl("^muffle", name)) 
  [15:45:58.414]                           next
  [15:45:58.414]                         invokeRestart(restart)
  [15:45:58.414]                         muffled <- TRUE
  [15:45:58.414]                         break
  [15:45:58.414]                       }
  [15:45:58.414]                     }
  [15:45:58.414]                     invisible(muffled)
  [15:45:58.414]                   }
  [15:45:58.414]                   muffleCondition(cond)
  [15:45:58.414]                 })
  [15:45:58.414]             }))
  [15:45:58.414]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.414]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.414]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.414]                 version = "1.8")
  [15:45:58.414]         }, condition = base::local({
  [15:45:58.414]             c <- base::c
  [15:45:58.414]             inherits <- base::inherits
  [15:45:58.414]             invokeRestart <- base::invokeRestart
  [15:45:58.414]             length <- base::length
  [15:45:58.414]             list <- base::list
  [15:45:58.414]             seq.int <- base::seq.int
  [15:45:58.414]             signalCondition <- base::signalCondition
  [15:45:58.414]             sys.calls <- base::sys.calls
  [15:45:58.414]             Sys.time <- base::Sys.time
  [15:45:58.414]             `[[` <- base::`[[`
  [15:45:58.414]             `+` <- base::`+`
  [15:45:58.414]             `<<-` <- base::`<<-`
  [15:45:58.414]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.414]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.414]                   3L)]
  [15:45:58.414]             }
  [15:45:58.414]             function(cond) {
  [15:45:58.414]                 if (inherits(cond, "error")) {
  [15:45:58.414]                   sessionInformation <- function() {
  [15:45:58.414]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.414]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.414]                       search = base::search(), system = base::Sys.info())
  [15:45:58.414]                   }
  [15:45:58.414]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.414]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.414]                     cond$call), session = sessionInformation(), 
  [15:45:58.414]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.414]                   signalCondition(cond)
  [15:45:58.414]                 }
  [15:45:58.414]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.414]                 ))) {
  [15:45:58.414]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.414]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.414]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.414]                   if (!signal) {
  [15:45:58.414]                     muffleCondition <- function (cond) 
  [15:45:58.414]                     {
  [15:45:58.414]                       inherits <- base::inherits
  [15:45:58.414]                       invokeRestart <- base::invokeRestart
  [15:45:58.414]                       muffled <- FALSE
  [15:45:58.414]                       if (inherits(cond, "message")) {
  [15:45:58.414]                         invokeRestart("muffleMessage")
  [15:45:58.414]                         muffled <- TRUE
  [15:45:58.414]                       }
  [15:45:58.414]                       else if (inherits(cond, "warning")) {
  [15:45:58.414]                         invokeRestart("muffleWarning")
  [15:45:58.414]                         muffled <- TRUE
  [15:45:58.414]                       }
  [15:45:58.414]                       else if (inherits(cond, "condition")) {
  [15:45:58.414]                         computeRestarts <- base::computeRestarts
  [15:45:58.414]                         grepl <- base::grepl
  [15:45:58.414]                         is.null <- base::is.null
  [15:45:58.414]                         restarts <- computeRestarts(cond)
  [15:45:58.414]                         for (restart in restarts) {
  [15:45:58.414]                           name <- restart$name
  [15:45:58.414]                           if (is.null(name)) 
  [15:45:58.414]                             next
  [15:45:58.414]                           if (!grepl("^muffle", name)) 
  [15:45:58.414]                             next
  [15:45:58.414]                           invokeRestart(restart)
  [15:45:58.414]                           muffled <- TRUE
  [15:45:58.414]                           break
  [15:45:58.414]                         }
  [15:45:58.414]                       }
  [15:45:58.414]                       invisible(muffled)
  [15:45:58.414]                     }
  [15:45:58.414]                     muffleCondition(cond)
  [15:45:58.414]                   }
  [15:45:58.414]                 }
  [15:45:58.414]             }
  [15:45:58.414]         }))
  [15:45:58.414]     }, error = function(ex) {
  [15:45:58.414]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.414]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.414]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.414]     }, finally = {
  [15:45:58.414]         {
  [15:45:58.414]             NULL
  [15:45:58.414]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.414]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.414]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.414]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.414]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.414]                 ...) 
  [15:45:58.414]             {
  [15:45:58.414]                 if (substitute) 
  [15:45:58.414]                   expr <- substitute(expr)
  [15:45:58.414]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.414]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.414]                   globals = globals, persistent = persistent, 
  [15:45:58.414]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.414]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.414]                   label = label, ...)
  [15:45:58.414]                 if (!future$lazy) 
  [15:45:58.414]                   future <- run(future)
  [15:45:58.414]                 invisible(future)
  [15:45:58.414]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.414]         }
  [15:45:58.414]         base::options(...future.oldOptions)
  [15:45:58.414]     })
  [15:45:58.414]     Sys.time
  [15:45:58.414]     if (base::is.na(TRUE)) {
  [15:45:58.414]     }
  [15:45:58.414]     else {
  [15:45:58.414]         base::sink(type = "output", split = FALSE)
  [15:45:58.414]         if (TRUE) {
  [15:45:58.414]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.414]         }
  [15:45:58.414]         else {
  [15:45:58.414]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.414]         }
  [15:45:58.414]         base::close(...future.stdout)
  [15:45:58.414]         ...future.stdout <- NULL
  [15:45:58.414]     }
  [15:45:58.414]     ...future.result$conditions <- ...future.conditions
  [15:45:58.414]     ...future.result
  [15:45:58.414] }
  [15:45:58.459] ClusterFuture started
  [15:45:58.460] getGlobalsAndPackages() ...
  [15:45:58.460] Searching for globals...
  [15:45:58.461] 
  [15:45:58.462] Searching for globals ... DONE
  [15:45:58.462] - globals: [0] <none>
  [15:45:58.462] getGlobalsAndPackages() ... DONE
  [15:45:58.468] Packages needed by the future expression (n = 0): <none>
  [15:45:58.469] Packages needed by future strategies (n = 0): <none>
  [15:45:58.475] {
  [15:45:58.475]     {
  [15:45:58.475]         ...future.startTime <- base::Sys.time()
  [15:45:58.475]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.475]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.475]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.475]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.475]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.475]         {
  [15:45:58.475]             {
  [15:45:58.475]                 base::local({
  [15:45:58.475]                   has_future <- base::requireNamespace("future", 
  [15:45:58.475]                     quietly = TRUE)
  [15:45:58.475]                   version <- if (has_future) 
  [15:45:58.475]                     utils::packageVersion("future")
  [15:45:58.475]                   else NULL
  [15:45:58.475]                   if (!has_future || version < "1.8.0") {
  [15:45:58.475]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.475]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.475]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.475]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.475]                         "release", "version")], collapse = " "), 
  [15:45:58.475]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.475]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.475]                       info)
  [15:45:58.475]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.475]                     if (!has_future) {
  [15:45:58.475]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.475]                         info)
  [15:45:58.475]                     }
  [15:45:58.475]                     else {
  [15:45:58.475]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.475]                         info, version)
  [15:45:58.475]                     }
  [15:45:58.475]                     base::stop(msg)
  [15:45:58.475]                   }
  [15:45:58.475]                 })
  [15:45:58.475]             }
  [15:45:58.475]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.475]         }
  [15:45:58.475]     }
  [15:45:58.475]     if (base::is.na(TRUE)) {
  [15:45:58.475]     }
  [15:45:58.475]     else {
  [15:45:58.475]         if (TRUE) {
  [15:45:58.475]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.475]                 open = "w")
  [15:45:58.475]         }
  [15:45:58.475]         else {
  [15:45:58.475]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.475]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.475]         }
  [15:45:58.475]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.475]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.475]             base::sink(type = "output", split = FALSE)
  [15:45:58.475]             base::close(...future.stdout)
  [15:45:58.475]         }, add = TRUE)
  [15:45:58.475]     }
  [15:45:58.475]     ...future.frame <- base::sys.nframe()
  [15:45:58.475]     ...future.conditions <- base::list()
  [15:45:58.475]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.475]     ...future.result <- base::tryCatch({
  [15:45:58.475]         base::withCallingHandlers({
  [15:45:58.475]             ...future.value <- base::withVisible(base::local({
  [15:45:58.475]                 ...future.sendCondition <- local({
  [15:45:58.475]                   sendCondition <- NULL
  [15:45:58.475]                   function(frame = 1L) {
  [15:45:58.475]                     if (is.function(sendCondition)) 
  [15:45:58.475]                       return(sendCondition)
  [15:45:58.475]                     ns <- getNamespace("parallel")
  [15:45:58.475]                     if (exists("sendData", mode = "function", 
  [15:45:58.475]                       envir = ns)) {
  [15:45:58.475]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.475]                         envir = ns)
  [15:45:58.475]                       envir <- sys.frame(frame)
  [15:45:58.475]                       master <- NULL
  [15:45:58.475]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.475]                         !identical(envir, emptyenv())) {
  [15:45:58.475]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.475]                           inherits = FALSE)) {
  [15:45:58.475]                           master <- get("master", mode = "list", 
  [15:45:58.475]                             envir = envir, inherits = FALSE)
  [15:45:58.475]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.475]                             sendCondition <<- function(cond) {
  [15:45:58.475]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.475]                                 success = TRUE)
  [15:45:58.475]                               parallel_sendData(master, data)
  [15:45:58.475]                             }
  [15:45:58.475]                             return(sendCondition)
  [15:45:58.475]                           }
  [15:45:58.475]                         }
  [15:45:58.475]                         frame <- frame + 1L
  [15:45:58.475]                         envir <- sys.frame(frame)
  [15:45:58.475]                       }
  [15:45:58.475]                     }
  [15:45:58.475]                     sendCondition <<- function(cond) NULL
  [15:45:58.475]                   }
  [15:45:58.475]                 })
  [15:45:58.475]                 withCallingHandlers({
  [15:45:58.475]                   NULL
  [15:45:58.475]                 }, immediateCondition = function(cond) {
  [15:45:58.475]                   sendCondition <- ...future.sendCondition()
  [15:45:58.475]                   sendCondition(cond)
  [15:45:58.475]                   muffleCondition <- function (cond) 
  [15:45:58.475]                   {
  [15:45:58.475]                     inherits <- base::inherits
  [15:45:58.475]                     invokeRestart <- base::invokeRestart
  [15:45:58.475]                     muffled <- FALSE
  [15:45:58.475]                     if (inherits(cond, "message")) {
  [15:45:58.475]                       invokeRestart("muffleMessage")
  [15:45:58.475]                       muffled <- TRUE
  [15:45:58.475]                     }
  [15:45:58.475]                     else if (inherits(cond, "warning")) {
  [15:45:58.475]                       invokeRestart("muffleWarning")
  [15:45:58.475]                       muffled <- TRUE
  [15:45:58.475]                     }
  [15:45:58.475]                     else if (inherits(cond, "condition")) {
  [15:45:58.475]                       computeRestarts <- base::computeRestarts
  [15:45:58.475]                       grepl <- base::grepl
  [15:45:58.475]                       is.null <- base::is.null
  [15:45:58.475]                       restarts <- computeRestarts(cond)
  [15:45:58.475]                       for (restart in restarts) {
  [15:45:58.475]                         name <- restart$name
  [15:45:58.475]                         if (is.null(name)) 
  [15:45:58.475]                           next
  [15:45:58.475]                         if (!grepl("^muffle", name)) 
  [15:45:58.475]                           next
  [15:45:58.475]                         invokeRestart(restart)
  [15:45:58.475]                         muffled <- TRUE
  [15:45:58.475]                         break
  [15:45:58.475]                       }
  [15:45:58.475]                     }
  [15:45:58.475]                     invisible(muffled)
  [15:45:58.475]                   }
  [15:45:58.475]                   muffleCondition(cond)
  [15:45:58.475]                 })
  [15:45:58.475]             }))
  [15:45:58.475]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.475]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.475]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.475]                 version = "1.8")
  [15:45:58.475]         }, condition = base::local({
  [15:45:58.475]             c <- base::c
  [15:45:58.475]             inherits <- base::inherits
  [15:45:58.475]             invokeRestart <- base::invokeRestart
  [15:45:58.475]             length <- base::length
  [15:45:58.475]             list <- base::list
  [15:45:58.475]             seq.int <- base::seq.int
  [15:45:58.475]             signalCondition <- base::signalCondition
  [15:45:58.475]             sys.calls <- base::sys.calls
  [15:45:58.475]             Sys.time <- base::Sys.time
  [15:45:58.475]             `[[` <- base::`[[`
  [15:45:58.475]             `+` <- base::`+`
  [15:45:58.475]             `<<-` <- base::`<<-`
  [15:45:58.475]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.475]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.475]                   3L)]
  [15:45:58.475]             }
  [15:45:58.475]             function(cond) {
  [15:45:58.475]                 if (inherits(cond, "error")) {
  [15:45:58.475]                   sessionInformation <- function() {
  [15:45:58.475]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.475]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.475]                       search = base::search(), system = base::Sys.info())
  [15:45:58.475]                   }
  [15:45:58.475]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.475]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.475]                     cond$call), session = sessionInformation(), 
  [15:45:58.475]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.475]                   signalCondition(cond)
  [15:45:58.475]                 }
  [15:45:58.475]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.475]                 ))) {
  [15:45:58.475]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.475]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.475]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.475]                   if (!signal) {
  [15:45:58.475]                     muffleCondition <- function (cond) 
  [15:45:58.475]                     {
  [15:45:58.475]                       inherits <- base::inherits
  [15:45:58.475]                       invokeRestart <- base::invokeRestart
  [15:45:58.475]                       muffled <- FALSE
  [15:45:58.475]                       if (inherits(cond, "message")) {
  [15:45:58.475]                         invokeRestart("muffleMessage")
  [15:45:58.475]                         muffled <- TRUE
  [15:45:58.475]                       }
  [15:45:58.475]                       else if (inherits(cond, "warning")) {
  [15:45:58.475]                         invokeRestart("muffleWarning")
  [15:45:58.475]                         muffled <- TRUE
  [15:45:58.475]                       }
  [15:45:58.475]                       else if (inherits(cond, "condition")) {
  [15:45:58.475]                         computeRestarts <- base::computeRestarts
  [15:45:58.475]                         grepl <- base::grepl
  [15:45:58.475]                         is.null <- base::is.null
  [15:45:58.475]                         restarts <- computeRestarts(cond)
  [15:45:58.475]                         for (restart in restarts) {
  [15:45:58.475]                           name <- restart$name
  [15:45:58.475]                           if (is.null(name)) 
  [15:45:58.475]                             next
  [15:45:58.475]                           if (!grepl("^muffle", name)) 
  [15:45:58.475]                             next
  [15:45:58.475]                           invokeRestart(restart)
  [15:45:58.475]                           muffled <- TRUE
  [15:45:58.475]                           break
  [15:45:58.475]                         }
  [15:45:58.475]                       }
  [15:45:58.475]                       invisible(muffled)
  [15:45:58.475]                     }
  [15:45:58.475]                     muffleCondition(cond)
  [15:45:58.475]                   }
  [15:45:58.475]                 }
  [15:45:58.475]             }
  [15:45:58.475]         }))
  [15:45:58.475]     }, error = function(ex) {
  [15:45:58.475]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.475]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.475]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.475]     }, finally = {
  [15:45:58.475]         {
  [15:45:58.475]             NULL
  [15:45:58.475]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.475]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.475]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.475]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.475]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.475]                 ...) 
  [15:45:58.475]             {
  [15:45:58.475]                 if (substitute) 
  [15:45:58.475]                   expr <- substitute(expr)
  [15:45:58.475]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.475]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.475]                   globals = globals, persistent = persistent, 
  [15:45:58.475]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.475]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.475]                   label = label, ...)
  [15:45:58.475]                 if (!future$lazy) 
  [15:45:58.475]                   future <- run(future)
  [15:45:58.475]                 invisible(future)
  [15:45:58.475]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.475]         }
  [15:45:58.475]         base::options(...future.oldOptions)
  [15:45:58.475]     })
  [15:45:58.475]     Sys.time
  [15:45:58.475]     if (base::is.na(TRUE)) {
  [15:45:58.475]     }
  [15:45:58.475]     else {
  [15:45:58.475]         base::sink(type = "output", split = FALSE)
  [15:45:58.475]         if (TRUE) {
  [15:45:58.475]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.475]         }
  [15:45:58.475]         else {
  [15:45:58.475]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.475]         }
  [15:45:58.475]         base::close(...future.stdout)
  [15:45:58.475]         ...future.stdout <- NULL
  [15:45:58.475]     }
  [15:45:58.475]     ...future.result$conditions <- ...future.conditions
  [15:45:58.475]     ...future.result
  [15:45:58.475] }
  [15:45:58.481] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.507] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.508] - Validating connection of ClusterFuture
  [15:45:58.509] - received message: FutureResult
  [15:45:58.509] - Received FutureResult
  [15:45:58.509] - Erased future from FutureRegistry
  [15:45:58.510] result() for ClusterFuture ...
  [15:45:58.510] - result already collected: FutureResult
  [15:45:58.510] result() for ClusterFuture ... done
  [15:45:58.511] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.511] result() for ClusterFuture ...
  [15:45:58.512] - result already collected: FutureResult
  [15:45:58.512] result() for ClusterFuture ... done
  [15:45:58.512] result() for ClusterFuture ...
  [15:45:58.513] - result already collected: FutureResult
  [15:45:58.513] result() for ClusterFuture ... done
  [15:45:58.516] ClusterFuture started
  [15:45:58.517] getGlobalsAndPackages() ...
  [15:45:58.517] Searching for globals...
  [15:45:58.519] - globals found: [1] '{'
  [15:45:58.519] Searching for globals ... DONE
  [15:45:58.522] Resolving globals: FALSE
  [15:45:58.523] 
  [15:45:58.523] 
  [15:45:58.524] getGlobalsAndPackages() ... DONE
  [15:45:58.529] Packages needed by the future expression (n = 0): <none>
  [15:45:58.530] Packages needed by future strategies (n = 0): <none>
  [15:45:58.560] {
  [15:45:58.560]     {
  [15:45:58.560]         ...future.startTime <- base::Sys.time()
  [15:45:58.560]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.560]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.560]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.560]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.560]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.560]         {
  [15:45:58.560]             {
  [15:45:58.560]                 base::local({
  [15:45:58.560]                   has_future <- base::requireNamespace("future", 
  [15:45:58.560]                     quietly = TRUE)
  [15:45:58.560]                   version <- if (has_future) 
  [15:45:58.560]                     utils::packageVersion("future")
  [15:45:58.560]                   else NULL
  [15:45:58.560]                   if (!has_future || version < "1.8.0") {
  [15:45:58.560]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.560]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.560]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.560]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.560]                         "release", "version")], collapse = " "), 
  [15:45:58.560]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.560]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.560]                       info)
  [15:45:58.560]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.560]                     if (!has_future) {
  [15:45:58.560]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.560]                         info)
  [15:45:58.560]                     }
  [15:45:58.560]                     else {
  [15:45:58.560]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.560]                         info, version)
  [15:45:58.560]                     }
  [15:45:58.560]                     base::stop(msg)
  [15:45:58.560]                   }
  [15:45:58.560]                 })
  [15:45:58.560]             }
  [15:45:58.560]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.560]         }
  [15:45:58.560]     }
  [15:45:58.560]     if (base::is.na(TRUE)) {
  [15:45:58.560]     }
  [15:45:58.560]     else {
  [15:45:58.560]         if (TRUE) {
  [15:45:58.560]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.560]                 open = "w")
  [15:45:58.560]         }
  [15:45:58.560]         else {
  [15:45:58.560]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.560]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.560]         }
  [15:45:58.560]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.560]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.560]             base::sink(type = "output", split = FALSE)
  [15:45:58.560]             base::close(...future.stdout)
  [15:45:58.560]         }, add = TRUE)
  [15:45:58.560]     }
  [15:45:58.560]     ...future.frame <- base::sys.nframe()
  [15:45:58.560]     ...future.conditions <- base::list()
  [15:45:58.560]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.560]     ...future.result <- base::tryCatch({
  [15:45:58.560]         base::withCallingHandlers({
  [15:45:58.560]             ...future.value <- base::withVisible(base::local({
  [15:45:58.560]                 ...future.sendCondition <- local({
  [15:45:58.560]                   sendCondition <- NULL
  [15:45:58.560]                   function(frame = 1L) {
  [15:45:58.560]                     if (is.function(sendCondition)) 
  [15:45:58.560]                       return(sendCondition)
  [15:45:58.560]                     ns <- getNamespace("parallel")
  [15:45:58.560]                     if (exists("sendData", mode = "function", 
  [15:45:58.560]                       envir = ns)) {
  [15:45:58.560]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.560]                         envir = ns)
  [15:45:58.560]                       envir <- sys.frame(frame)
  [15:45:58.560]                       master <- NULL
  [15:45:58.560]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.560]                         !identical(envir, emptyenv())) {
  [15:45:58.560]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.560]                           inherits = FALSE)) {
  [15:45:58.560]                           master <- get("master", mode = "list", 
  [15:45:58.560]                             envir = envir, inherits = FALSE)
  [15:45:58.560]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.560]                             sendCondition <<- function(cond) {
  [15:45:58.560]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.560]                                 success = TRUE)
  [15:45:58.560]                               parallel_sendData(master, data)
  [15:45:58.560]                             }
  [15:45:58.560]                             return(sendCondition)
  [15:45:58.560]                           }
  [15:45:58.560]                         }
  [15:45:58.560]                         frame <- frame + 1L
  [15:45:58.560]                         envir <- sys.frame(frame)
  [15:45:58.560]                       }
  [15:45:58.560]                     }
  [15:45:58.560]                     sendCondition <<- function(cond) NULL
  [15:45:58.560]                   }
  [15:45:58.560]                 })
  [15:45:58.560]                 withCallingHandlers({
  [15:45:58.560]                   {
  [15:45:58.560]                     4
  [15:45:58.560]                   }
  [15:45:58.560]                 }, immediateCondition = function(cond) {
  [15:45:58.560]                   sendCondition <- ...future.sendCondition()
  [15:45:58.560]                   sendCondition(cond)
  [15:45:58.560]                   muffleCondition <- function (cond) 
  [15:45:58.560]                   {
  [15:45:58.560]                     inherits <- base::inherits
  [15:45:58.560]                     invokeRestart <- base::invokeRestart
  [15:45:58.560]                     muffled <- FALSE
  [15:45:58.560]                     if (inherits(cond, "message")) {
  [15:45:58.560]                       invokeRestart("muffleMessage")
  [15:45:58.560]                       muffled <- TRUE
  [15:45:58.560]                     }
  [15:45:58.560]                     else if (inherits(cond, "warning")) {
  [15:45:58.560]                       invokeRestart("muffleWarning")
  [15:45:58.560]                       muffled <- TRUE
  [15:45:58.560]                     }
  [15:45:58.560]                     else if (inherits(cond, "condition")) {
  [15:45:58.560]                       computeRestarts <- base::computeRestarts
  [15:45:58.560]                       grepl <- base::grepl
  [15:45:58.560]                       is.null <- base::is.null
  [15:45:58.560]                       restarts <- computeRestarts(cond)
  [15:45:58.560]                       for (restart in restarts) {
  [15:45:58.560]                         name <- restart$name
  [15:45:58.560]                         if (is.null(name)) 
  [15:45:58.560]                           next
  [15:45:58.560]                         if (!grepl("^muffle", name)) 
  [15:45:58.560]                           next
  [15:45:58.560]                         invokeRestart(restart)
  [15:45:58.560]                         muffled <- TRUE
  [15:45:58.560]                         break
  [15:45:58.560]                       }
  [15:45:58.560]                     }
  [15:45:58.560]                     invisible(muffled)
  [15:45:58.560]                   }
  [15:45:58.560]                   muffleCondition(cond)
  [15:45:58.560]                 })
  [15:45:58.560]             }))
  [15:45:58.560]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.560]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.560]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.560]                 version = "1.8")
  [15:45:58.560]         }, condition = base::local({
  [15:45:58.560]             c <- base::c
  [15:45:58.560]             inherits <- base::inherits
  [15:45:58.560]             invokeRestart <- base::invokeRestart
  [15:45:58.560]             length <- base::length
  [15:45:58.560]             list <- base::list
  [15:45:58.560]             seq.int <- base::seq.int
  [15:45:58.560]             signalCondition <- base::signalCondition
  [15:45:58.560]             sys.calls <- base::sys.calls
  [15:45:58.560]             Sys.time <- base::Sys.time
  [15:45:58.560]             `[[` <- base::`[[`
  [15:45:58.560]             `+` <- base::`+`
  [15:45:58.560]             `<<-` <- base::`<<-`
  [15:45:58.560]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.560]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.560]                   3L)]
  [15:45:58.560]             }
  [15:45:58.560]             function(cond) {
  [15:45:58.560]                 if (inherits(cond, "error")) {
  [15:45:58.560]                   sessionInformation <- function() {
  [15:45:58.560]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.560]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.560]                       search = base::search(), system = base::Sys.info())
  [15:45:58.560]                   }
  [15:45:58.560]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.560]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.560]                     cond$call), session = sessionInformation(), 
  [15:45:58.560]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.560]                   signalCondition(cond)
  [15:45:58.560]                 }
  [15:45:58.560]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.560]                 ))) {
  [15:45:58.560]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.560]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.560]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.560]                   if (!signal) {
  [15:45:58.560]                     muffleCondition <- function (cond) 
  [15:45:58.560]                     {
  [15:45:58.560]                       inherits <- base::inherits
  [15:45:58.560]                       invokeRestart <- base::invokeRestart
  [15:45:58.560]                       muffled <- FALSE
  [15:45:58.560]                       if (inherits(cond, "message")) {
  [15:45:58.560]                         invokeRestart("muffleMessage")
  [15:45:58.560]                         muffled <- TRUE
  [15:45:58.560]                       }
  [15:45:58.560]                       else if (inherits(cond, "warning")) {
  [15:45:58.560]                         invokeRestart("muffleWarning")
  [15:45:58.560]                         muffled <- TRUE
  [15:45:58.560]                       }
  [15:45:58.560]                       else if (inherits(cond, "condition")) {
  [15:45:58.560]                         computeRestarts <- base::computeRestarts
  [15:45:58.560]                         grepl <- base::grepl
  [15:45:58.560]                         is.null <- base::is.null
  [15:45:58.560]                         restarts <- computeRestarts(cond)
  [15:45:58.560]                         for (restart in restarts) {
  [15:45:58.560]                           name <- restart$name
  [15:45:58.560]                           if (is.null(name)) 
  [15:45:58.560]                             next
  [15:45:58.560]                           if (!grepl("^muffle", name)) 
  [15:45:58.560]                             next
  [15:45:58.560]                           invokeRestart(restart)
  [15:45:58.560]                           muffled <- TRUE
  [15:45:58.560]                           break
  [15:45:58.560]                         }
  [15:45:58.560]                       }
  [15:45:58.560]                       invisible(muffled)
  [15:45:58.560]                     }
  [15:45:58.560]                     muffleCondition(cond)
  [15:45:58.560]                   }
  [15:45:58.560]                 }
  [15:45:58.560]             }
  [15:45:58.560]         }))
  [15:45:58.560]     }, error = function(ex) {
  [15:45:58.560]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.560]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.560]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.560]     }, finally = {
  [15:45:58.560]         {
  [15:45:58.560]             NULL
  [15:45:58.560]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.560]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.560]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.560]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.560]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.560]                 ...) 
  [15:45:58.560]             {
  [15:45:58.560]                 if (substitute) 
  [15:45:58.560]                   expr <- substitute(expr)
  [15:45:58.560]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.560]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.560]                   globals = globals, persistent = persistent, 
  [15:45:58.560]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.560]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.560]                   label = label, ...)
  [15:45:58.560]                 if (!future$lazy) 
  [15:45:58.560]                   future <- run(future)
  [15:45:58.560]                 invisible(future)
  [15:45:58.560]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.560]         }
  [15:45:58.560]         base::options(...future.oldOptions)
  [15:45:58.560]     })
  [15:45:58.560]     Sys.time
  [15:45:58.560]     if (base::is.na(TRUE)) {
  [15:45:58.560]     }
  [15:45:58.560]     else {
  [15:45:58.560]         base::sink(type = "output", split = FALSE)
  [15:45:58.560]         if (TRUE) {
  [15:45:58.560]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.560]         }
  [15:45:58.560]         else {
  [15:45:58.560]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.560]         }
  [15:45:58.560]         base::close(...future.stdout)
  [15:45:58.560]         ...future.stdout <- NULL
  [15:45:58.560]     }
  [15:45:58.560]     ...future.result$conditions <- ...future.conditions
  [15:45:58.560]     ...future.result
  [15:45:58.560] }
  [15:45:58.571] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.583] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.583] - Validating connection of ClusterFuture
  [15:45:58.584] - received message: FutureResult
  [15:45:58.584] - Received FutureResult
  [15:45:58.585] - Erased future from FutureRegistry
  [15:45:58.585] result() for ClusterFuture ...
  [15:45:58.586] - result already collected: FutureResult
  [15:45:58.586] result() for ClusterFuture ... done
  [15:45:58.587] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.587] result() for ClusterFuture ...
  [15:45:58.587] - result already collected: FutureResult
  [15:45:58.588] result() for ClusterFuture ... done
  [15:45:58.588] result() for ClusterFuture ...
  [15:45:58.589] - result already collected: FutureResult
  [15:45:58.589] result() for ClusterFuture ... done
  [15:45:58.608] ClusterFuture started
  <environment: 0x55ca2ad33710> 
  <environment: 0x55ca2adc0690> 
  [15:45:58.655] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.656] - Validating connection of ClusterFuture
  [15:45:58.656] - received message: FutureResult
  [15:45:58.657] - Received FutureResult
  [15:45:58.657] - Erased future from FutureRegistry
  [15:45:58.658] result() for ClusterFuture ...
  [15:45:58.658] - result already collected: FutureResult
  [15:45:58.658] result() for ClusterFuture ... done
  [15:45:58.659] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:58.662] resolve() on environment ...
  [15:45:58.663]  recursive: 0
  [15:45:58.665]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:58.665] signalConditionsASAP(numeric, pos=1) ...
  [15:45:58.665] - nx: 4
  [15:45:58.666] - relay: TRUE
  [15:45:58.666] - stdout: TRUE
  [15:45:58.666] - signal: TRUE
  [15:45:58.667] - resignal: FALSE
  [15:45:58.667] - force: TRUE
  [15:45:58.667] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.668] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.668]  - until=2
  [15:45:58.668]  - relaying element #2
  [15:45:58.669] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.669] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.669] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:58.670]  length: 3 (resolved future 1)
  [15:45:58.670] Future #2
  [15:45:58.670] result() for ClusterFuture ...
  [15:45:58.671] - result already collected: FutureResult
  [15:45:58.671] result() for ClusterFuture ... done
  [15:45:58.671] result() for ClusterFuture ...
  [15:45:58.672] - result already collected: FutureResult
  [15:45:58.672] result() for ClusterFuture ... done
  [15:45:58.672] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:58.673] - nx: 4
  [15:45:58.673] - relay: TRUE
  [15:45:58.673] - stdout: TRUE
  [15:45:58.674] - signal: TRUE
  [15:45:58.674] - resignal: FALSE
  [15:45:58.674] - force: TRUE
  [15:45:58.674] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.675] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.675]  - until=2
  [15:45:58.675]  - relaying element #2
  [15:45:58.676] result() for ClusterFuture ...
  [15:45:58.676] - result already collected: FutureResult
  [15:45:58.676] result() for ClusterFuture ... done
  [15:45:58.677] result() for ClusterFuture ...
  [15:45:58.677] - result already collected: FutureResult
  [15:45:58.678] result() for ClusterFuture ... done
  [15:45:58.678] result() for ClusterFuture ...
  [15:45:58.688] - result already collected: FutureResult
  [15:45:58.688] result() for ClusterFuture ... done
  [15:45:58.689] result() for ClusterFuture ...
  [15:45:58.689] - result already collected: FutureResult
  [15:45:58.689] result() for ClusterFuture ... done
  [15:45:58.690] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.690] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.691] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:58.691]  length: 2 (resolved future 2)
  [15:45:58.691] Future #3
  [15:45:58.692] result() for ClusterFuture ...
  [15:45:58.692] - result already collected: FutureResult
  [15:45:58.692] result() for ClusterFuture ... done
  [15:45:58.693] result() for ClusterFuture ...
  [15:45:58.693] - result already collected: FutureResult
  [15:45:58.693] result() for ClusterFuture ... done
  [15:45:58.694] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:58.694] - nx: 4
  [15:45:58.694] - relay: TRUE
  [15:45:58.695] - stdout: TRUE
  [15:45:58.695] - signal: TRUE
  [15:45:58.695] - resignal: FALSE
  [15:45:58.696] - force: TRUE
  [15:45:58.696] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.696] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.697]  - until=3
  [15:45:58.697]  - relaying element #3
  [15:45:58.697] result() for ClusterFuture ...
  [15:45:58.698] - result already collected: FutureResult
  [15:45:58.719] result() for ClusterFuture ... done
  [15:45:58.719] result() for ClusterFuture ...
  [15:45:58.720] - result already collected: FutureResult
  [15:45:58.720] result() for ClusterFuture ... done
  [15:45:58.720] result() for ClusterFuture ...
  [15:45:58.721] - result already collected: FutureResult
  [15:45:58.721] result() for ClusterFuture ... done
  [15:45:58.722] result() for ClusterFuture ...
  [15:45:58.722] - result already collected: FutureResult
  [15:45:58.722] result() for ClusterFuture ... done
  [15:45:58.723] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.723] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.723] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:58.724]  length: 1 (resolved future 3)
  [15:45:58.724] Future #4
  [15:45:58.724] result() for ClusterFuture ...
  [15:45:58.725] - result already collected: FutureResult
  [15:45:58.725] result() for ClusterFuture ... done
  [15:45:58.726] result() for ClusterFuture ...
  [15:45:58.726] - result already collected: FutureResult
  [15:45:58.726] result() for ClusterFuture ... done
  [15:45:58.727] signalConditionsASAP(ClusterFuture, pos=4) ...
  [15:45:58.727] - nx: 4
  [15:45:58.727] - relay: TRUE
  [15:45:58.728] - stdout: TRUE
  [15:45:58.728] - signal: TRUE
  [15:45:58.728] - resignal: FALSE
  [15:45:58.729] - force: TRUE
  [15:45:58.729] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.729] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.730]  - until=4
  [15:45:58.730]  - relaying element #4
  [15:45:58.730] result() for ClusterFuture ...
  [15:45:58.731] - result already collected: FutureResult
  [15:45:58.731] result() for ClusterFuture ... done
  [15:45:58.731] result() for ClusterFuture ...
  [15:45:58.732] - result already collected: FutureResult
  [15:45:58.732] result() for ClusterFuture ... done
  [15:45:58.733] result() for ClusterFuture ...
  [15:45:58.733] - result already collected: FutureResult
  [15:45:58.733] result() for ClusterFuture ... done
  [15:45:58.734] result() for ClusterFuture ...
  [15:45:58.734] - result already collected: FutureResult
  [15:45:58.735] result() for ClusterFuture ... done
  [15:45:58.736] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.736] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.736] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [15:45:58.737]  length: 0 (resolved future 4)
  [15:45:58.737] Relaying remaining futures
  [15:45:58.737] signalConditionsASAP(NULL, pos=0) ...
  [15:45:58.738] - nx: 4
  [15:45:58.738] - relay: TRUE
  [15:45:58.738] - stdout: TRUE
  [15:45:58.739] - signal: TRUE
  [15:45:58.739] - resignal: FALSE
  [15:45:58.739] - force: TRUE
  [15:45:58.740] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.740] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:58.741] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.741] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.741] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:58.742] resolve() on environment ... DONE
  [15:45:58.742] result() for ClusterFuture ...
  [15:45:58.742] - result already collected: FutureResult
  [15:45:58.743] result() for ClusterFuture ... done
  [15:45:58.743] result() for ClusterFuture ...
  [15:45:58.743] - result already collected: FutureResult
  [15:45:58.744] result() for ClusterFuture ... done
  [15:45:58.744] result() for ClusterFuture ...
  [15:45:58.745] - result already collected: FutureResult
  [15:45:58.745] result() for ClusterFuture ... done
  [15:45:58.745] result() for ClusterFuture ...
  [15:45:58.746] - result already collected: FutureResult
  [15:45:58.746] result() for ClusterFuture ... done
  [15:45:58.746] result() for ClusterFuture ...
  [15:45:58.747] - result already collected: FutureResult
  [15:45:58.747] result() for ClusterFuture ... done
  [15:45:58.747] result() for ClusterFuture ...
  [15:45:58.748] - result already collected: FutureResult
  [15:45:58.748] result() for ClusterFuture ... done
  <environment: 0x55ca295d9d88> 
  Dimensions: c(2, 3)
  [15:45:58.749] getGlobalsAndPackages() ...
  [15:45:58.750] Searching for globals...
  [15:45:58.751] 
  [15:45:58.751] Searching for globals ... DONE
  [15:45:58.751] - globals: [0] <none>
  [15:45:58.752] getGlobalsAndPackages() ... DONE
  [15:45:58.761] Packages needed by the future expression (n = 0): <none>
  [15:45:58.761] Packages needed by future strategies (n = 0): <none>
  [15:45:58.768] {
  [15:45:58.768]     {
  [15:45:58.768]         ...future.startTime <- base::Sys.time()
  [15:45:58.768]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.768]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.768]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.768]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.768]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.768]         {
  [15:45:58.768]             {
  [15:45:58.768]                 base::local({
  [15:45:58.768]                   has_future <- base::requireNamespace("future", 
  [15:45:58.768]                     quietly = TRUE)
  [15:45:58.768]                   version <- if (has_future) 
  [15:45:58.768]                     utils::packageVersion("future")
  [15:45:58.768]                   else NULL
  [15:45:58.768]                   if (!has_future || version < "1.8.0") {
  [15:45:58.768]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.768]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.768]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.768]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.768]                         "release", "version")], collapse = " "), 
  [15:45:58.768]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.768]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.768]                       info)
  [15:45:58.768]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.768]                     if (!has_future) {
  [15:45:58.768]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.768]                         info)
  [15:45:58.768]                     }
  [15:45:58.768]                     else {
  [15:45:58.768]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.768]                         info, version)
  [15:45:58.768]                     }
  [15:45:58.768]                     base::stop(msg)
  [15:45:58.768]                   }
  [15:45:58.768]                 })
  [15:45:58.768]             }
  [15:45:58.768]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.768]         }
  [15:45:58.768]     }
  [15:45:58.768]     if (base::is.na(TRUE)) {
  [15:45:58.768]     }
  [15:45:58.768]     else {
  [15:45:58.768]         if (TRUE) {
  [15:45:58.768]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.768]                 open = "w")
  [15:45:58.768]         }
  [15:45:58.768]         else {
  [15:45:58.768]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.768]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.768]         }
  [15:45:58.768]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.768]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.768]             base::sink(type = "output", split = FALSE)
  [15:45:58.768]             base::close(...future.stdout)
  [15:45:58.768]         }, add = TRUE)
  [15:45:58.768]     }
  [15:45:58.768]     ...future.frame <- base::sys.nframe()
  [15:45:58.768]     ...future.conditions <- base::list()
  [15:45:58.768]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.768]     ...future.result <- base::tryCatch({
  [15:45:58.768]         base::withCallingHandlers({
  [15:45:58.768]             ...future.value <- base::withVisible(base::local({
  [15:45:58.768]                 ...future.sendCondition <- local({
  [15:45:58.768]                   sendCondition <- NULL
  [15:45:58.768]                   function(frame = 1L) {
  [15:45:58.768]                     if (is.function(sendCondition)) 
  [15:45:58.768]                       return(sendCondition)
  [15:45:58.768]                     ns <- getNamespace("parallel")
  [15:45:58.768]                     if (exists("sendData", mode = "function", 
  [15:45:58.768]                       envir = ns)) {
  [15:45:58.768]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.768]                         envir = ns)
  [15:45:58.768]                       envir <- sys.frame(frame)
  [15:45:58.768]                       master <- NULL
  [15:45:58.768]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.768]                         !identical(envir, emptyenv())) {
  [15:45:58.768]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.768]                           inherits = FALSE)) {
  [15:45:58.768]                           master <- get("master", mode = "list", 
  [15:45:58.768]                             envir = envir, inherits = FALSE)
  [15:45:58.768]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.768]                             sendCondition <<- function(cond) {
  [15:45:58.768]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.768]                                 success = TRUE)
  [15:45:58.768]                               parallel_sendData(master, data)
  [15:45:58.768]                             }
  [15:45:58.768]                             return(sendCondition)
  [15:45:58.768]                           }
  [15:45:58.768]                         }
  [15:45:58.768]                         frame <- frame + 1L
  [15:45:58.768]                         envir <- sys.frame(frame)
  [15:45:58.768]                       }
  [15:45:58.768]                     }
  [15:45:58.768]                     sendCondition <<- function(cond) NULL
  [15:45:58.768]                   }
  [15:45:58.768]                 })
  [15:45:58.768]                 withCallingHandlers({
  [15:45:58.768]                   2
  [15:45:58.768]                 }, immediateCondition = function(cond) {
  [15:45:58.768]                   sendCondition <- ...future.sendCondition()
  [15:45:58.768]                   sendCondition(cond)
  [15:45:58.768]                   muffleCondition <- function (cond) 
  [15:45:58.768]                   {
  [15:45:58.768]                     inherits <- base::inherits
  [15:45:58.768]                     invokeRestart <- base::invokeRestart
  [15:45:58.768]                     muffled <- FALSE
  [15:45:58.768]                     if (inherits(cond, "message")) {
  [15:45:58.768]                       invokeRestart("muffleMessage")
  [15:45:58.768]                       muffled <- TRUE
  [15:45:58.768]                     }
  [15:45:58.768]                     else if (inherits(cond, "warning")) {
  [15:45:58.768]                       invokeRestart("muffleWarning")
  [15:45:58.768]                       muffled <- TRUE
  [15:45:58.768]                     }
  [15:45:58.768]                     else if (inherits(cond, "condition")) {
  [15:45:58.768]                       computeRestarts <- base::computeRestarts
  [15:45:58.768]                       grepl <- base::grepl
  [15:45:58.768]                       is.null <- base::is.null
  [15:45:58.768]                       restarts <- computeRestarts(cond)
  [15:45:58.768]                       for (restart in restarts) {
  [15:45:58.768]                         name <- restart$name
  [15:45:58.768]                         if (is.null(name)) 
  [15:45:58.768]                           next
  [15:45:58.768]                         if (!grepl("^muffle", name)) 
  [15:45:58.768]                           next
  [15:45:58.768]                         invokeRestart(restart)
  [15:45:58.768]                         muffled <- TRUE
  [15:45:58.768]                         break
  [15:45:58.768]                       }
  [15:45:58.768]                     }
  [15:45:58.768]                     invisible(muffled)
  [15:45:58.768]                   }
  [15:45:58.768]                   muffleCondition(cond)
  [15:45:58.768]                 })
  [15:45:58.768]             }))
  [15:45:58.768]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.768]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.768]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.768]                 version = "1.8")
  [15:45:58.768]         }, condition = base::local({
  [15:45:58.768]             c <- base::c
  [15:45:58.768]             inherits <- base::inherits
  [15:45:58.768]             invokeRestart <- base::invokeRestart
  [15:45:58.768]             length <- base::length
  [15:45:58.768]             list <- base::list
  [15:45:58.768]             seq.int <- base::seq.int
  [15:45:58.768]             signalCondition <- base::signalCondition
  [15:45:58.768]             sys.calls <- base::sys.calls
  [15:45:58.768]             Sys.time <- base::Sys.time
  [15:45:58.768]             `[[` <- base::`[[`
  [15:45:58.768]             `+` <- base::`+`
  [15:45:58.768]             `<<-` <- base::`<<-`
  [15:45:58.768]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.768]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.768]                   3L)]
  [15:45:58.768]             }
  [15:45:58.768]             function(cond) {
  [15:45:58.768]                 if (inherits(cond, "error")) {
  [15:45:58.768]                   sessionInformation <- function() {
  [15:45:58.768]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.768]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.768]                       search = base::search(), system = base::Sys.info())
  [15:45:58.768]                   }
  [15:45:58.768]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.768]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.768]                     cond$call), session = sessionInformation(), 
  [15:45:58.768]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.768]                   signalCondition(cond)
  [15:45:58.768]                 }
  [15:45:58.768]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.768]                 ))) {
  [15:45:58.768]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.768]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.768]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.768]                   if (!signal) {
  [15:45:58.768]                     muffleCondition <- function (cond) 
  [15:45:58.768]                     {
  [15:45:58.768]                       inherits <- base::inherits
  [15:45:58.768]                       invokeRestart <- base::invokeRestart
  [15:45:58.768]                       muffled <- FALSE
  [15:45:58.768]                       if (inherits(cond, "message")) {
  [15:45:58.768]                         invokeRestart("muffleMessage")
  [15:45:58.768]                         muffled <- TRUE
  [15:45:58.768]                       }
  [15:45:58.768]                       else if (inherits(cond, "warning")) {
  [15:45:58.768]                         invokeRestart("muffleWarning")
  [15:45:58.768]                         muffled <- TRUE
  [15:45:58.768]                       }
  [15:45:58.768]                       else if (inherits(cond, "condition")) {
  [15:45:58.768]                         computeRestarts <- base::computeRestarts
  [15:45:58.768]                         grepl <- base::grepl
  [15:45:58.768]                         is.null <- base::is.null
  [15:45:58.768]                         restarts <- computeRestarts(cond)
  [15:45:58.768]                         for (restart in restarts) {
  [15:45:58.768]                           name <- restart$name
  [15:45:58.768]                           if (is.null(name)) 
  [15:45:58.768]                             next
  [15:45:58.768]                           if (!grepl("^muffle", name)) 
  [15:45:58.768]                             next
  [15:45:58.768]                           invokeRestart(restart)
  [15:45:58.768]                           muffled <- TRUE
  [15:45:58.768]                           break
  [15:45:58.768]                         }
  [15:45:58.768]                       }
  [15:45:58.768]                       invisible(muffled)
  [15:45:58.768]                     }
  [15:45:58.768]                     muffleCondition(cond)
  [15:45:58.768]                   }
  [15:45:58.768]                 }
  [15:45:58.768]             }
  [15:45:58.768]         }))
  [15:45:58.768]     }, error = function(ex) {
  [15:45:58.768]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.768]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.768]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.768]     }, finally = {
  [15:45:58.768]         {
  [15:45:58.768]             NULL
  [15:45:58.768]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.768]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.768]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.768]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.768]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.768]                 ...) 
  [15:45:58.768]             {
  [15:45:58.768]                 if (substitute) 
  [15:45:58.768]                   expr <- substitute(expr)
  [15:45:58.768]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.768]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.768]                   globals = globals, persistent = persistent, 
  [15:45:58.768]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.768]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.768]                   label = label, ...)
  [15:45:58.768]                 if (!future$lazy) 
  [15:45:58.768]                   future <- run(future)
  [15:45:58.768]                 invisible(future)
  [15:45:58.768]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.768]         }
  [15:45:58.768]         base::options(...future.oldOptions)
  [15:45:58.768]     })
  [15:45:58.768]     Sys.time
  [15:45:58.768]     if (base::is.na(TRUE)) {
  [15:45:58.768]     }
  [15:45:58.768]     else {
  [15:45:58.768]         base::sink(type = "output", split = FALSE)
  [15:45:58.768]         if (TRUE) {
  [15:45:58.768]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.768]         }
  [15:45:58.768]         else {
  [15:45:58.768]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.768]         }
  [15:45:58.768]         base::close(...future.stdout)
  [15:45:58.768]         ...future.stdout <- NULL
  [15:45:58.768]     }
  [15:45:58.768]     ...future.result$conditions <- ...future.conditions
  [15:45:58.768]     ...future.result
  [15:45:58.768] }
  [15:45:58.777] ClusterFuture started
  [15:45:58.777] getGlobalsAndPackages() ...
  [15:45:58.778] Searching for globals...
  [15:45:58.779] 
  [15:45:58.779] Searching for globals ... DONE
  [15:45:58.780] - globals: [0] <none>
  [15:45:58.780] getGlobalsAndPackages() ... DONE
  [15:45:58.786] Packages needed by the future expression (n = 0): <none>
  [15:45:58.786] Packages needed by future strategies (n = 0): <none>
  [15:45:58.793] {
  [15:45:58.793]     {
  [15:45:58.793]         ...future.startTime <- base::Sys.time()
  [15:45:58.793]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.793]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.793]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.793]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.793]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.793]         {
  [15:45:58.793]             {
  [15:45:58.793]                 base::local({
  [15:45:58.793]                   has_future <- base::requireNamespace("future", 
  [15:45:58.793]                     quietly = TRUE)
  [15:45:58.793]                   version <- if (has_future) 
  [15:45:58.793]                     utils::packageVersion("future")
  [15:45:58.793]                   else NULL
  [15:45:58.793]                   if (!has_future || version < "1.8.0") {
  [15:45:58.793]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.793]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.793]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.793]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.793]                         "release", "version")], collapse = " "), 
  [15:45:58.793]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.793]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.793]                       info)
  [15:45:58.793]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.793]                     if (!has_future) {
  [15:45:58.793]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.793]                         info)
  [15:45:58.793]                     }
  [15:45:58.793]                     else {
  [15:45:58.793]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.793]                         info, version)
  [15:45:58.793]                     }
  [15:45:58.793]                     base::stop(msg)
  [15:45:58.793]                   }
  [15:45:58.793]                 })
  [15:45:58.793]             }
  [15:45:58.793]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.793]         }
  [15:45:58.793]     }
  [15:45:58.793]     if (base::is.na(TRUE)) {
  [15:45:58.793]     }
  [15:45:58.793]     else {
  [15:45:58.793]         if (TRUE) {
  [15:45:58.793]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.793]                 open = "w")
  [15:45:58.793]         }
  [15:45:58.793]         else {
  [15:45:58.793]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.793]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.793]         }
  [15:45:58.793]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.793]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.793]             base::sink(type = "output", split = FALSE)
  [15:45:58.793]             base::close(...future.stdout)
  [15:45:58.793]         }, add = TRUE)
  [15:45:58.793]     }
  [15:45:58.793]     ...future.frame <- base::sys.nframe()
  [15:45:58.793]     ...future.conditions <- base::list()
  [15:45:58.793]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.793]     ...future.result <- base::tryCatch({
  [15:45:58.793]         base::withCallingHandlers({
  [15:45:58.793]             ...future.value <- base::withVisible(base::local({
  [15:45:58.793]                 ...future.sendCondition <- local({
  [15:45:58.793]                   sendCondition <- NULL
  [15:45:58.793]                   function(frame = 1L) {
  [15:45:58.793]                     if (is.function(sendCondition)) 
  [15:45:58.793]                       return(sendCondition)
  [15:45:58.793]                     ns <- getNamespace("parallel")
  [15:45:58.793]                     if (exists("sendData", mode = "function", 
  [15:45:58.793]                       envir = ns)) {
  [15:45:58.793]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.793]                         envir = ns)
  [15:45:58.793]                       envir <- sys.frame(frame)
  [15:45:58.793]                       master <- NULL
  [15:45:58.793]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.793]                         !identical(envir, emptyenv())) {
  [15:45:58.793]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.793]                           inherits = FALSE)) {
  [15:45:58.793]                           master <- get("master", mode = "list", 
  [15:45:58.793]                             envir = envir, inherits = FALSE)
  [15:45:58.793]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.793]                             sendCondition <<- function(cond) {
  [15:45:58.793]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.793]                                 success = TRUE)
  [15:45:58.793]                               parallel_sendData(master, data)
  [15:45:58.793]                             }
  [15:45:58.793]                             return(sendCondition)
  [15:45:58.793]                           }
  [15:45:58.793]                         }
  [15:45:58.793]                         frame <- frame + 1L
  [15:45:58.793]                         envir <- sys.frame(frame)
  [15:45:58.793]                       }
  [15:45:58.793]                     }
  [15:45:58.793]                     sendCondition <<- function(cond) NULL
  [15:45:58.793]                   }
  [15:45:58.793]                 })
  [15:45:58.793]                 withCallingHandlers({
  [15:45:58.793]                   NULL
  [15:45:58.793]                 }, immediateCondition = function(cond) {
  [15:45:58.793]                   sendCondition <- ...future.sendCondition()
  [15:45:58.793]                   sendCondition(cond)
  [15:45:58.793]                   muffleCondition <- function (cond) 
  [15:45:58.793]                   {
  [15:45:58.793]                     inherits <- base::inherits
  [15:45:58.793]                     invokeRestart <- base::invokeRestart
  [15:45:58.793]                     muffled <- FALSE
  [15:45:58.793]                     if (inherits(cond, "message")) {
  [15:45:58.793]                       invokeRestart("muffleMessage")
  [15:45:58.793]                       muffled <- TRUE
  [15:45:58.793]                     }
  [15:45:58.793]                     else if (inherits(cond, "warning")) {
  [15:45:58.793]                       invokeRestart("muffleWarning")
  [15:45:58.793]                       muffled <- TRUE
  [15:45:58.793]                     }
  [15:45:58.793]                     else if (inherits(cond, "condition")) {
  [15:45:58.793]                       computeRestarts <- base::computeRestarts
  [15:45:58.793]                       grepl <- base::grepl
  [15:45:58.793]                       is.null <- base::is.null
  [15:45:58.793]                       restarts <- computeRestarts(cond)
  [15:45:58.793]                       for (restart in restarts) {
  [15:45:58.793]                         name <- restart$name
  [15:45:58.793]                         if (is.null(name)) 
  [15:45:58.793]                           next
  [15:45:58.793]                         if (!grepl("^muffle", name)) 
  [15:45:58.793]                           next
  [15:45:58.793]                         invokeRestart(restart)
  [15:45:58.793]                         muffled <- TRUE
  [15:45:58.793]                         break
  [15:45:58.793]                       }
  [15:45:58.793]                     }
  [15:45:58.793]                     invisible(muffled)
  [15:45:58.793]                   }
  [15:45:58.793]                   muffleCondition(cond)
  [15:45:58.793]                 })
  [15:45:58.793]             }))
  [15:45:58.793]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.793]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.793]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.793]                 version = "1.8")
  [15:45:58.793]         }, condition = base::local({
  [15:45:58.793]             c <- base::c
  [15:45:58.793]             inherits <- base::inherits
  [15:45:58.793]             invokeRestart <- base::invokeRestart
  [15:45:58.793]             length <- base::length
  [15:45:58.793]             list <- base::list
  [15:45:58.793]             seq.int <- base::seq.int
  [15:45:58.793]             signalCondition <- base::signalCondition
  [15:45:58.793]             sys.calls <- base::sys.calls
  [15:45:58.793]             Sys.time <- base::Sys.time
  [15:45:58.793]             `[[` <- base::`[[`
  [15:45:58.793]             `+` <- base::`+`
  [15:45:58.793]             `<<-` <- base::`<<-`
  [15:45:58.793]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.793]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.793]                   3L)]
  [15:45:58.793]             }
  [15:45:58.793]             function(cond) {
  [15:45:58.793]                 if (inherits(cond, "error")) {
  [15:45:58.793]                   sessionInformation <- function() {
  [15:45:58.793]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.793]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.793]                       search = base::search(), system = base::Sys.info())
  [15:45:58.793]                   }
  [15:45:58.793]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.793]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.793]                     cond$call), session = sessionInformation(), 
  [15:45:58.793]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.793]                   signalCondition(cond)
  [15:45:58.793]                 }
  [15:45:58.793]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.793]                 ))) {
  [15:45:58.793]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.793]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.793]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.793]                   if (!signal) {
  [15:45:58.793]                     muffleCondition <- function (cond) 
  [15:45:58.793]                     {
  [15:45:58.793]                       inherits <- base::inherits
  [15:45:58.793]                       invokeRestart <- base::invokeRestart
  [15:45:58.793]                       muffled <- FALSE
  [15:45:58.793]                       if (inherits(cond, "message")) {
  [15:45:58.793]                         invokeRestart("muffleMessage")
  [15:45:58.793]                         muffled <- TRUE
  [15:45:58.793]                       }
  [15:45:58.793]                       else if (inherits(cond, "warning")) {
  [15:45:58.793]                         invokeRestart("muffleWarning")
  [15:45:58.793]                         muffled <- TRUE
  [15:45:58.793]                       }
  [15:45:58.793]                       else if (inherits(cond, "condition")) {
  [15:45:58.793]                         computeRestarts <- base::computeRestarts
  [15:45:58.793]                         grepl <- base::grepl
  [15:45:58.793]                         is.null <- base::is.null
  [15:45:58.793]                         restarts <- computeRestarts(cond)
  [15:45:58.793]                         for (restart in restarts) {
  [15:45:58.793]                           name <- restart$name
  [15:45:58.793]                           if (is.null(name)) 
  [15:45:58.793]                             next
  [15:45:58.793]                           if (!grepl("^muffle", name)) 
  [15:45:58.793]                             next
  [15:45:58.793]                           invokeRestart(restart)
  [15:45:58.793]                           muffled <- TRUE
  [15:45:58.793]                           break
  [15:45:58.793]                         }
  [15:45:58.793]                       }
  [15:45:58.793]                       invisible(muffled)
  [15:45:58.793]                     }
  [15:45:58.793]                     muffleCondition(cond)
  [15:45:58.793]                   }
  [15:45:58.793]                 }
  [15:45:58.793]             }
  [15:45:58.793]         }))
  [15:45:58.793]     }, error = function(ex) {
  [15:45:58.793]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.793]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.793]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.793]     }, finally = {
  [15:45:58.793]         {
  [15:45:58.793]             NULL
  [15:45:58.793]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.793]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.793]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.793]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.793]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.793]                 ...) 
  [15:45:58.793]             {
  [15:45:58.793]                 if (substitute) 
  [15:45:58.793]                   expr <- substitute(expr)
  [15:45:58.793]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.793]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.793]                   globals = globals, persistent = persistent, 
  [15:45:58.793]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.793]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.793]                   label = label, ...)
  [15:45:58.793]                 if (!future$lazy) 
  [15:45:58.793]                   future <- run(future)
  [15:45:58.793]                 invisible(future)
  [15:45:58.793]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.793]         }
  [15:45:58.793]         base::options(...future.oldOptions)
  [15:45:58.793]     })
  [15:45:58.793]     Sys.time
  [15:45:58.793]     if (base::is.na(TRUE)) {
  [15:45:58.793]     }
  [15:45:58.793]     else {
  [15:45:58.793]         base::sink(type = "output", split = FALSE)
  [15:45:58.793]         if (TRUE) {
  [15:45:58.793]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.793]         }
  [15:45:58.793]         else {
  [15:45:58.793]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.793]         }
  [15:45:58.793]         base::close(...future.stdout)
  [15:45:58.793]         ...future.stdout <- NULL
  [15:45:58.793]     }
  [15:45:58.793]     ...future.result$conditions <- ...future.conditions
  [15:45:58.793]     ...future.result
  [15:45:58.793] }
  [15:45:58.798] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.824] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.824] - Validating connection of ClusterFuture
  [15:45:58.825] - received message: FutureResult
  [15:45:58.825] - Received FutureResult
  [15:45:58.826] - Erased future from FutureRegistry
  [15:45:58.826] result() for ClusterFuture ...
  [15:45:58.826] - result already collected: FutureResult
  [15:45:58.827] result() for ClusterFuture ... done
  [15:45:58.827] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.828] result() for ClusterFuture ...
  [15:45:58.828] - result already collected: FutureResult
  [15:45:58.828] result() for ClusterFuture ... done
  [15:45:58.829] result() for ClusterFuture ...
  [15:45:58.829] - result already collected: FutureResult
  [15:45:58.830] result() for ClusterFuture ... done
  [15:45:58.832] ClusterFuture started
  [15:45:58.834] getGlobalsAndPackages() ...
  [15:45:58.834] Searching for globals...
  [15:45:58.836] - globals found: [1] '{'
  [15:45:58.837] Searching for globals ... DONE
  [15:45:58.837] Resolving globals: FALSE
  [15:45:58.838] 
  [15:45:58.839] 
  [15:45:58.839] getGlobalsAndPackages() ... DONE
  [15:45:58.845] Packages needed by the future expression (n = 0): <none>
  [15:45:58.845] Packages needed by future strategies (n = 0): <none>
  [15:45:58.851] {
  [15:45:58.851]     {
  [15:45:58.851]         ...future.startTime <- base::Sys.time()
  [15:45:58.851]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:58.851]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:58.851]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:58.851]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:58.851]             future.resolve.recursive = NULL, width = 80L)
  [15:45:58.851]         {
  [15:45:58.851]             {
  [15:45:58.851]                 base::local({
  [15:45:58.851]                   has_future <- base::requireNamespace("future", 
  [15:45:58.851]                     quietly = TRUE)
  [15:45:58.851]                   version <- if (has_future) 
  [15:45:58.851]                     utils::packageVersion("future")
  [15:45:58.851]                   else NULL
  [15:45:58.851]                   if (!has_future || version < "1.8.0") {
  [15:45:58.851]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:58.851]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:58.851]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:58.851]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:58.851]                         "release", "version")], collapse = " "), 
  [15:45:58.851]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:58.851]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:58.851]                       info)
  [15:45:58.851]                     info <- base::paste(info, collapse = "; ")
  [15:45:58.851]                     if (!has_future) {
  [15:45:58.851]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:58.851]                         info)
  [15:45:58.851]                     }
  [15:45:58.851]                     else {
  [15:45:58.851]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:58.851]                         info, version)
  [15:45:58.851]                     }
  [15:45:58.851]                     base::stop(msg)
  [15:45:58.851]                   }
  [15:45:58.851]                 })
  [15:45:58.851]             }
  [15:45:58.851]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:58.851]         }
  [15:45:58.851]     }
  [15:45:58.851]     if (base::is.na(TRUE)) {
  [15:45:58.851]     }
  [15:45:58.851]     else {
  [15:45:58.851]         if (TRUE) {
  [15:45:58.851]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:58.851]                 open = "w")
  [15:45:58.851]         }
  [15:45:58.851]         else {
  [15:45:58.851]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:58.851]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:58.851]         }
  [15:45:58.851]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:58.851]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:58.851]             base::sink(type = "output", split = FALSE)
  [15:45:58.851]             base::close(...future.stdout)
  [15:45:58.851]         }, add = TRUE)
  [15:45:58.851]     }
  [15:45:58.851]     ...future.frame <- base::sys.nframe()
  [15:45:58.851]     ...future.conditions <- base::list()
  [15:45:58.851]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:58.851]     ...future.result <- base::tryCatch({
  [15:45:58.851]         base::withCallingHandlers({
  [15:45:58.851]             ...future.value <- base::withVisible(base::local({
  [15:45:58.851]                 ...future.sendCondition <- local({
  [15:45:58.851]                   sendCondition <- NULL
  [15:45:58.851]                   function(frame = 1L) {
  [15:45:58.851]                     if (is.function(sendCondition)) 
  [15:45:58.851]                       return(sendCondition)
  [15:45:58.851]                     ns <- getNamespace("parallel")
  [15:45:58.851]                     if (exists("sendData", mode = "function", 
  [15:45:58.851]                       envir = ns)) {
  [15:45:58.851]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:58.851]                         envir = ns)
  [15:45:58.851]                       envir <- sys.frame(frame)
  [15:45:58.851]                       master <- NULL
  [15:45:58.851]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:58.851]                         !identical(envir, emptyenv())) {
  [15:45:58.851]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:58.851]                           inherits = FALSE)) {
  [15:45:58.851]                           master <- get("master", mode = "list", 
  [15:45:58.851]                             envir = envir, inherits = FALSE)
  [15:45:58.851]                           if (inherits(master, "SOCKnode")) {
  [15:45:58.851]                             sendCondition <<- function(cond) {
  [15:45:58.851]                               data <- list(type = "VALUE", value = cond, 
  [15:45:58.851]                                 success = TRUE)
  [15:45:58.851]                               parallel_sendData(master, data)
  [15:45:58.851]                             }
  [15:45:58.851]                             return(sendCondition)
  [15:45:58.851]                           }
  [15:45:58.851]                         }
  [15:45:58.851]                         frame <- frame + 1L
  [15:45:58.851]                         envir <- sys.frame(frame)
  [15:45:58.851]                       }
  [15:45:58.851]                     }
  [15:45:58.851]                     sendCondition <<- function(cond) NULL
  [15:45:58.851]                   }
  [15:45:58.851]                 })
  [15:45:58.851]                 withCallingHandlers({
  [15:45:58.851]                   {
  [15:45:58.851]                     4
  [15:45:58.851]                   }
  [15:45:58.851]                 }, immediateCondition = function(cond) {
  [15:45:58.851]                   sendCondition <- ...future.sendCondition()
  [15:45:58.851]                   sendCondition(cond)
  [15:45:58.851]                   muffleCondition <- function (cond) 
  [15:45:58.851]                   {
  [15:45:58.851]                     inherits <- base::inherits
  [15:45:58.851]                     invokeRestart <- base::invokeRestart
  [15:45:58.851]                     muffled <- FALSE
  [15:45:58.851]                     if (inherits(cond, "message")) {
  [15:45:58.851]                       invokeRestart("muffleMessage")
  [15:45:58.851]                       muffled <- TRUE
  [15:45:58.851]                     }
  [15:45:58.851]                     else if (inherits(cond, "warning")) {
  [15:45:58.851]                       invokeRestart("muffleWarning")
  [15:45:58.851]                       muffled <- TRUE
  [15:45:58.851]                     }
  [15:45:58.851]                     else if (inherits(cond, "condition")) {
  [15:45:58.851]                       computeRestarts <- base::computeRestarts
  [15:45:58.851]                       grepl <- base::grepl
  [15:45:58.851]                       is.null <- base::is.null
  [15:45:58.851]                       restarts <- computeRestarts(cond)
  [15:45:58.851]                       for (restart in restarts) {
  [15:45:58.851]                         name <- restart$name
  [15:45:58.851]                         if (is.null(name)) 
  [15:45:58.851]                           next
  [15:45:58.851]                         if (!grepl("^muffle", name)) 
  [15:45:58.851]                           next
  [15:45:58.851]                         invokeRestart(restart)
  [15:45:58.851]                         muffled <- TRUE
  [15:45:58.851]                         break
  [15:45:58.851]                       }
  [15:45:58.851]                     }
  [15:45:58.851]                     invisible(muffled)
  [15:45:58.851]                   }
  [15:45:58.851]                   muffleCondition(cond)
  [15:45:58.851]                 })
  [15:45:58.851]             }))
  [15:45:58.851]             future::FutureResult(value = ...future.value$value, 
  [15:45:58.851]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.851]                   ...future.rng), started = ...future.startTime, 
  [15:45:58.851]                 version = "1.8")
  [15:45:58.851]         }, condition = base::local({
  [15:45:58.851]             c <- base::c
  [15:45:58.851]             inherits <- base::inherits
  [15:45:58.851]             invokeRestart <- base::invokeRestart
  [15:45:58.851]             length <- base::length
  [15:45:58.851]             list <- base::list
  [15:45:58.851]             seq.int <- base::seq.int
  [15:45:58.851]             signalCondition <- base::signalCondition
  [15:45:58.851]             sys.calls <- base::sys.calls
  [15:45:58.851]             Sys.time <- base::Sys.time
  [15:45:58.851]             `[[` <- base::`[[`
  [15:45:58.851]             `+` <- base::`+`
  [15:45:58.851]             `<<-` <- base::`<<-`
  [15:45:58.851]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:58.851]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:58.851]                   3L)]
  [15:45:58.851]             }
  [15:45:58.851]             function(cond) {
  [15:45:58.851]                 if (inherits(cond, "error")) {
  [15:45:58.851]                   sessionInformation <- function() {
  [15:45:58.851]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:58.851]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:58.851]                       search = base::search(), system = base::Sys.info())
  [15:45:58.851]                   }
  [15:45:58.851]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.851]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:58.851]                     cond$call), session = sessionInformation(), 
  [15:45:58.851]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:58.851]                   signalCondition(cond)
  [15:45:58.851]                 }
  [15:45:58.851]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:58.851]                 ))) {
  [15:45:58.851]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:58.851]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:58.851]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:58.851]                   if (!signal) {
  [15:45:58.851]                     muffleCondition <- function (cond) 
  [15:45:58.851]                     {
  [15:45:58.851]                       inherits <- base::inherits
  [15:45:58.851]                       invokeRestart <- base::invokeRestart
  [15:45:58.851]                       muffled <- FALSE
  [15:45:58.851]                       if (inherits(cond, "message")) {
  [15:45:58.851]                         invokeRestart("muffleMessage")
  [15:45:58.851]                         muffled <- TRUE
  [15:45:58.851]                       }
  [15:45:58.851]                       else if (inherits(cond, "warning")) {
  [15:45:58.851]                         invokeRestart("muffleWarning")
  [15:45:58.851]                         muffled <- TRUE
  [15:45:58.851]                       }
  [15:45:58.851]                       else if (inherits(cond, "condition")) {
  [15:45:58.851]                         computeRestarts <- base::computeRestarts
  [15:45:58.851]                         grepl <- base::grepl
  [15:45:58.851]                         is.null <- base::is.null
  [15:45:58.851]                         restarts <- computeRestarts(cond)
  [15:45:58.851]                         for (restart in restarts) {
  [15:45:58.851]                           name <- restart$name
  [15:45:58.851]                           if (is.null(name)) 
  [15:45:58.851]                             next
  [15:45:58.851]                           if (!grepl("^muffle", name)) 
  [15:45:58.851]                             next
  [15:45:58.851]                           invokeRestart(restart)
  [15:45:58.851]                           muffled <- TRUE
  [15:45:58.851]                           break
  [15:45:58.851]                         }
  [15:45:58.851]                       }
  [15:45:58.851]                       invisible(muffled)
  [15:45:58.851]                     }
  [15:45:58.851]                     muffleCondition(cond)
  [15:45:58.851]                   }
  [15:45:58.851]                 }
  [15:45:58.851]             }
  [15:45:58.851]         }))
  [15:45:58.851]     }, error = function(ex) {
  [15:45:58.851]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:58.851]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:58.851]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:58.851]     }, finally = {
  [15:45:58.851]         {
  [15:45:58.851]             NULL
  [15:45:58.851]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:58.851]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:58.851]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:58.851]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:58.851]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:58.851]                 ...) 
  [15:45:58.851]             {
  [15:45:58.851]                 if (substitute) 
  [15:45:58.851]                   expr <- substitute(expr)
  [15:45:58.851]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:58.851]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:58.851]                   globals = globals, persistent = persistent, 
  [15:45:58.851]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:58.851]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:58.851]                   label = label, ...)
  [15:45:58.851]                 if (!future$lazy) 
  [15:45:58.851]                   future <- run(future)
  [15:45:58.851]                 invisible(future)
  [15:45:58.851]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:58.851]         }
  [15:45:58.851]         base::options(...future.oldOptions)
  [15:45:58.851]     })
  [15:45:58.851]     Sys.time
  [15:45:58.851]     if (base::is.na(TRUE)) {
  [15:45:58.851]     }
  [15:45:58.851]     else {
  [15:45:58.851]         base::sink(type = "output", split = FALSE)
  [15:45:58.851]         if (TRUE) {
  [15:45:58.851]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:58.851]         }
  [15:45:58.851]         else {
  [15:45:58.851]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:58.851]         }
  [15:45:58.851]         base::close(...future.stdout)
  [15:45:58.851]         ...future.stdout <- NULL
  [15:45:58.851]     }
  [15:45:58.851]     ...future.result$conditions <- ...future.conditions
  [15:45:58.851]     ...future.result
  [15:45:58.851] }
  [15:45:58.857] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:58.879] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.880] - Validating connection of ClusterFuture
  [15:45:58.881] - received message: FutureResult
  [15:45:58.881] - Received FutureResult
  [15:45:58.882] - Erased future from FutureRegistry
  [15:45:58.882] result() for ClusterFuture ...
  [15:45:58.883] - result already collected: FutureResult
  [15:45:58.883] result() for ClusterFuture ... done
  [15:45:58.883] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:58.884] result() for ClusterFuture ...
  [15:45:58.884] - result already collected: FutureResult
  [15:45:58.885] result() for ClusterFuture ... done
  [15:45:58.885] result() for ClusterFuture ...
  [15:45:58.886] - result already collected: FutureResult
  [15:45:58.886] result() for ClusterFuture ... done
  [15:45:58.889] ClusterFuture started
  <environment: 0x55ca2ac36fe8> 
  <environment: 0x55ca2b1ccff8> 
  [15:45:58.936] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:58.937] - Validating connection of ClusterFuture
  [15:45:58.937] - received message: FutureResult
  [15:45:58.938] - Received FutureResult
  [15:45:58.938] - Erased future from FutureRegistry
  [15:45:58.939] result() for ClusterFuture ...
  [15:45:58.939] - result already collected: FutureResult
  [15:45:58.939] result() for ClusterFuture ... done
  [15:45:58.940] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:58.943] resolve() on environment ...
  [15:45:58.944]  recursive: 0
  [15:45:58.945]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:58.946] signalConditionsASAP(numeric, pos=1) ...
  [15:45:58.946] - nx: 4
  [15:45:58.947] - relay: TRUE
  [15:45:58.947] - stdout: TRUE
  [15:45:58.947] - signal: TRUE
  [15:45:58.948] - resignal: FALSE
  [15:45:58.948] - force: TRUE
  [15:45:58.948] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.949] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.949]  - until=2
  [15:45:58.949]  - relaying element #2
  [15:45:58.949] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.950] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.950] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:58.950]  length: 3 (resolved future 1)
  [15:45:58.950] Future #2
  [15:45:58.951] result() for ClusterFuture ...
  [15:45:58.951] - result already collected: FutureResult
  [15:45:58.951] result() for ClusterFuture ... done
  [15:45:58.952] result() for ClusterFuture ...
  [15:45:58.952] - result already collected: FutureResult
  [15:45:58.953] result() for ClusterFuture ... done
  [15:45:58.953] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:58.953] - nx: 4
  [15:45:58.954] - relay: TRUE
  [15:45:58.954] - stdout: TRUE
  [15:45:58.954] - signal: TRUE
  [15:45:58.955] - resignal: FALSE
  [15:45:58.955] - force: TRUE
  [15:45:58.955] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:58.956] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:58.956]  - until=2
  [15:45:58.956]  - relaying element #2
  [15:45:58.957] result() for ClusterFuture ...
  [15:45:58.957] - result already collected: FutureResult
  [15:45:58.957] result() for ClusterFuture ... done
  [15:45:58.958] result() for ClusterFuture ...
  [15:45:58.958] - result already collected: FutureResult
  [15:45:58.959] result() for ClusterFuture ... done
  [15:45:58.959] result() for ClusterFuture ...
  [15:45:58.959] - result already collected: FutureResult
  [15:45:58.960] result() for ClusterFuture ... done
  [15:45:58.960] result() for ClusterFuture ...
  [15:45:58.960] - result already collected: FutureResult
  [15:45:58.961] result() for ClusterFuture ... done
  [15:45:58.961] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.962] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.962] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:58.962]  length: 2 (resolved future 2)
  [15:45:58.963] Future #3
  [15:45:58.963] result() for ClusterFuture ...
  [15:45:58.964] - result already collected: FutureResult
  [15:45:58.964] result() for ClusterFuture ... done
  [15:45:58.964] result() for ClusterFuture ...
  [15:45:58.965] - result already collected: FutureResult
  [15:45:58.965] result() for ClusterFuture ... done
  [15:45:58.965] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:58.966] - nx: 4
  [15:45:58.966] - relay: TRUE
  [15:45:58.967] - stdout: TRUE
  [15:45:58.967] - signal: TRUE
  [15:45:58.967] - resignal: FALSE
  [15:45:58.968] - force: TRUE
  [15:45:58.968] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:58.968] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:58.969]  - until=3
  [15:45:58.969]  - relaying element #3
  [15:45:58.969] result() for ClusterFuture ...
  [15:45:58.970] - result already collected: FutureResult
  [15:45:58.970] result() for ClusterFuture ... done
  [15:45:58.970] result() for ClusterFuture ...
  [15:45:58.971] - result already collected: FutureResult
  [15:45:58.971] result() for ClusterFuture ... done
  [15:45:58.972] result() for ClusterFuture ...
  [15:45:58.972] - result already collected: FutureResult
  [15:45:58.972] result() for ClusterFuture ... done
  [15:45:58.973] result() for ClusterFuture ...
  [15:45:58.973] - result already collected: FutureResult
  [15:45:58.973] result() for ClusterFuture ... done
  [15:45:58.974] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.974] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.975] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:58.975]  length: 1 (resolved future 3)
  [15:45:58.975] Future #4
  [15:45:58.976] result() for ClusterFuture ...
  [15:45:58.976] - result already collected: FutureResult
  [15:45:58.976] result() for ClusterFuture ... done
  [15:45:58.977] result() for ClusterFuture ...
  [15:45:58.977] - result already collected: FutureResult
  [15:45:58.978] result() for ClusterFuture ... done
  [15:45:58.978] signalConditionsASAP(ClusterFuture, pos=4) ...
  [15:45:58.978] - nx: 4
  [15:45:58.979] - relay: TRUE
  [15:45:58.979] - stdout: TRUE
  [15:45:58.979] - signal: TRUE
  [15:45:58.980] - resignal: FALSE
  [15:45:58.980] - force: TRUE
  [15:45:58.980] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:58.981] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:58.981]  - until=4
  [15:45:58.981]  - relaying element #4
  [15:45:58.982] result() for ClusterFuture ...
  [15:45:58.982] - result already collected: FutureResult
  [15:45:58.983] result() for ClusterFuture ... done
  [15:45:58.983] result() for ClusterFuture ...
  [15:45:58.983] - result already collected: FutureResult
  [15:45:58.984] result() for ClusterFuture ... done
  [15:45:58.984] result() for ClusterFuture ...
  [15:45:58.984] - result already collected: FutureResult
  [15:45:58.985] result() for ClusterFuture ... done
  [15:45:58.985] result() for ClusterFuture ...
  [15:45:58.985] - result already collected: FutureResult
  [15:45:58.986] result() for ClusterFuture ... done
  [15:45:58.986] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.987] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.987] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [15:45:58.987]  length: 0 (resolved future 4)
  [15:45:58.988] Relaying remaining futures
  [15:45:58.988] signalConditionsASAP(NULL, pos=0) ...
  [15:45:58.988] - nx: 4
  [15:45:58.989] - relay: TRUE
  [15:45:58.989] - stdout: TRUE
  [15:45:58.989] - signal: TRUE
  [15:45:58.990] - resignal: FALSE
  [15:45:58.990] - force: TRUE
  [15:45:58.990] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.991] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:58.991] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:58.991] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:58.992] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:58.992] resolve() on environment ... DONE
  [15:45:58.993] result() for ClusterFuture ...
  [15:45:58.993] - result already collected: FutureResult
  [15:45:58.993] result() for ClusterFuture ... done
  [15:45:58.994] result() for ClusterFuture ...
  [15:45:58.994] - result already collected: FutureResult
  [15:45:58.994] result() for ClusterFuture ... done
  [15:45:58.995] result() for ClusterFuture ...
  [15:45:58.995] - result already collected: FutureResult
  [15:45:58.995] result() for ClusterFuture ... done
  [15:45:58.996] result() for ClusterFuture ...
  [15:45:58.996] - result already collected: FutureResult
  [15:45:58.997] result() for ClusterFuture ... done
  [15:45:58.997] result() for ClusterFuture ...
  [15:45:58.997] - result already collected: FutureResult
  [15:45:58.998] result() for ClusterFuture ... done
  [15:45:58.998] result() for ClusterFuture ...
  [15:45:58.998] - result already collected: FutureResult
  [15:45:58.999] result() for ClusterFuture ... done
  <environment: 0x55ca296c7d58> 
  Dimensions: c(2, 3, 1)
  [15:45:59.000] getGlobalsAndPackages() ...
  [15:45:59.001] Searching for globals...
  [15:45:59.001] 
  [15:45:59.002] Searching for globals ... DONE
  [15:45:59.002] - globals: [0] <none>
  [15:45:59.003] getGlobalsAndPackages() ... DONE
  [15:45:59.014] Packages needed by the future expression (n = 0): <none>
  [15:45:59.015] Packages needed by future strategies (n = 0): <none>
  [15:45:59.021] {
  [15:45:59.021]     {
  [15:45:59.021]         ...future.startTime <- base::Sys.time()
  [15:45:59.021]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.021]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.021]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.021]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.021]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.021]         {
  [15:45:59.021]             {
  [15:45:59.021]                 base::local({
  [15:45:59.021]                   has_future <- base::requireNamespace("future", 
  [15:45:59.021]                     quietly = TRUE)
  [15:45:59.021]                   version <- if (has_future) 
  [15:45:59.021]                     utils::packageVersion("future")
  [15:45:59.021]                   else NULL
  [15:45:59.021]                   if (!has_future || version < "1.8.0") {
  [15:45:59.021]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.021]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.021]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.021]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.021]                         "release", "version")], collapse = " "), 
  [15:45:59.021]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.021]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.021]                       info)
  [15:45:59.021]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.021]                     if (!has_future) {
  [15:45:59.021]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.021]                         info)
  [15:45:59.021]                     }
  [15:45:59.021]                     else {
  [15:45:59.021]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.021]                         info, version)
  [15:45:59.021]                     }
  [15:45:59.021]                     base::stop(msg)
  [15:45:59.021]                   }
  [15:45:59.021]                 })
  [15:45:59.021]             }
  [15:45:59.021]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.021]         }
  [15:45:59.021]     }
  [15:45:59.021]     if (base::is.na(TRUE)) {
  [15:45:59.021]     }
  [15:45:59.021]     else {
  [15:45:59.021]         if (TRUE) {
  [15:45:59.021]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.021]                 open = "w")
  [15:45:59.021]         }
  [15:45:59.021]         else {
  [15:45:59.021]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.021]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.021]         }
  [15:45:59.021]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.021]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.021]             base::sink(type = "output", split = FALSE)
  [15:45:59.021]             base::close(...future.stdout)
  [15:45:59.021]         }, add = TRUE)
  [15:45:59.021]     }
  [15:45:59.021]     ...future.frame <- base::sys.nframe()
  [15:45:59.021]     ...future.conditions <- base::list()
  [15:45:59.021]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.021]     ...future.result <- base::tryCatch({
  [15:45:59.021]         base::withCallingHandlers({
  [15:45:59.021]             ...future.value <- base::withVisible(base::local({
  [15:45:59.021]                 ...future.sendCondition <- local({
  [15:45:59.021]                   sendCondition <- NULL
  [15:45:59.021]                   function(frame = 1L) {
  [15:45:59.021]                     if (is.function(sendCondition)) 
  [15:45:59.021]                       return(sendCondition)
  [15:45:59.021]                     ns <- getNamespace("parallel")
  [15:45:59.021]                     if (exists("sendData", mode = "function", 
  [15:45:59.021]                       envir = ns)) {
  [15:45:59.021]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.021]                         envir = ns)
  [15:45:59.021]                       envir <- sys.frame(frame)
  [15:45:59.021]                       master <- NULL
  [15:45:59.021]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.021]                         !identical(envir, emptyenv())) {
  [15:45:59.021]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.021]                           inherits = FALSE)) {
  [15:45:59.021]                           master <- get("master", mode = "list", 
  [15:45:59.021]                             envir = envir, inherits = FALSE)
  [15:45:59.021]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.021]                             sendCondition <<- function(cond) {
  [15:45:59.021]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.021]                                 success = TRUE)
  [15:45:59.021]                               parallel_sendData(master, data)
  [15:45:59.021]                             }
  [15:45:59.021]                             return(sendCondition)
  [15:45:59.021]                           }
  [15:45:59.021]                         }
  [15:45:59.021]                         frame <- frame + 1L
  [15:45:59.021]                         envir <- sys.frame(frame)
  [15:45:59.021]                       }
  [15:45:59.021]                     }
  [15:45:59.021]                     sendCondition <<- function(cond) NULL
  [15:45:59.021]                   }
  [15:45:59.021]                 })
  [15:45:59.021]                 withCallingHandlers({
  [15:45:59.021]                   2
  [15:45:59.021]                 }, immediateCondition = function(cond) {
  [15:45:59.021]                   sendCondition <- ...future.sendCondition()
  [15:45:59.021]                   sendCondition(cond)
  [15:45:59.021]                   muffleCondition <- function (cond) 
  [15:45:59.021]                   {
  [15:45:59.021]                     inherits <- base::inherits
  [15:45:59.021]                     invokeRestart <- base::invokeRestart
  [15:45:59.021]                     muffled <- FALSE
  [15:45:59.021]                     if (inherits(cond, "message")) {
  [15:45:59.021]                       invokeRestart("muffleMessage")
  [15:45:59.021]                       muffled <- TRUE
  [15:45:59.021]                     }
  [15:45:59.021]                     else if (inherits(cond, "warning")) {
  [15:45:59.021]                       invokeRestart("muffleWarning")
  [15:45:59.021]                       muffled <- TRUE
  [15:45:59.021]                     }
  [15:45:59.021]                     else if (inherits(cond, "condition")) {
  [15:45:59.021]                       computeRestarts <- base::computeRestarts
  [15:45:59.021]                       grepl <- base::grepl
  [15:45:59.021]                       is.null <- base::is.null
  [15:45:59.021]                       restarts <- computeRestarts(cond)
  [15:45:59.021]                       for (restart in restarts) {
  [15:45:59.021]                         name <- restart$name
  [15:45:59.021]                         if (is.null(name)) 
  [15:45:59.021]                           next
  [15:45:59.021]                         if (!grepl("^muffle", name)) 
  [15:45:59.021]                           next
  [15:45:59.021]                         invokeRestart(restart)
  [15:45:59.021]                         muffled <- TRUE
  [15:45:59.021]                         break
  [15:45:59.021]                       }
  [15:45:59.021]                     }
  [15:45:59.021]                     invisible(muffled)
  [15:45:59.021]                   }
  [15:45:59.021]                   muffleCondition(cond)
  [15:45:59.021]                 })
  [15:45:59.021]             }))
  [15:45:59.021]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.021]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.021]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.021]                 version = "1.8")
  [15:45:59.021]         }, condition = base::local({
  [15:45:59.021]             c <- base::c
  [15:45:59.021]             inherits <- base::inherits
  [15:45:59.021]             invokeRestart <- base::invokeRestart
  [15:45:59.021]             length <- base::length
  [15:45:59.021]             list <- base::list
  [15:45:59.021]             seq.int <- base::seq.int
  [15:45:59.021]             signalCondition <- base::signalCondition
  [15:45:59.021]             sys.calls <- base::sys.calls
  [15:45:59.021]             Sys.time <- base::Sys.time
  [15:45:59.021]             `[[` <- base::`[[`
  [15:45:59.021]             `+` <- base::`+`
  [15:45:59.021]             `<<-` <- base::`<<-`
  [15:45:59.021]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.021]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.021]                   3L)]
  [15:45:59.021]             }
  [15:45:59.021]             function(cond) {
  [15:45:59.021]                 if (inherits(cond, "error")) {
  [15:45:59.021]                   sessionInformation <- function() {
  [15:45:59.021]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.021]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.021]                       search = base::search(), system = base::Sys.info())
  [15:45:59.021]                   }
  [15:45:59.021]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.021]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.021]                     cond$call), session = sessionInformation(), 
  [15:45:59.021]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.021]                   signalCondition(cond)
  [15:45:59.021]                 }
  [15:45:59.021]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.021]                 ))) {
  [15:45:59.021]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.021]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.021]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.021]                   if (!signal) {
  [15:45:59.021]                     muffleCondition <- function (cond) 
  [15:45:59.021]                     {
  [15:45:59.021]                       inherits <- base::inherits
  [15:45:59.021]                       invokeRestart <- base::invokeRestart
  [15:45:59.021]                       muffled <- FALSE
  [15:45:59.021]                       if (inherits(cond, "message")) {
  [15:45:59.021]                         invokeRestart("muffleMessage")
  [15:45:59.021]                         muffled <- TRUE
  [15:45:59.021]                       }
  [15:45:59.021]                       else if (inherits(cond, "warning")) {
  [15:45:59.021]                         invokeRestart("muffleWarning")
  [15:45:59.021]                         muffled <- TRUE
  [15:45:59.021]                       }
  [15:45:59.021]                       else if (inherits(cond, "condition")) {
  [15:45:59.021]                         computeRestarts <- base::computeRestarts
  [15:45:59.021]                         grepl <- base::grepl
  [15:45:59.021]                         is.null <- base::is.null
  [15:45:59.021]                         restarts <- computeRestarts(cond)
  [15:45:59.021]                         for (restart in restarts) {
  [15:45:59.021]                           name <- restart$name
  [15:45:59.021]                           if (is.null(name)) 
  [15:45:59.021]                             next
  [15:45:59.021]                           if (!grepl("^muffle", name)) 
  [15:45:59.021]                             next
  [15:45:59.021]                           invokeRestart(restart)
  [15:45:59.021]                           muffled <- TRUE
  [15:45:59.021]                           break
  [15:45:59.021]                         }
  [15:45:59.021]                       }
  [15:45:59.021]                       invisible(muffled)
  [15:45:59.021]                     }
  [15:45:59.021]                     muffleCondition(cond)
  [15:45:59.021]                   }
  [15:45:59.021]                 }
  [15:45:59.021]             }
  [15:45:59.021]         }))
  [15:45:59.021]     }, error = function(ex) {
  [15:45:59.021]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.021]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.021]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.021]     }, finally = {
  [15:45:59.021]         {
  [15:45:59.021]             NULL
  [15:45:59.021]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.021]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.021]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.021]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.021]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.021]                 ...) 
  [15:45:59.021]             {
  [15:45:59.021]                 if (substitute) 
  [15:45:59.021]                   expr <- substitute(expr)
  [15:45:59.021]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.021]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.021]                   globals = globals, persistent = persistent, 
  [15:45:59.021]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.021]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.021]                   label = label, ...)
  [15:45:59.021]                 if (!future$lazy) 
  [15:45:59.021]                   future <- run(future)
  [15:45:59.021]                 invisible(future)
  [15:45:59.021]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.021]         }
  [15:45:59.021]         base::options(...future.oldOptions)
  [15:45:59.021]     })
  [15:45:59.021]     Sys.time
  [15:45:59.021]     if (base::is.na(TRUE)) {
  [15:45:59.021]     }
  [15:45:59.021]     else {
  [15:45:59.021]         base::sink(type = "output", split = FALSE)
  [15:45:59.021]         if (TRUE) {
  [15:45:59.021]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.021]         }
  [15:45:59.021]         else {
  [15:45:59.021]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.021]         }
  [15:45:59.021]         base::close(...future.stdout)
  [15:45:59.021]         ...future.stdout <- NULL
  [15:45:59.021]     }
  [15:45:59.021]     ...future.result$conditions <- ...future.conditions
  [15:45:59.021]     ...future.result
  [15:45:59.021] }
  [15:45:59.030] ClusterFuture started
  [15:45:59.030] getGlobalsAndPackages() ...
  [15:45:59.031] Searching for globals...
  [15:45:59.032] 
  [15:45:59.032] Searching for globals ... DONE
  [15:45:59.032] - globals: [0] <none>
  [15:45:59.033] getGlobalsAndPackages() ... DONE
  [15:45:59.039] Packages needed by the future expression (n = 0): <none>
  [15:45:59.039] Packages needed by future strategies (n = 0): <none>
  [15:45:59.046] {
  [15:45:59.046]     {
  [15:45:59.046]         ...future.startTime <- base::Sys.time()
  [15:45:59.046]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.046]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.046]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.046]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.046]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.046]         {
  [15:45:59.046]             {
  [15:45:59.046]                 base::local({
  [15:45:59.046]                   has_future <- base::requireNamespace("future", 
  [15:45:59.046]                     quietly = TRUE)
  [15:45:59.046]                   version <- if (has_future) 
  [15:45:59.046]                     utils::packageVersion("future")
  [15:45:59.046]                   else NULL
  [15:45:59.046]                   if (!has_future || version < "1.8.0") {
  [15:45:59.046]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.046]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.046]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.046]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.046]                         "release", "version")], collapse = " "), 
  [15:45:59.046]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.046]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.046]                       info)
  [15:45:59.046]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.046]                     if (!has_future) {
  [15:45:59.046]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.046]                         info)
  [15:45:59.046]                     }
  [15:45:59.046]                     else {
  [15:45:59.046]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.046]                         info, version)
  [15:45:59.046]                     }
  [15:45:59.046]                     base::stop(msg)
  [15:45:59.046]                   }
  [15:45:59.046]                 })
  [15:45:59.046]             }
  [15:45:59.046]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.046]         }
  [15:45:59.046]     }
  [15:45:59.046]     if (base::is.na(TRUE)) {
  [15:45:59.046]     }
  [15:45:59.046]     else {
  [15:45:59.046]         if (TRUE) {
  [15:45:59.046]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.046]                 open = "w")
  [15:45:59.046]         }
  [15:45:59.046]         else {
  [15:45:59.046]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.046]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.046]         }
  [15:45:59.046]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.046]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.046]             base::sink(type = "output", split = FALSE)
  [15:45:59.046]             base::close(...future.stdout)
  [15:45:59.046]         }, add = TRUE)
  [15:45:59.046]     }
  [15:45:59.046]     ...future.frame <- base::sys.nframe()
  [15:45:59.046]     ...future.conditions <- base::list()
  [15:45:59.046]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.046]     ...future.result <- base::tryCatch({
  [15:45:59.046]         base::withCallingHandlers({
  [15:45:59.046]             ...future.value <- base::withVisible(base::local({
  [15:45:59.046]                 ...future.sendCondition <- local({
  [15:45:59.046]                   sendCondition <- NULL
  [15:45:59.046]                   function(frame = 1L) {
  [15:45:59.046]                     if (is.function(sendCondition)) 
  [15:45:59.046]                       return(sendCondition)
  [15:45:59.046]                     ns <- getNamespace("parallel")
  [15:45:59.046]                     if (exists("sendData", mode = "function", 
  [15:45:59.046]                       envir = ns)) {
  [15:45:59.046]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.046]                         envir = ns)
  [15:45:59.046]                       envir <- sys.frame(frame)
  [15:45:59.046]                       master <- NULL
  [15:45:59.046]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.046]                         !identical(envir, emptyenv())) {
  [15:45:59.046]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.046]                           inherits = FALSE)) {
  [15:45:59.046]                           master <- get("master", mode = "list", 
  [15:45:59.046]                             envir = envir, inherits = FALSE)
  [15:45:59.046]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.046]                             sendCondition <<- function(cond) {
  [15:45:59.046]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.046]                                 success = TRUE)
  [15:45:59.046]                               parallel_sendData(master, data)
  [15:45:59.046]                             }
  [15:45:59.046]                             return(sendCondition)
  [15:45:59.046]                           }
  [15:45:59.046]                         }
  [15:45:59.046]                         frame <- frame + 1L
  [15:45:59.046]                         envir <- sys.frame(frame)
  [15:45:59.046]                       }
  [15:45:59.046]                     }
  [15:45:59.046]                     sendCondition <<- function(cond) NULL
  [15:45:59.046]                   }
  [15:45:59.046]                 })
  [15:45:59.046]                 withCallingHandlers({
  [15:45:59.046]                   NULL
  [15:45:59.046]                 }, immediateCondition = function(cond) {
  [15:45:59.046]                   sendCondition <- ...future.sendCondition()
  [15:45:59.046]                   sendCondition(cond)
  [15:45:59.046]                   muffleCondition <- function (cond) 
  [15:45:59.046]                   {
  [15:45:59.046]                     inherits <- base::inherits
  [15:45:59.046]                     invokeRestart <- base::invokeRestart
  [15:45:59.046]                     muffled <- FALSE
  [15:45:59.046]                     if (inherits(cond, "message")) {
  [15:45:59.046]                       invokeRestart("muffleMessage")
  [15:45:59.046]                       muffled <- TRUE
  [15:45:59.046]                     }
  [15:45:59.046]                     else if (inherits(cond, "warning")) {
  [15:45:59.046]                       invokeRestart("muffleWarning")
  [15:45:59.046]                       muffled <- TRUE
  [15:45:59.046]                     }
  [15:45:59.046]                     else if (inherits(cond, "condition")) {
  [15:45:59.046]                       computeRestarts <- base::computeRestarts
  [15:45:59.046]                       grepl <- base::grepl
  [15:45:59.046]                       is.null <- base::is.null
  [15:45:59.046]                       restarts <- computeRestarts(cond)
  [15:45:59.046]                       for (restart in restarts) {
  [15:45:59.046]                         name <- restart$name
  [15:45:59.046]                         if (is.null(name)) 
  [15:45:59.046]                           next
  [15:45:59.046]                         if (!grepl("^muffle", name)) 
  [15:45:59.046]                           next
  [15:45:59.046]                         invokeRestart(restart)
  [15:45:59.046]                         muffled <- TRUE
  [15:45:59.046]                         break
  [15:45:59.046]                       }
  [15:45:59.046]                     }
  [15:45:59.046]                     invisible(muffled)
  [15:45:59.046]                   }
  [15:45:59.046]                   muffleCondition(cond)
  [15:45:59.046]                 })
  [15:45:59.046]             }))
  [15:45:59.046]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.046]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.046]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.046]                 version = "1.8")
  [15:45:59.046]         }, condition = base::local({
  [15:45:59.046]             c <- base::c
  [15:45:59.046]             inherits <- base::inherits
  [15:45:59.046]             invokeRestart <- base::invokeRestart
  [15:45:59.046]             length <- base::length
  [15:45:59.046]             list <- base::list
  [15:45:59.046]             seq.int <- base::seq.int
  [15:45:59.046]             signalCondition <- base::signalCondition
  [15:45:59.046]             sys.calls <- base::sys.calls
  [15:45:59.046]             Sys.time <- base::Sys.time
  [15:45:59.046]             `[[` <- base::`[[`
  [15:45:59.046]             `+` <- base::`+`
  [15:45:59.046]             `<<-` <- base::`<<-`
  [15:45:59.046]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.046]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.046]                   3L)]
  [15:45:59.046]             }
  [15:45:59.046]             function(cond) {
  [15:45:59.046]                 if (inherits(cond, "error")) {
  [15:45:59.046]                   sessionInformation <- function() {
  [15:45:59.046]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.046]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.046]                       search = base::search(), system = base::Sys.info())
  [15:45:59.046]                   }
  [15:45:59.046]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.046]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.046]                     cond$call), session = sessionInformation(), 
  [15:45:59.046]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.046]                   signalCondition(cond)
  [15:45:59.046]                 }
  [15:45:59.046]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.046]                 ))) {
  [15:45:59.046]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.046]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.046]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.046]                   if (!signal) {
  [15:45:59.046]                     muffleCondition <- function (cond) 
  [15:45:59.046]                     {
  [15:45:59.046]                       inherits <- base::inherits
  [15:45:59.046]                       invokeRestart <- base::invokeRestart
  [15:45:59.046]                       muffled <- FALSE
  [15:45:59.046]                       if (inherits(cond, "message")) {
  [15:45:59.046]                         invokeRestart("muffleMessage")
  [15:45:59.046]                         muffled <- TRUE
  [15:45:59.046]                       }
  [15:45:59.046]                       else if (inherits(cond, "warning")) {
  [15:45:59.046]                         invokeRestart("muffleWarning")
  [15:45:59.046]                         muffled <- TRUE
  [15:45:59.046]                       }
  [15:45:59.046]                       else if (inherits(cond, "condition")) {
  [15:45:59.046]                         computeRestarts <- base::computeRestarts
  [15:45:59.046]                         grepl <- base::grepl
  [15:45:59.046]                         is.null <- base::is.null
  [15:45:59.046]                         restarts <- computeRestarts(cond)
  [15:45:59.046]                         for (restart in restarts) {
  [15:45:59.046]                           name <- restart$name
  [15:45:59.046]                           if (is.null(name)) 
  [15:45:59.046]                             next
  [15:45:59.046]                           if (!grepl("^muffle", name)) 
  [15:45:59.046]                             next
  [15:45:59.046]                           invokeRestart(restart)
  [15:45:59.046]                           muffled <- TRUE
  [15:45:59.046]                           break
  [15:45:59.046]                         }
  [15:45:59.046]                       }
  [15:45:59.046]                       invisible(muffled)
  [15:45:59.046]                     }
  [15:45:59.046]                     muffleCondition(cond)
  [15:45:59.046]                   }
  [15:45:59.046]                 }
  [15:45:59.046]             }
  [15:45:59.046]         }))
  [15:45:59.046]     }, error = function(ex) {
  [15:45:59.046]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.046]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.046]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.046]     }, finally = {
  [15:45:59.046]         {
  [15:45:59.046]             NULL
  [15:45:59.046]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.046]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.046]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.046]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.046]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.046]                 ...) 
  [15:45:59.046]             {
  [15:45:59.046]                 if (substitute) 
  [15:45:59.046]                   expr <- substitute(expr)
  [15:45:59.046]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.046]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.046]                   globals = globals, persistent = persistent, 
  [15:45:59.046]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.046]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.046]                   label = label, ...)
  [15:45:59.046]                 if (!future$lazy) 
  [15:45:59.046]                   future <- run(future)
  [15:45:59.046]                 invisible(future)
  [15:45:59.046]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.046]         }
  [15:45:59.046]         base::options(...future.oldOptions)
  [15:45:59.046]     })
  [15:45:59.046]     Sys.time
  [15:45:59.046]     if (base::is.na(TRUE)) {
  [15:45:59.046]     }
  [15:45:59.046]     else {
  [15:45:59.046]         base::sink(type = "output", split = FALSE)
  [15:45:59.046]         if (TRUE) {
  [15:45:59.046]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.046]         }
  [15:45:59.046]         else {
  [15:45:59.046]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.046]         }
  [15:45:59.046]         base::close(...future.stdout)
  [15:45:59.046]         ...future.stdout <- NULL
  [15:45:59.046]     }
  [15:45:59.046]     ...future.result$conditions <- ...future.conditions
  [15:45:59.046]     ...future.result
  [15:45:59.046] }
  [15:45:59.051] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:59.082] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.083] - Validating connection of ClusterFuture
  [15:45:59.083] - received message: FutureResult
  [15:45:59.084] - Received FutureResult
  [15:45:59.084] - Erased future from FutureRegistry
  [15:45:59.085] result() for ClusterFuture ...
  [15:45:59.085] - result already collected: FutureResult
  [15:45:59.085] result() for ClusterFuture ... done
  [15:45:59.086] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:59.086] result() for ClusterFuture ...
  [15:45:59.087] - result already collected: FutureResult
  [15:45:59.087] result() for ClusterFuture ... done
  [15:45:59.088] result() for ClusterFuture ...
  [15:45:59.088] - result already collected: FutureResult
  [15:45:59.088] result() for ClusterFuture ... done
  [15:45:59.091] ClusterFuture started
  [15:45:59.092] getGlobalsAndPackages() ...
  [15:45:59.092] Searching for globals...
  [15:45:59.094] - globals found: [1] '{'
  [15:45:59.094] Searching for globals ... DONE
  [15:45:59.095] Resolving globals: FALSE
  [15:45:59.096] 
  [15:45:59.096] 
  [15:45:59.096] getGlobalsAndPackages() ... DONE
  [15:45:59.112] Packages needed by the future expression (n = 0): <none>
  [15:45:59.113] Packages needed by future strategies (n = 0): <none>
  [15:45:59.119] {
  [15:45:59.119]     {
  [15:45:59.119]         ...future.startTime <- base::Sys.time()
  [15:45:59.119]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.119]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.119]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.119]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.119]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.119]         {
  [15:45:59.119]             {
  [15:45:59.119]                 base::local({
  [15:45:59.119]                   has_future <- base::requireNamespace("future", 
  [15:45:59.119]                     quietly = TRUE)
  [15:45:59.119]                   version <- if (has_future) 
  [15:45:59.119]                     utils::packageVersion("future")
  [15:45:59.119]                   else NULL
  [15:45:59.119]                   if (!has_future || version < "1.8.0") {
  [15:45:59.119]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.119]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.119]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.119]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.119]                         "release", "version")], collapse = " "), 
  [15:45:59.119]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.119]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.119]                       info)
  [15:45:59.119]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.119]                     if (!has_future) {
  [15:45:59.119]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.119]                         info)
  [15:45:59.119]                     }
  [15:45:59.119]                     else {
  [15:45:59.119]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.119]                         info, version)
  [15:45:59.119]                     }
  [15:45:59.119]                     base::stop(msg)
  [15:45:59.119]                   }
  [15:45:59.119]                 })
  [15:45:59.119]             }
  [15:45:59.119]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.119]         }
  [15:45:59.119]     }
  [15:45:59.119]     if (base::is.na(TRUE)) {
  [15:45:59.119]     }
  [15:45:59.119]     else {
  [15:45:59.119]         if (TRUE) {
  [15:45:59.119]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.119]                 open = "w")
  [15:45:59.119]         }
  [15:45:59.119]         else {
  [15:45:59.119]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.119]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.119]         }
  [15:45:59.119]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.119]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.119]             base::sink(type = "output", split = FALSE)
  [15:45:59.119]             base::close(...future.stdout)
  [15:45:59.119]         }, add = TRUE)
  [15:45:59.119]     }
  [15:45:59.119]     ...future.frame <- base::sys.nframe()
  [15:45:59.119]     ...future.conditions <- base::list()
  [15:45:59.119]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.119]     ...future.result <- base::tryCatch({
  [15:45:59.119]         base::withCallingHandlers({
  [15:45:59.119]             ...future.value <- base::withVisible(base::local({
  [15:45:59.119]                 ...future.sendCondition <- local({
  [15:45:59.119]                   sendCondition <- NULL
  [15:45:59.119]                   function(frame = 1L) {
  [15:45:59.119]                     if (is.function(sendCondition)) 
  [15:45:59.119]                       return(sendCondition)
  [15:45:59.119]                     ns <- getNamespace("parallel")
  [15:45:59.119]                     if (exists("sendData", mode = "function", 
  [15:45:59.119]                       envir = ns)) {
  [15:45:59.119]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.119]                         envir = ns)
  [15:45:59.119]                       envir <- sys.frame(frame)
  [15:45:59.119]                       master <- NULL
  [15:45:59.119]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.119]                         !identical(envir, emptyenv())) {
  [15:45:59.119]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.119]                           inherits = FALSE)) {
  [15:45:59.119]                           master <- get("master", mode = "list", 
  [15:45:59.119]                             envir = envir, inherits = FALSE)
  [15:45:59.119]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.119]                             sendCondition <<- function(cond) {
  [15:45:59.119]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.119]                                 success = TRUE)
  [15:45:59.119]                               parallel_sendData(master, data)
  [15:45:59.119]                             }
  [15:45:59.119]                             return(sendCondition)
  [15:45:59.119]                           }
  [15:45:59.119]                         }
  [15:45:59.119]                         frame <- frame + 1L
  [15:45:59.119]                         envir <- sys.frame(frame)
  [15:45:59.119]                       }
  [15:45:59.119]                     }
  [15:45:59.119]                     sendCondition <<- function(cond) NULL
  [15:45:59.119]                   }
  [15:45:59.119]                 })
  [15:45:59.119]                 withCallingHandlers({
  [15:45:59.119]                   {
  [15:45:59.119]                     4
  [15:45:59.119]                   }
  [15:45:59.119]                 }, immediateCondition = function(cond) {
  [15:45:59.119]                   sendCondition <- ...future.sendCondition()
  [15:45:59.119]                   sendCondition(cond)
  [15:45:59.119]                   muffleCondition <- function (cond) 
  [15:45:59.119]                   {
  [15:45:59.119]                     inherits <- base::inherits
  [15:45:59.119]                     invokeRestart <- base::invokeRestart
  [15:45:59.119]                     muffled <- FALSE
  [15:45:59.119]                     if (inherits(cond, "message")) {
  [15:45:59.119]                       invokeRestart("muffleMessage")
  [15:45:59.119]                       muffled <- TRUE
  [15:45:59.119]                     }
  [15:45:59.119]                     else if (inherits(cond, "warning")) {
  [15:45:59.119]                       invokeRestart("muffleWarning")
  [15:45:59.119]                       muffled <- TRUE
  [15:45:59.119]                     }
  [15:45:59.119]                     else if (inherits(cond, "condition")) {
  [15:45:59.119]                       computeRestarts <- base::computeRestarts
  [15:45:59.119]                       grepl <- base::grepl
  [15:45:59.119]                       is.null <- base::is.null
  [15:45:59.119]                       restarts <- computeRestarts(cond)
  [15:45:59.119]                       for (restart in restarts) {
  [15:45:59.119]                         name <- restart$name
  [15:45:59.119]                         if (is.null(name)) 
  [15:45:59.119]                           next
  [15:45:59.119]                         if (!grepl("^muffle", name)) 
  [15:45:59.119]                           next
  [15:45:59.119]                         invokeRestart(restart)
  [15:45:59.119]                         muffled <- TRUE
  [15:45:59.119]                         break
  [15:45:59.119]                       }
  [15:45:59.119]                     }
  [15:45:59.119]                     invisible(muffled)
  [15:45:59.119]                   }
  [15:45:59.119]                   muffleCondition(cond)
  [15:45:59.119]                 })
  [15:45:59.119]             }))
  [15:45:59.119]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.119]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.119]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.119]                 version = "1.8")
  [15:45:59.119]         }, condition = base::local({
  [15:45:59.119]             c <- base::c
  [15:45:59.119]             inherits <- base::inherits
  [15:45:59.119]             invokeRestart <- base::invokeRestart
  [15:45:59.119]             length <- base::length
  [15:45:59.119]             list <- base::list
  [15:45:59.119]             seq.int <- base::seq.int
  [15:45:59.119]             signalCondition <- base::signalCondition
  [15:45:59.119]             sys.calls <- base::sys.calls
  [15:45:59.119]             Sys.time <- base::Sys.time
  [15:45:59.119]             `[[` <- base::`[[`
  [15:45:59.119]             `+` <- base::`+`
  [15:45:59.119]             `<<-` <- base::`<<-`
  [15:45:59.119]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.119]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.119]                   3L)]
  [15:45:59.119]             }
  [15:45:59.119]             function(cond) {
  [15:45:59.119]                 if (inherits(cond, "error")) {
  [15:45:59.119]                   sessionInformation <- function() {
  [15:45:59.119]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.119]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.119]                       search = base::search(), system = base::Sys.info())
  [15:45:59.119]                   }
  [15:45:59.119]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.119]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.119]                     cond$call), session = sessionInformation(), 
  [15:45:59.119]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.119]                   signalCondition(cond)
  [15:45:59.119]                 }
  [15:45:59.119]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.119]                 ))) {
  [15:45:59.119]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.119]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.119]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.119]                   if (!signal) {
  [15:45:59.119]                     muffleCondition <- function (cond) 
  [15:45:59.119]                     {
  [15:45:59.119]                       inherits <- base::inherits
  [15:45:59.119]                       invokeRestart <- base::invokeRestart
  [15:45:59.119]                       muffled <- FALSE
  [15:45:59.119]                       if (inherits(cond, "message")) {
  [15:45:59.119]                         invokeRestart("muffleMessage")
  [15:45:59.119]                         muffled <- TRUE
  [15:45:59.119]                       }
  [15:45:59.119]                       else if (inherits(cond, "warning")) {
  [15:45:59.119]                         invokeRestart("muffleWarning")
  [15:45:59.119]                         muffled <- TRUE
  [15:45:59.119]                       }
  [15:45:59.119]                       else if (inherits(cond, "condition")) {
  [15:45:59.119]                         computeRestarts <- base::computeRestarts
  [15:45:59.119]                         grepl <- base::grepl
  [15:45:59.119]                         is.null <- base::is.null
  [15:45:59.119]                         restarts <- computeRestarts(cond)
  [15:45:59.119]                         for (restart in restarts) {
  [15:45:59.119]                           name <- restart$name
  [15:45:59.119]                           if (is.null(name)) 
  [15:45:59.119]                             next
  [15:45:59.119]                           if (!grepl("^muffle", name)) 
  [15:45:59.119]                             next
  [15:45:59.119]                           invokeRestart(restart)
  [15:45:59.119]                           muffled <- TRUE
  [15:45:59.119]                           break
  [15:45:59.119]                         }
  [15:45:59.119]                       }
  [15:45:59.119]                       invisible(muffled)
  [15:45:59.119]                     }
  [15:45:59.119]                     muffleCondition(cond)
  [15:45:59.119]                   }
  [15:45:59.119]                 }
  [15:45:59.119]             }
  [15:45:59.119]         }))
  [15:45:59.119]     }, error = function(ex) {
  [15:45:59.119]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.119]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.119]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.119]     }, finally = {
  [15:45:59.119]         {
  [15:45:59.119]             NULL
  [15:45:59.119]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.119]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.119]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.119]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.119]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.119]                 ...) 
  [15:45:59.119]             {
  [15:45:59.119]                 if (substitute) 
  [15:45:59.119]                   expr <- substitute(expr)
  [15:45:59.119]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.119]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.119]                   globals = globals, persistent = persistent, 
  [15:45:59.119]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.119]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.119]                   label = label, ...)
  [15:45:59.119]                 if (!future$lazy) 
  [15:45:59.119]                   future <- run(future)
  [15:45:59.119]                 invisible(future)
  [15:45:59.119]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.119]         }
  [15:45:59.119]         base::options(...future.oldOptions)
  [15:45:59.119]     })
  [15:45:59.119]     Sys.time
  [15:45:59.119]     if (base::is.na(TRUE)) {
  [15:45:59.119]     }
  [15:45:59.119]     else {
  [15:45:59.119]         base::sink(type = "output", split = FALSE)
  [15:45:59.119]         if (TRUE) {
  [15:45:59.119]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.119]         }
  [15:45:59.119]         else {
  [15:45:59.119]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.119]         }
  [15:45:59.119]         base::close(...future.stdout)
  [15:45:59.119]         ...future.stdout <- NULL
  [15:45:59.119]     }
  [15:45:59.119]     ...future.result$conditions <- ...future.conditions
  [15:45:59.119]     ...future.result
  [15:45:59.119] }
  [15:45:59.142] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:59.155] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.155] - Validating connection of ClusterFuture
  [15:45:59.156] - received message: FutureResult
  [15:45:59.156] - Received FutureResult
  [15:45:59.157] - Erased future from FutureRegistry
  [15:45:59.157] result() for ClusterFuture ...
  [15:45:59.158] - result already collected: FutureResult
  [15:45:59.158] result() for ClusterFuture ... done
  [15:45:59.158] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:59.159] result() for ClusterFuture ...
  [15:45:59.159] - result already collected: FutureResult
  [15:45:59.160] result() for ClusterFuture ... done
  [15:45:59.160] result() for ClusterFuture ...
  [15:45:59.161] - result already collected: FutureResult
  [15:45:59.161] result() for ClusterFuture ... done
  [15:45:59.164] ClusterFuture started
  <environment: 0x55ca2abe38e0> 
  <environment: 0x55ca2b1d8e38> 
  [15:45:59.216] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.216] - Validating connection of ClusterFuture
  [15:45:59.217] - received message: FutureResult
  [15:45:59.217] - Received FutureResult
  [15:45:59.218] - Erased future from FutureRegistry
  [15:45:59.218] result() for ClusterFuture ...
  [15:45:59.219] - result already collected: FutureResult
  [15:45:59.219] result() for ClusterFuture ... done
  [15:45:59.219] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:59.223] resolve() on environment ...
  [15:45:59.224]  recursive: 0
  [15:45:59.226]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:59.226] signalConditionsASAP(numeric, pos=1) ...
  [15:45:59.227] - nx: 4
  [15:45:59.227] - relay: TRUE
  [15:45:59.227] - stdout: TRUE
  [15:45:59.228] - signal: TRUE
  [15:45:59.228] - resignal: FALSE
  [15:45:59.228] - force: TRUE
  [15:45:59.229] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.229] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.229]  - until=2
  [15:45:59.230]  - relaying element #2
  [15:45:59.230] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:59.230] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.231] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:59.231]  length: 3 (resolved future 1)
  [15:45:59.231] Future #2
  [15:45:59.232] result() for ClusterFuture ...
  [15:45:59.232] - result already collected: FutureResult
  [15:45:59.233] result() for ClusterFuture ... done
  [15:45:59.233] result() for ClusterFuture ...
  [15:45:59.233] - result already collected: FutureResult
  [15:45:59.234] result() for ClusterFuture ... done
  [15:45:59.234] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:59.234] - nx: 4
  [15:45:59.235] - relay: TRUE
  [15:45:59.235] - stdout: TRUE
  [15:45:59.235] - signal: TRUE
  [15:45:59.236] - resignal: FALSE
  [15:45:59.236] - force: TRUE
  [15:45:59.236] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:59.237] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.237]  - until=2
  [15:45:59.237]  - relaying element #2
  [15:45:59.263] result() for ClusterFuture ...
  [15:45:59.263] - result already collected: FutureResult
  [15:45:59.263] result() for ClusterFuture ... done
  [15:45:59.264] result() for ClusterFuture ...
  [15:45:59.264] - result already collected: FutureResult
  [15:45:59.265] result() for ClusterFuture ... done
  [15:45:59.265] result() for ClusterFuture ...
  [15:45:59.265] - result already collected: FutureResult
  [15:45:59.266] result() for ClusterFuture ... done
  [15:45:59.266] result() for ClusterFuture ...
  [15:45:59.267] - result already collected: FutureResult
  [15:45:59.267] result() for ClusterFuture ... done
  [15:45:59.267] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:59.268] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:59.268] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:59.269]  length: 2 (resolved future 2)
  [15:45:59.269] Future #3
  [15:45:59.269] result() for ClusterFuture ...
  [15:45:59.270] - result already collected: FutureResult
  [15:45:59.270] result() for ClusterFuture ... done
  [15:45:59.270] result() for ClusterFuture ...
  [15:45:59.271] - result already collected: FutureResult
  [15:45:59.271] result() for ClusterFuture ... done
  [15:45:59.272] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:59.272] - nx: 4
  [15:45:59.272] - relay: TRUE
  [15:45:59.273] - stdout: TRUE
  [15:45:59.273] - signal: TRUE
  [15:45:59.273] - resignal: FALSE
  [15:45:59.273] - force: TRUE
  [15:45:59.274] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:59.274] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:59.275]  - until=3
  [15:45:59.275]  - relaying element #3
  [15:45:59.275] result() for ClusterFuture ...
  [15:45:59.276] - result already collected: FutureResult
  [15:45:59.276] result() for ClusterFuture ... done
  [15:45:59.276] result() for ClusterFuture ...
  [15:45:59.277] - result already collected: FutureResult
  [15:45:59.277] result() for ClusterFuture ... done
  [15:45:59.278] result() for ClusterFuture ...
  [15:45:59.278] - result already collected: FutureResult
  [15:45:59.278] result() for ClusterFuture ... done
  [15:45:59.295] result() for ClusterFuture ...
  [15:45:59.295] - result already collected: FutureResult
  [15:45:59.296] result() for ClusterFuture ... done
  [15:45:59.296] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:59.296] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:59.297] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:59.297]  length: 1 (resolved future 3)
  [15:45:59.298] Future #4
  [15:45:59.298] result() for ClusterFuture ...
  [15:45:59.299] - result already collected: FutureResult
  [15:45:59.299] result() for ClusterFuture ... done
  [15:45:59.299] result() for ClusterFuture ...
  [15:45:59.300] - result already collected: FutureResult
  [15:45:59.300] result() for ClusterFuture ... done
  [15:45:59.300] signalConditionsASAP(ClusterFuture, pos=4) ...
  [15:45:59.301] - nx: 4
  [15:45:59.301] - relay: TRUE
  [15:45:59.301] - stdout: TRUE
  [15:45:59.302] - signal: TRUE
  [15:45:59.302] - resignal: FALSE
  [15:45:59.302] - force: TRUE
  [15:45:59.303] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:59.303] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:59.304]  - until=4
  [15:45:59.304]  - relaying element #4
  [15:45:59.304] result() for ClusterFuture ...
  [15:45:59.305] - result already collected: FutureResult
  [15:45:59.305] result() for ClusterFuture ... done
  [15:45:59.305] result() for ClusterFuture ...
  [15:45:59.306] - result already collected: FutureResult
  [15:45:59.306] result() for ClusterFuture ... done
  [15:45:59.307] result() for ClusterFuture ...
  [15:45:59.307] - result already collected: FutureResult
  [15:45:59.307] result() for ClusterFuture ... done
  [15:45:59.308] result() for ClusterFuture ...
  [15:45:59.308] - result already collected: FutureResult
  [15:45:59.309] result() for ClusterFuture ... done
  [15:45:59.309] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.309] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:59.310] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [15:45:59.310]  length: 0 (resolved future 4)
  [15:45:59.326] Relaying remaining futures
  [15:45:59.327] signalConditionsASAP(NULL, pos=0) ...
  [15:45:59.327] - nx: 4
  [15:45:59.328] - relay: TRUE
  [15:45:59.328] - stdout: TRUE
  [15:45:59.328] - signal: TRUE
  [15:45:59.329] - resignal: FALSE
  [15:45:59.329] - force: TRUE
  [15:45:59.329] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.330] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:59.330] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.331] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:59.331] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:59.331] resolve() on environment ... DONE
  [15:45:59.332] result() for ClusterFuture ...
  [15:45:59.332] - result already collected: FutureResult
  [15:45:59.332] result() for ClusterFuture ... done
  [15:45:59.333] result() for ClusterFuture ...
  [15:45:59.333] - result already collected: FutureResult
  [15:45:59.333] result() for ClusterFuture ... done
  [15:45:59.334] result() for ClusterFuture ...
  [15:45:59.334] - result already collected: FutureResult
  [15:45:59.335] result() for ClusterFuture ... done
  [15:45:59.335] result() for ClusterFuture ...
  [15:45:59.335] - result already collected: FutureResult
  [15:45:59.336] result() for ClusterFuture ... done
  [15:45:59.336] result() for ClusterFuture ...
  [15:45:59.336] - result already collected: FutureResult
  [15:45:59.337] result() for ClusterFuture ... done
  [15:45:59.337] result() for ClusterFuture ...
  [15:45:59.337] - result already collected: FutureResult
  [15:45:59.338] result() for ClusterFuture ... done
  <environment: 0x55ca29693498> 
  Dimensions: c(2, 1, 3, 1)
  [15:45:59.339] getGlobalsAndPackages() ...
  [15:45:59.340] Searching for globals...
  [15:45:59.341] 
  [15:45:59.341] Searching for globals ... DONE
  [15:45:59.341] - globals: [0] <none>
  [15:45:59.342] getGlobalsAndPackages() ... DONE
  [15:45:59.357] Packages needed by the future expression (n = 0): <none>
  [15:45:59.357] Packages needed by future strategies (n = 0): <none>
  [15:45:59.380] {
  [15:45:59.380]     {
  [15:45:59.380]         ...future.startTime <- base::Sys.time()
  [15:45:59.380]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.380]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.380]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.380]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.380]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.380]         {
  [15:45:59.380]             {
  [15:45:59.380]                 base::local({
  [15:45:59.380]                   has_future <- base::requireNamespace("future", 
  [15:45:59.380]                     quietly = TRUE)
  [15:45:59.380]                   version <- if (has_future) 
  [15:45:59.380]                     utils::packageVersion("future")
  [15:45:59.380]                   else NULL
  [15:45:59.380]                   if (!has_future || version < "1.8.0") {
  [15:45:59.380]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.380]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.380]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.380]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.380]                         "release", "version")], collapse = " "), 
  [15:45:59.380]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.380]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.380]                       info)
  [15:45:59.380]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.380]                     if (!has_future) {
  [15:45:59.380]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.380]                         info)
  [15:45:59.380]                     }
  [15:45:59.380]                     else {
  [15:45:59.380]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.380]                         info, version)
  [15:45:59.380]                     }
  [15:45:59.380]                     base::stop(msg)
  [15:45:59.380]                   }
  [15:45:59.380]                 })
  [15:45:59.380]             }
  [15:45:59.380]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.380]         }
  [15:45:59.380]     }
  [15:45:59.380]     if (base::is.na(TRUE)) {
  [15:45:59.380]     }
  [15:45:59.380]     else {
  [15:45:59.380]         if (TRUE) {
  [15:45:59.380]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.380]                 open = "w")
  [15:45:59.380]         }
  [15:45:59.380]         else {
  [15:45:59.380]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.380]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.380]         }
  [15:45:59.380]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.380]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.380]             base::sink(type = "output", split = FALSE)
  [15:45:59.380]             base::close(...future.stdout)
  [15:45:59.380]         }, add = TRUE)
  [15:45:59.380]     }
  [15:45:59.380]     ...future.frame <- base::sys.nframe()
  [15:45:59.380]     ...future.conditions <- base::list()
  [15:45:59.380]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.380]     ...future.result <- base::tryCatch({
  [15:45:59.380]         base::withCallingHandlers({
  [15:45:59.380]             ...future.value <- base::withVisible(base::local({
  [15:45:59.380]                 ...future.sendCondition <- local({
  [15:45:59.380]                   sendCondition <- NULL
  [15:45:59.380]                   function(frame = 1L) {
  [15:45:59.380]                     if (is.function(sendCondition)) 
  [15:45:59.380]                       return(sendCondition)
  [15:45:59.380]                     ns <- getNamespace("parallel")
  [15:45:59.380]                     if (exists("sendData", mode = "function", 
  [15:45:59.380]                       envir = ns)) {
  [15:45:59.380]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.380]                         envir = ns)
  [15:45:59.380]                       envir <- sys.frame(frame)
  [15:45:59.380]                       master <- NULL
  [15:45:59.380]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.380]                         !identical(envir, emptyenv())) {
  [15:45:59.380]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.380]                           inherits = FALSE)) {
  [15:45:59.380]                           master <- get("master", mode = "list", 
  [15:45:59.380]                             envir = envir, inherits = FALSE)
  [15:45:59.380]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.380]                             sendCondition <<- function(cond) {
  [15:45:59.380]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.380]                                 success = TRUE)
  [15:45:59.380]                               parallel_sendData(master, data)
  [15:45:59.380]                             }
  [15:45:59.380]                             return(sendCondition)
  [15:45:59.380]                           }
  [15:45:59.380]                         }
  [15:45:59.380]                         frame <- frame + 1L
  [15:45:59.380]                         envir <- sys.frame(frame)
  [15:45:59.380]                       }
  [15:45:59.380]                     }
  [15:45:59.380]                     sendCondition <<- function(cond) NULL
  [15:45:59.380]                   }
  [15:45:59.380]                 })
  [15:45:59.380]                 withCallingHandlers({
  [15:45:59.380]                   2
  [15:45:59.380]                 }, immediateCondition = function(cond) {
  [15:45:59.380]                   sendCondition <- ...future.sendCondition()
  [15:45:59.380]                   sendCondition(cond)
  [15:45:59.380]                   muffleCondition <- function (cond) 
  [15:45:59.380]                   {
  [15:45:59.380]                     inherits <- base::inherits
  [15:45:59.380]                     invokeRestart <- base::invokeRestart
  [15:45:59.380]                     muffled <- FALSE
  [15:45:59.380]                     if (inherits(cond, "message")) {
  [15:45:59.380]                       invokeRestart("muffleMessage")
  [15:45:59.380]                       muffled <- TRUE
  [15:45:59.380]                     }
  [15:45:59.380]                     else if (inherits(cond, "warning")) {
  [15:45:59.380]                       invokeRestart("muffleWarning")
  [15:45:59.380]                       muffled <- TRUE
  [15:45:59.380]                     }
  [15:45:59.380]                     else if (inherits(cond, "condition")) {
  [15:45:59.380]                       computeRestarts <- base::computeRestarts
  [15:45:59.380]                       grepl <- base::grepl
  [15:45:59.380]                       is.null <- base::is.null
  [15:45:59.380]                       restarts <- computeRestarts(cond)
  [15:45:59.380]                       for (restart in restarts) {
  [15:45:59.380]                         name <- restart$name
  [15:45:59.380]                         if (is.null(name)) 
  [15:45:59.380]                           next
  [15:45:59.380]                         if (!grepl("^muffle", name)) 
  [15:45:59.380]                           next
  [15:45:59.380]                         invokeRestart(restart)
  [15:45:59.380]                         muffled <- TRUE
  [15:45:59.380]                         break
  [15:45:59.380]                       }
  [15:45:59.380]                     }
  [15:45:59.380]                     invisible(muffled)
  [15:45:59.380]                   }
  [15:45:59.380]                   muffleCondition(cond)
  [15:45:59.380]                 })
  [15:45:59.380]             }))
  [15:45:59.380]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.380]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.380]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.380]                 version = "1.8")
  [15:45:59.380]         }, condition = base::local({
  [15:45:59.380]             c <- base::c
  [15:45:59.380]             inherits <- base::inherits
  [15:45:59.380]             invokeRestart <- base::invokeRestart
  [15:45:59.380]             length <- base::length
  [15:45:59.380]             list <- base::list
  [15:45:59.380]             seq.int <- base::seq.int
  [15:45:59.380]             signalCondition <- base::signalCondition
  [15:45:59.380]             sys.calls <- base::sys.calls
  [15:45:59.380]             Sys.time <- base::Sys.time
  [15:45:59.380]             `[[` <- base::`[[`
  [15:45:59.380]             `+` <- base::`+`
  [15:45:59.380]             `<<-` <- base::`<<-`
  [15:45:59.380]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.380]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.380]                   3L)]
  [15:45:59.380]             }
  [15:45:59.380]             function(cond) {
  [15:45:59.380]                 if (inherits(cond, "error")) {
  [15:45:59.380]                   sessionInformation <- function() {
  [15:45:59.380]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.380]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.380]                       search = base::search(), system = base::Sys.info())
  [15:45:59.380]                   }
  [15:45:59.380]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.380]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.380]                     cond$call), session = sessionInformation(), 
  [15:45:59.380]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.380]                   signalCondition(cond)
  [15:45:59.380]                 }
  [15:45:59.380]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.380]                 ))) {
  [15:45:59.380]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.380]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.380]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.380]                   if (!signal) {
  [15:45:59.380]                     muffleCondition <- function (cond) 
  [15:45:59.380]                     {
  [15:45:59.380]                       inherits <- base::inherits
  [15:45:59.380]                       invokeRestart <- base::invokeRestart
  [15:45:59.380]                       muffled <- FALSE
  [15:45:59.380]                       if (inherits(cond, "message")) {
  [15:45:59.380]                         invokeRestart("muffleMessage")
  [15:45:59.380]                         muffled <- TRUE
  [15:45:59.380]                       }
  [15:45:59.380]                       else if (inherits(cond, "warning")) {
  [15:45:59.380]                         invokeRestart("muffleWarning")
  [15:45:59.380]                         muffled <- TRUE
  [15:45:59.380]                       }
  [15:45:59.380]                       else if (inherits(cond, "condition")) {
  [15:45:59.380]                         computeRestarts <- base::computeRestarts
  [15:45:59.380]                         grepl <- base::grepl
  [15:45:59.380]                         is.null <- base::is.null
  [15:45:59.380]                         restarts <- computeRestarts(cond)
  [15:45:59.380]                         for (restart in restarts) {
  [15:45:59.380]                           name <- restart$name
  [15:45:59.380]                           if (is.null(name)) 
  [15:45:59.380]                             next
  [15:45:59.380]                           if (!grepl("^muffle", name)) 
  [15:45:59.380]                             next
  [15:45:59.380]                           invokeRestart(restart)
  [15:45:59.380]                           muffled <- TRUE
  [15:45:59.380]                           break
  [15:45:59.380]                         }
  [15:45:59.380]                       }
  [15:45:59.380]                       invisible(muffled)
  [15:45:59.380]                     }
  [15:45:59.380]                     muffleCondition(cond)
  [15:45:59.380]                   }
  [15:45:59.380]                 }
  [15:45:59.380]             }
  [15:45:59.380]         }))
  [15:45:59.380]     }, error = function(ex) {
  [15:45:59.380]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.380]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.380]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.380]     }, finally = {
  [15:45:59.380]         {
  [15:45:59.380]             NULL
  [15:45:59.380]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.380]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.380]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.380]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.380]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.380]                 ...) 
  [15:45:59.380]             {
  [15:45:59.380]                 if (substitute) 
  [15:45:59.380]                   expr <- substitute(expr)
  [15:45:59.380]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.380]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.380]                   globals = globals, persistent = persistent, 
  [15:45:59.380]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.380]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.380]                   label = label, ...)
  [15:45:59.380]                 if (!future$lazy) 
  [15:45:59.380]                   future <- run(future)
  [15:45:59.380]                 invisible(future)
  [15:45:59.380]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.380]         }
  [15:45:59.380]         base::options(...future.oldOptions)
  [15:45:59.380]     })
  [15:45:59.380]     Sys.time
  [15:45:59.380]     if (base::is.na(TRUE)) {
  [15:45:59.380]     }
  [15:45:59.380]     else {
  [15:45:59.380]         base::sink(type = "output", split = FALSE)
  [15:45:59.380]         if (TRUE) {
  [15:45:59.380]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.380]         }
  [15:45:59.380]         else {
  [15:45:59.380]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.380]         }
  [15:45:59.380]         base::close(...future.stdout)
  [15:45:59.380]         ...future.stdout <- NULL
  [15:45:59.380]     }
  [15:45:59.380]     ...future.result$conditions <- ...future.conditions
  [15:45:59.380]     ...future.result
  [15:45:59.380] }
  [15:45:59.399] ClusterFuture started
  [15:45:59.399] getGlobalsAndPackages() ...
  [15:45:59.400] Searching for globals...
  [15:45:59.400] 
  [15:45:59.401] Searching for globals ... DONE
  [15:45:59.401] - globals: [0] <none>
  [15:45:59.402] getGlobalsAndPackages() ... DONE
  [15:45:59.408] Packages needed by the future expression (n = 0): <none>
  [15:45:59.408] Packages needed by future strategies (n = 0): <none>
  [15:45:59.415] {
  [15:45:59.415]     {
  [15:45:59.415]         ...future.startTime <- base::Sys.time()
  [15:45:59.415]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.415]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.415]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.415]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.415]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.415]         {
  [15:45:59.415]             {
  [15:45:59.415]                 base::local({
  [15:45:59.415]                   has_future <- base::requireNamespace("future", 
  [15:45:59.415]                     quietly = TRUE)
  [15:45:59.415]                   version <- if (has_future) 
  [15:45:59.415]                     utils::packageVersion("future")
  [15:45:59.415]                   else NULL
  [15:45:59.415]                   if (!has_future || version < "1.8.0") {
  [15:45:59.415]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.415]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.415]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.415]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.415]                         "release", "version")], collapse = " "), 
  [15:45:59.415]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.415]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.415]                       info)
  [15:45:59.415]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.415]                     if (!has_future) {
  [15:45:59.415]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.415]                         info)
  [15:45:59.415]                     }
  [15:45:59.415]                     else {
  [15:45:59.415]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.415]                         info, version)
  [15:45:59.415]                     }
  [15:45:59.415]                     base::stop(msg)
  [15:45:59.415]                   }
  [15:45:59.415]                 })
  [15:45:59.415]             }
  [15:45:59.415]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.415]         }
  [15:45:59.415]     }
  [15:45:59.415]     if (base::is.na(TRUE)) {
  [15:45:59.415]     }
  [15:45:59.415]     else {
  [15:45:59.415]         if (TRUE) {
  [15:45:59.415]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.415]                 open = "w")
  [15:45:59.415]         }
  [15:45:59.415]         else {
  [15:45:59.415]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.415]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.415]         }
  [15:45:59.415]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.415]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.415]             base::sink(type = "output", split = FALSE)
  [15:45:59.415]             base::close(...future.stdout)
  [15:45:59.415]         }, add = TRUE)
  [15:45:59.415]     }
  [15:45:59.415]     ...future.frame <- base::sys.nframe()
  [15:45:59.415]     ...future.conditions <- base::list()
  [15:45:59.415]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.415]     ...future.result <- base::tryCatch({
  [15:45:59.415]         base::withCallingHandlers({
  [15:45:59.415]             ...future.value <- base::withVisible(base::local({
  [15:45:59.415]                 ...future.sendCondition <- local({
  [15:45:59.415]                   sendCondition <- NULL
  [15:45:59.415]                   function(frame = 1L) {
  [15:45:59.415]                     if (is.function(sendCondition)) 
  [15:45:59.415]                       return(sendCondition)
  [15:45:59.415]                     ns <- getNamespace("parallel")
  [15:45:59.415]                     if (exists("sendData", mode = "function", 
  [15:45:59.415]                       envir = ns)) {
  [15:45:59.415]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.415]                         envir = ns)
  [15:45:59.415]                       envir <- sys.frame(frame)
  [15:45:59.415]                       master <- NULL
  [15:45:59.415]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.415]                         !identical(envir, emptyenv())) {
  [15:45:59.415]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.415]                           inherits = FALSE)) {
  [15:45:59.415]                           master <- get("master", mode = "list", 
  [15:45:59.415]                             envir = envir, inherits = FALSE)
  [15:45:59.415]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.415]                             sendCondition <<- function(cond) {
  [15:45:59.415]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.415]                                 success = TRUE)
  [15:45:59.415]                               parallel_sendData(master, data)
  [15:45:59.415]                             }
  [15:45:59.415]                             return(sendCondition)
  [15:45:59.415]                           }
  [15:45:59.415]                         }
  [15:45:59.415]                         frame <- frame + 1L
  [15:45:59.415]                         envir <- sys.frame(frame)
  [15:45:59.415]                       }
  [15:45:59.415]                     }
  [15:45:59.415]                     sendCondition <<- function(cond) NULL
  [15:45:59.415]                   }
  [15:45:59.415]                 })
  [15:45:59.415]                 withCallingHandlers({
  [15:45:59.415]                   NULL
  [15:45:59.415]                 }, immediateCondition = function(cond) {
  [15:45:59.415]                   sendCondition <- ...future.sendCondition()
  [15:45:59.415]                   sendCondition(cond)
  [15:45:59.415]                   muffleCondition <- function (cond) 
  [15:45:59.415]                   {
  [15:45:59.415]                     inherits <- base::inherits
  [15:45:59.415]                     invokeRestart <- base::invokeRestart
  [15:45:59.415]                     muffled <- FALSE
  [15:45:59.415]                     if (inherits(cond, "message")) {
  [15:45:59.415]                       invokeRestart("muffleMessage")
  [15:45:59.415]                       muffled <- TRUE
  [15:45:59.415]                     }
  [15:45:59.415]                     else if (inherits(cond, "warning")) {
  [15:45:59.415]                       invokeRestart("muffleWarning")
  [15:45:59.415]                       muffled <- TRUE
  [15:45:59.415]                     }
  [15:45:59.415]                     else if (inherits(cond, "condition")) {
  [15:45:59.415]                       computeRestarts <- base::computeRestarts
  [15:45:59.415]                       grepl <- base::grepl
  [15:45:59.415]                       is.null <- base::is.null
  [15:45:59.415]                       restarts <- computeRestarts(cond)
  [15:45:59.415]                       for (restart in restarts) {
  [15:45:59.415]                         name <- restart$name
  [15:45:59.415]                         if (is.null(name)) 
  [15:45:59.415]                           next
  [15:45:59.415]                         if (!grepl("^muffle", name)) 
  [15:45:59.415]                           next
  [15:45:59.415]                         invokeRestart(restart)
  [15:45:59.415]                         muffled <- TRUE
  [15:45:59.415]                         break
  [15:45:59.415]                       }
  [15:45:59.415]                     }
  [15:45:59.415]                     invisible(muffled)
  [15:45:59.415]                   }
  [15:45:59.415]                   muffleCondition(cond)
  [15:45:59.415]                 })
  [15:45:59.415]             }))
  [15:45:59.415]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.415]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.415]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.415]                 version = "1.8")
  [15:45:59.415]         }, condition = base::local({
  [15:45:59.415]             c <- base::c
  [15:45:59.415]             inherits <- base::inherits
  [15:45:59.415]             invokeRestart <- base::invokeRestart
  [15:45:59.415]             length <- base::length
  [15:45:59.415]             list <- base::list
  [15:45:59.415]             seq.int <- base::seq.int
  [15:45:59.415]             signalCondition <- base::signalCondition
  [15:45:59.415]             sys.calls <- base::sys.calls
  [15:45:59.415]             Sys.time <- base::Sys.time
  [15:45:59.415]             `[[` <- base::`[[`
  [15:45:59.415]             `+` <- base::`+`
  [15:45:59.415]             `<<-` <- base::`<<-`
  [15:45:59.415]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.415]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.415]                   3L)]
  [15:45:59.415]             }
  [15:45:59.415]             function(cond) {
  [15:45:59.415]                 if (inherits(cond, "error")) {
  [15:45:59.415]                   sessionInformation <- function() {
  [15:45:59.415]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.415]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.415]                       search = base::search(), system = base::Sys.info())
  [15:45:59.415]                   }
  [15:45:59.415]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.415]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.415]                     cond$call), session = sessionInformation(), 
  [15:45:59.415]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.415]                   signalCondition(cond)
  [15:45:59.415]                 }
  [15:45:59.415]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.415]                 ))) {
  [15:45:59.415]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.415]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.415]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.415]                   if (!signal) {
  [15:45:59.415]                     muffleCondition <- function (cond) 
  [15:45:59.415]                     {
  [15:45:59.415]                       inherits <- base::inherits
  [15:45:59.415]                       invokeRestart <- base::invokeRestart
  [15:45:59.415]                       muffled <- FALSE
  [15:45:59.415]                       if (inherits(cond, "message")) {
  [15:45:59.415]                         invokeRestart("muffleMessage")
  [15:45:59.415]                         muffled <- TRUE
  [15:45:59.415]                       }
  [15:45:59.415]                       else if (inherits(cond, "warning")) {
  [15:45:59.415]                         invokeRestart("muffleWarning")
  [15:45:59.415]                         muffled <- TRUE
  [15:45:59.415]                       }
  [15:45:59.415]                       else if (inherits(cond, "condition")) {
  [15:45:59.415]                         computeRestarts <- base::computeRestarts
  [15:45:59.415]                         grepl <- base::grepl
  [15:45:59.415]                         is.null <- base::is.null
  [15:45:59.415]                         restarts <- computeRestarts(cond)
  [15:45:59.415]                         for (restart in restarts) {
  [15:45:59.415]                           name <- restart$name
  [15:45:59.415]                           if (is.null(name)) 
  [15:45:59.415]                             next
  [15:45:59.415]                           if (!grepl("^muffle", name)) 
  [15:45:59.415]                             next
  [15:45:59.415]                           invokeRestart(restart)
  [15:45:59.415]                           muffled <- TRUE
  [15:45:59.415]                           break
  [15:45:59.415]                         }
  [15:45:59.415]                       }
  [15:45:59.415]                       invisible(muffled)
  [15:45:59.415]                     }
  [15:45:59.415]                     muffleCondition(cond)
  [15:45:59.415]                   }
  [15:45:59.415]                 }
  [15:45:59.415]             }
  [15:45:59.415]         }))
  [15:45:59.415]     }, error = function(ex) {
  [15:45:59.415]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.415]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.415]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.415]     }, finally = {
  [15:45:59.415]         {
  [15:45:59.415]             NULL
  [15:45:59.415]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.415]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.415]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.415]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.415]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.415]                 ...) 
  [15:45:59.415]             {
  [15:45:59.415]                 if (substitute) 
  [15:45:59.415]                   expr <- substitute(expr)
  [15:45:59.415]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.415]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.415]                   globals = globals, persistent = persistent, 
  [15:45:59.415]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.415]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.415]                   label = label, ...)
  [15:45:59.415]                 if (!future$lazy) 
  [15:45:59.415]                   future <- run(future)
  [15:45:59.415]                 invisible(future)
  [15:45:59.415]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.415]         }
  [15:45:59.415]         base::options(...future.oldOptions)
  [15:45:59.415]     })
  [15:45:59.415]     Sys.time
  [15:45:59.415]     if (base::is.na(TRUE)) {
  [15:45:59.415]     }
  [15:45:59.415]     else {
  [15:45:59.415]         base::sink(type = "output", split = FALSE)
  [15:45:59.415]         if (TRUE) {
  [15:45:59.415]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.415]         }
  [15:45:59.415]         else {
  [15:45:59.415]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.415]         }
  [15:45:59.415]         base::close(...future.stdout)
  [15:45:59.415]         ...future.stdout <- NULL
  [15:45:59.415]     }
  [15:45:59.415]     ...future.result$conditions <- ...future.conditions
  [15:45:59.415]     ...future.result
  [15:45:59.415] }
  [15:45:59.420] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:59.444] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.444] - Validating connection of ClusterFuture
  [15:45:59.445] - received message: FutureResult
  [15:45:59.445] - Received FutureResult
  [15:45:59.445] - Erased future from FutureRegistry
  [15:45:59.446] result() for ClusterFuture ...
  [15:45:59.446] - result already collected: FutureResult
  [15:45:59.447] result() for ClusterFuture ... done
  [15:45:59.447] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:59.448] result() for ClusterFuture ...
  [15:45:59.448] - result already collected: FutureResult
  [15:45:59.448] result() for ClusterFuture ... done
  [15:45:59.449] result() for ClusterFuture ...
  [15:45:59.449] - result already collected: FutureResult
  [15:45:59.450] result() for ClusterFuture ... done
  [15:45:59.452] ClusterFuture started
  [15:45:59.454] getGlobalsAndPackages() ...
  [15:45:59.454] Searching for globals...
  [15:45:59.456] - globals found: [1] '{'
  [15:45:59.456] Searching for globals ... DONE
  [15:45:59.457] Resolving globals: FALSE
  [15:45:59.458] 
  [15:45:59.458] 
  [15:45:59.459] getGlobalsAndPackages() ... DONE
  [15:45:59.465] Packages needed by the future expression (n = 0): <none>
  [15:45:59.466] Packages needed by future strategies (n = 0): <none>
  [15:45:59.472] {
  [15:45:59.472]     {
  [15:45:59.472]         ...future.startTime <- base::Sys.time()
  [15:45:59.472]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.472]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.472]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.472]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.472]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.472]         {
  [15:45:59.472]             {
  [15:45:59.472]                 base::local({
  [15:45:59.472]                   has_future <- base::requireNamespace("future", 
  [15:45:59.472]                     quietly = TRUE)
  [15:45:59.472]                   version <- if (has_future) 
  [15:45:59.472]                     utils::packageVersion("future")
  [15:45:59.472]                   else NULL
  [15:45:59.472]                   if (!has_future || version < "1.8.0") {
  [15:45:59.472]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.472]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.472]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.472]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.472]                         "release", "version")], collapse = " "), 
  [15:45:59.472]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.472]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.472]                       info)
  [15:45:59.472]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.472]                     if (!has_future) {
  [15:45:59.472]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.472]                         info)
  [15:45:59.472]                     }
  [15:45:59.472]                     else {
  [15:45:59.472]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.472]                         info, version)
  [15:45:59.472]                     }
  [15:45:59.472]                     base::stop(msg)
  [15:45:59.472]                   }
  [15:45:59.472]                 })
  [15:45:59.472]             }
  [15:45:59.472]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.472]         }
  [15:45:59.472]     }
  [15:45:59.472]     if (base::is.na(TRUE)) {
  [15:45:59.472]     }
  [15:45:59.472]     else {
  [15:45:59.472]         if (TRUE) {
  [15:45:59.472]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.472]                 open = "w")
  [15:45:59.472]         }
  [15:45:59.472]         else {
  [15:45:59.472]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.472]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.472]         }
  [15:45:59.472]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.472]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.472]             base::sink(type = "output", split = FALSE)
  [15:45:59.472]             base::close(...future.stdout)
  [15:45:59.472]         }, add = TRUE)
  [15:45:59.472]     }
  [15:45:59.472]     ...future.frame <- base::sys.nframe()
  [15:45:59.472]     ...future.conditions <- base::list()
  [15:45:59.472]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.472]     ...future.result <- base::tryCatch({
  [15:45:59.472]         base::withCallingHandlers({
  [15:45:59.472]             ...future.value <- base::withVisible(base::local({
  [15:45:59.472]                 ...future.sendCondition <- local({
  [15:45:59.472]                   sendCondition <- NULL
  [15:45:59.472]                   function(frame = 1L) {
  [15:45:59.472]                     if (is.function(sendCondition)) 
  [15:45:59.472]                       return(sendCondition)
  [15:45:59.472]                     ns <- getNamespace("parallel")
  [15:45:59.472]                     if (exists("sendData", mode = "function", 
  [15:45:59.472]                       envir = ns)) {
  [15:45:59.472]                       parallel_sendData <- get("sendData", mode = "function", 
  [15:45:59.472]                         envir = ns)
  [15:45:59.472]                       envir <- sys.frame(frame)
  [15:45:59.472]                       master <- NULL
  [15:45:59.472]                       while (!identical(envir, .GlobalEnv) && 
  [15:45:59.472]                         !identical(envir, emptyenv())) {
  [15:45:59.472]                         if (exists("master", mode = "list", envir = envir, 
  [15:45:59.472]                           inherits = FALSE)) {
  [15:45:59.472]                           master <- get("master", mode = "list", 
  [15:45:59.472]                             envir = envir, inherits = FALSE)
  [15:45:59.472]                           if (inherits(master, "SOCKnode")) {
  [15:45:59.472]                             sendCondition <<- function(cond) {
  [15:45:59.472]                               data <- list(type = "VALUE", value = cond, 
  [15:45:59.472]                                 success = TRUE)
  [15:45:59.472]                               parallel_sendData(master, data)
  [15:45:59.472]                             }
  [15:45:59.472]                             return(sendCondition)
  [15:45:59.472]                           }
  [15:45:59.472]                         }
  [15:45:59.472]                         frame <- frame + 1L
  [15:45:59.472]                         envir <- sys.frame(frame)
  [15:45:59.472]                       }
  [15:45:59.472]                     }
  [15:45:59.472]                     sendCondition <<- function(cond) NULL
  [15:45:59.472]                   }
  [15:45:59.472]                 })
  [15:45:59.472]                 withCallingHandlers({
  [15:45:59.472]                   {
  [15:45:59.472]                     4
  [15:45:59.472]                   }
  [15:45:59.472]                 }, immediateCondition = function(cond) {
  [15:45:59.472]                   sendCondition <- ...future.sendCondition()
  [15:45:59.472]                   sendCondition(cond)
  [15:45:59.472]                   muffleCondition <- function (cond) 
  [15:45:59.472]                   {
  [15:45:59.472]                     inherits <- base::inherits
  [15:45:59.472]                     invokeRestart <- base::invokeRestart
  [15:45:59.472]                     muffled <- FALSE
  [15:45:59.472]                     if (inherits(cond, "message")) {
  [15:45:59.472]                       invokeRestart("muffleMessage")
  [15:45:59.472]                       muffled <- TRUE
  [15:45:59.472]                     }
  [15:45:59.472]                     else if (inherits(cond, "warning")) {
  [15:45:59.472]                       invokeRestart("muffleWarning")
  [15:45:59.472]                       muffled <- TRUE
  [15:45:59.472]                     }
  [15:45:59.472]                     else if (inherits(cond, "condition")) {
  [15:45:59.472]                       computeRestarts <- base::computeRestarts
  [15:45:59.472]                       grepl <- base::grepl
  [15:45:59.472]                       is.null <- base::is.null
  [15:45:59.472]                       restarts <- computeRestarts(cond)
  [15:45:59.472]                       for (restart in restarts) {
  [15:45:59.472]                         name <- restart$name
  [15:45:59.472]                         if (is.null(name)) 
  [15:45:59.472]                           next
  [15:45:59.472]                         if (!grepl("^muffle", name)) 
  [15:45:59.472]                           next
  [15:45:59.472]                         invokeRestart(restart)
  [15:45:59.472]                         muffled <- TRUE
  [15:45:59.472]                         break
  [15:45:59.472]                       }
  [15:45:59.472]                     }
  [15:45:59.472]                     invisible(muffled)
  [15:45:59.472]                   }
  [15:45:59.472]                   muffleCondition(cond)
  [15:45:59.472]                 })
  [15:45:59.472]             }))
  [15:45:59.472]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.472]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.472]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.472]                 version = "1.8")
  [15:45:59.472]         }, condition = base::local({
  [15:45:59.472]             c <- base::c
  [15:45:59.472]             inherits <- base::inherits
  [15:45:59.472]             invokeRestart <- base::invokeRestart
  [15:45:59.472]             length <- base::length
  [15:45:59.472]             list <- base::list
  [15:45:59.472]             seq.int <- base::seq.int
  [15:45:59.472]             signalCondition <- base::signalCondition
  [15:45:59.472]             sys.calls <- base::sys.calls
  [15:45:59.472]             Sys.time <- base::Sys.time
  [15:45:59.472]             `[[` <- base::`[[`
  [15:45:59.472]             `+` <- base::`+`
  [15:45:59.472]             `<<-` <- base::`<<-`
  [15:45:59.472]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.472]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.472]                   3L)]
  [15:45:59.472]             }
  [15:45:59.472]             function(cond) {
  [15:45:59.472]                 if (inherits(cond, "error")) {
  [15:45:59.472]                   sessionInformation <- function() {
  [15:45:59.472]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.472]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.472]                       search = base::search(), system = base::Sys.info())
  [15:45:59.472]                   }
  [15:45:59.472]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.472]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.472]                     cond$call), session = sessionInformation(), 
  [15:45:59.472]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.472]                   signalCondition(cond)
  [15:45:59.472]                 }
  [15:45:59.472]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.472]                 ))) {
  [15:45:59.472]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.472]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.472]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.472]                   if (!signal) {
  [15:45:59.472]                     muffleCondition <- function (cond) 
  [15:45:59.472]                     {
  [15:45:59.472]                       inherits <- base::inherits
  [15:45:59.472]                       invokeRestart <- base::invokeRestart
  [15:45:59.472]                       muffled <- FALSE
  [15:45:59.472]                       if (inherits(cond, "message")) {
  [15:45:59.472]                         invokeRestart("muffleMessage")
  [15:45:59.472]                         muffled <- TRUE
  [15:45:59.472]                       }
  [15:45:59.472]                       else if (inherits(cond, "warning")) {
  [15:45:59.472]                         invokeRestart("muffleWarning")
  [15:45:59.472]                         muffled <- TRUE
  [15:45:59.472]                       }
  [15:45:59.472]                       else if (inherits(cond, "condition")) {
  [15:45:59.472]                         computeRestarts <- base::computeRestarts
  [15:45:59.472]                         grepl <- base::grepl
  [15:45:59.472]                         is.null <- base::is.null
  [15:45:59.472]                         restarts <- computeRestarts(cond)
  [15:45:59.472]                         for (restart in restarts) {
  [15:45:59.472]                           name <- restart$name
  [15:45:59.472]                           if (is.null(name)) 
  [15:45:59.472]                             next
  [15:45:59.472]                           if (!grepl("^muffle", name)) 
  [15:45:59.472]                             next
  [15:45:59.472]                           invokeRestart(restart)
  [15:45:59.472]                           muffled <- TRUE
  [15:45:59.472]                           break
  [15:45:59.472]                         }
  [15:45:59.472]                       }
  [15:45:59.472]                       invisible(muffled)
  [15:45:59.472]                     }
  [15:45:59.472]                     muffleCondition(cond)
  [15:45:59.472]                   }
  [15:45:59.472]                 }
  [15:45:59.472]             }
  [15:45:59.472]         }))
  [15:45:59.472]     }, error = function(ex) {
  [15:45:59.472]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.472]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.472]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.472]     }, finally = {
  [15:45:59.472]         {
  [15:45:59.472]             NULL
  [15:45:59.472]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.472]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.472]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [15:45:59.472]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [15:45:59.472]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [15:45:59.472]                 ...) 
  [15:45:59.472]             {
  [15:45:59.472]                 if (substitute) 
  [15:45:59.472]                   expr <- substitute(expr)
  [15:45:59.472]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [15:45:59.472]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.472]                   globals = globals, persistent = persistent, 
  [15:45:59.472]                   workers = workers, user = user, revtunnel = revtunnel, 
  [15:45:59.472]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [15:45:59.472]                   label = label, ...)
  [15:45:59.472]                 if (!future$lazy) 
  [15:45:59.472]                   future <- run(future)
  [15:45:59.472]                 invisible(future)
  [15:45:59.472]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.472]         }
  [15:45:59.472]         base::options(...future.oldOptions)
  [15:45:59.472]     })
  [15:45:59.472]     Sys.time
  [15:45:59.472]     if (base::is.na(TRUE)) {
  [15:45:59.472]     }
  [15:45:59.472]     else {
  [15:45:59.472]         base::sink(type = "output", split = FALSE)
  [15:45:59.472]         if (TRUE) {
  [15:45:59.472]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.472]         }
  [15:45:59.472]         else {
  [15:45:59.472]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.472]         }
  [15:45:59.472]         base::close(...future.stdout)
  [15:45:59.472]         ...future.stdout <- NULL
  [15:45:59.472]     }
  [15:45:59.472]     ...future.result$conditions <- ...future.conditions
  [15:45:59.472]     ...future.result
  [15:45:59.472] }
  [15:45:59.478] Poll #1 (0): usedNodes() = 1, workers = 1
  [15:45:59.500] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.500] - Validating connection of ClusterFuture
  [15:45:59.501] - received message: FutureResult
  [15:45:59.501] - Received FutureResult
  [15:45:59.502] - Erased future from FutureRegistry
  [15:45:59.502] result() for ClusterFuture ...
  [15:45:59.503] - result already collected: FutureResult
  [15:45:59.503] result() for ClusterFuture ... done
  [15:45:59.503] receiveMessageFromWorker() for ClusterFuture ... done
  [15:45:59.504] result() for ClusterFuture ...
  [15:45:59.504] - result already collected: FutureResult
  [15:45:59.505] result() for ClusterFuture ... done
  [15:45:59.509] result() for ClusterFuture ...
  [15:45:59.510] - result already collected: FutureResult
  [15:45:59.510] result() for ClusterFuture ... done
  [15:45:59.528] ClusterFuture started
  <environment: 0x55ca2ac14fe8> 
  <environment: 0x55ca2b16dc28> 
  [15:45:59.576] receiveMessageFromWorker() for ClusterFuture ...
  [15:45:59.576] - Validating connection of ClusterFuture
  [15:45:59.577] - received message: FutureResult
  [15:45:59.577] - Received FutureResult
  [15:45:59.578] - Erased future from FutureRegistry
  [15:45:59.578] result() for ClusterFuture ...
  [15:45:59.578] - result already collected: FutureResult
  [15:45:59.579] result() for ClusterFuture ... done
  [15:45:59.579] receiveMessageFromWorker() for ClusterFuture ... done
   Named logi [1:4] TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:4] "a" "b" "c" "d"
  [15:45:59.583] resolve() on environment ...
  [15:45:59.583]  recursive: 0
  [15:45:59.585]  elements: [4] 'a', 'b', 'c', 'd'
  [15:45:59.585] signalConditionsASAP(numeric, pos=1) ...
  [15:45:59.586] - nx: 4
  [15:45:59.586] - relay: TRUE
  [15:45:59.586] - stdout: TRUE
  [15:45:59.587] - signal: TRUE
  [15:45:59.587] - resignal: FALSE
  [15:45:59.587] - force: TRUE
  [15:45:59.588] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.588] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.588]  - until=2
  [15:45:59.589]  - relaying element #2
  [15:45:59.589] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:59.589] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.590] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:59.590]  length: 3 (resolved future 1)
  [15:45:59.599] Future #2
  [15:45:59.599] result() for ClusterFuture ...
  [15:45:59.600] - result already collected: FutureResult
  [15:45:59.600] result() for ClusterFuture ... done
  [15:45:59.600] result() for ClusterFuture ...
  [15:45:59.601] - result already collected: FutureResult
  [15:45:59.601] result() for ClusterFuture ... done
  [15:45:59.601] signalConditionsASAP(ClusterFuture, pos=2) ...
  [15:45:59.602] - nx: 4
  [15:45:59.602] - relay: TRUE
  [15:45:59.602] - stdout: TRUE
  [15:45:59.603] - signal: TRUE
  [15:45:59.603] - resignal: FALSE
  [15:45:59.603] - force: TRUE
  [15:45:59.604] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [15:45:59.604] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [15:45:59.605]  - until=2
  [15:45:59.605]  - relaying element #2
  [15:45:59.605] result() for ClusterFuture ...
  [15:45:59.606] - result already collected: FutureResult
  [15:45:59.606] result() for ClusterFuture ... done
  [15:45:59.606] result() for ClusterFuture ...
  [15:45:59.607] - result already collected: FutureResult
  [15:45:59.607] result() for ClusterFuture ... done
  [15:45:59.608] result() for ClusterFuture ...
  [15:45:59.608] - result already collected: FutureResult
  [15:45:59.608] result() for ClusterFuture ... done
  [15:45:59.609] result() for ClusterFuture ...
  [15:45:59.609] - result already collected: FutureResult
  [15:45:59.610] result() for ClusterFuture ... done
  [15:45:59.610] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:59.610] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:59.611] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [15:45:59.611]  length: 2 (resolved future 2)
  [15:45:59.611] Future #3
  [15:45:59.612] result() for ClusterFuture ...
  [15:45:59.612] - result already collected: FutureResult
  [15:45:59.612] result() for ClusterFuture ... done
  [15:45:59.613] result() for ClusterFuture ...
  [15:45:59.613] - result already collected: FutureResult
  [15:45:59.614] result() for ClusterFuture ... done
  [15:45:59.614] signalConditionsASAP(ClusterFuture, pos=3) ...
  [15:45:59.614] - nx: 4
  [15:45:59.615] - relay: TRUE
  [15:45:59.615] - stdout: TRUE
  [15:45:59.615] - signal: TRUE
  [15:45:59.616] - resignal: FALSE
  [15:45:59.616] - force: TRUE
  [15:45:59.616] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [15:45:59.617] - queued futures: [n=4] FALSE, TRUE, FALSE, FALSE
  [15:45:59.617]  - until=3
  [15:45:59.617]  - relaying element #3
  [15:45:59.618] result() for ClusterFuture ...
  [15:45:59.618] - result already collected: FutureResult
  [15:45:59.618] result() for ClusterFuture ... done
  [15:45:59.619] result() for ClusterFuture ...
  [15:45:59.619] - result already collected: FutureResult
  [15:45:59.620] result() for ClusterFuture ... done
  [15:45:59.620] result() for ClusterFuture ...
  [15:45:59.620] - result already collected: FutureResult
  [15:45:59.621] result() for ClusterFuture ... done
  [15:45:59.621] result() for ClusterFuture ...
  [15:45:59.621] - result already collected: FutureResult
  [15:45:59.622] result() for ClusterFuture ... done
  [15:45:59.622] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:59.622] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:59.623] signalConditionsASAP(ClusterFuture, pos=3) ... done
  [15:45:59.623]  length: 1 (resolved future 3)
  [15:45:59.624] Future #4
  [15:45:59.624] result() for ClusterFuture ...
  [15:45:59.624] - result already collected: FutureResult
  [15:45:59.625] result() for ClusterFuture ... done
  [15:45:59.625] result() for ClusterFuture ...
  [15:45:59.625] - result already collected: FutureResult
  [15:45:59.626] result() for ClusterFuture ... done
  [15:45:59.626] signalConditionsASAP(ClusterFuture, pos=4) ...
  [15:45:59.626] - nx: 4
  [15:45:59.627] - relay: TRUE
  [15:45:59.627] - stdout: TRUE
  [15:45:59.627] - signal: TRUE
  [15:45:59.628] - resignal: FALSE
  [15:45:59.628] - force: TRUE
  [15:45:59.628] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [15:45:59.629] - queued futures: [n=4] FALSE, TRUE, TRUE, FALSE
  [15:45:59.629]  - until=4
  [15:45:59.629]  - relaying element #4
  [15:45:59.630] result() for ClusterFuture ...
  [15:45:59.630] - result already collected: FutureResult
  [15:45:59.630] result() for ClusterFuture ... done
  [15:45:59.631] result() for ClusterFuture ...
  [15:45:59.631] - result already collected: FutureResult
  [15:45:59.632] result() for ClusterFuture ... done
  [15:45:59.632] result() for ClusterFuture ...
  [15:45:59.632] - result already collected: FutureResult
  [15:45:59.633] result() for ClusterFuture ... done
  [15:45:59.633] result() for ClusterFuture ...
  [15:45:59.633] - result already collected: FutureResult
  [15:45:59.634] result() for ClusterFuture ... done
  [15:45:59.634] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.635] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:59.635] signalConditionsASAP(ClusterFuture, pos=4) ... done
  [15:45:59.635]  length: 0 (resolved future 4)
  [15:45:59.636] Relaying remaining futures
  [15:45:59.636] signalConditionsASAP(NULL, pos=0) ...
  [15:45:59.636] - nx: 4
  [15:45:59.637] - relay: TRUE
  [15:45:59.637] - stdout: TRUE
  [15:45:59.637] - signal: TRUE
  [15:45:59.638] - resignal: FALSE
  [15:45:59.638] - force: TRUE
  [15:45:59.638] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.639] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
   - flush all
  [15:45:59.639] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [15:45:59.639] - queued futures: [n=4] FALSE, TRUE, TRUE, TRUE
  [15:45:59.640] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:59.640] resolve() on environment ... DONE
  [15:45:59.641] result() for ClusterFuture ...
  [15:45:59.641] - result already collected: FutureResult
  [15:45:59.641] result() for ClusterFuture ... done
  [15:45:59.642] result() for ClusterFuture ...
  [15:45:59.642] - result already collected: FutureResult
  [15:45:59.642] result() for ClusterFuture ... done
  [15:45:59.643] result() for ClusterFuture ...
  [15:45:59.643] - result already collected: FutureResult
  [15:45:59.643] result() for ClusterFuture ... done
  [15:45:59.644] result() for ClusterFuture ...
  [15:45:59.644] - result already collected: FutureResult
  [15:45:59.644] result() for ClusterFuture ... done
  [15:45:59.645] result() for ClusterFuture ...
  [15:45:59.645] - result already collected: FutureResult
  [15:45:59.645] result() for ClusterFuture ... done
  [15:45:59.646] result() for ClusterFuture ...
  [15:45:59.646] - result already collected: FutureResult
  [15:45:59.647] result() for ClusterFuture ... done
  <environment: 0x55ca29291510> 
  *** futures() - environment ... DONE
  Type of object: listenv
  Type of future: sequential
  [15:45:59.649] plan(): Setting new future strategy stack:
  [15:45:59.649] List of future strategies:
  [15:45:59.649] 1. sequential:
  [15:45:59.649]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.649]    - tweaked: FALSE
  [15:45:59.649]    - call: plan(strategy)
  [15:45:59.650] plan(): nbrOfWorkers() = 1
  Dimensions: NULL
  [15:45:59.655] getGlobalsAndPackages() ...
  [15:45:59.655] Searching for globals...
  [15:45:59.656] 
  [15:45:59.657] Searching for globals ... DONE
  [15:45:59.657] - globals: [0] <none>
  [15:45:59.657] getGlobalsAndPackages() ... DONE
  [15:45:59.660] Packages needed by the future expression (n = 0): <none>
  [15:45:59.660] Packages needed by future strategies (n = 0): <none>
  [15:45:59.668] {
  [15:45:59.668]     {
  [15:45:59.668]         ...future.startTime <- base::Sys.time()
  [15:45:59.668]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.668]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.668]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.668]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.668]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.668]         {
  [15:45:59.668]             {
  [15:45:59.668]                 base::local({
  [15:45:59.668]                   has_future <- base::requireNamespace("future", 
  [15:45:59.668]                     quietly = TRUE)
  [15:45:59.668]                   version <- if (has_future) 
  [15:45:59.668]                     utils::packageVersion("future")
  [15:45:59.668]                   else NULL
  [15:45:59.668]                   if (!has_future || version < "1.8.0") {
  [15:45:59.668]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.668]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.668]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.668]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.668]                         "release", "version")], collapse = " "), 
  [15:45:59.668]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.668]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.668]                       info)
  [15:45:59.668]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.668]                     if (!has_future) {
  [15:45:59.668]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.668]                         info)
  [15:45:59.668]                     }
  [15:45:59.668]                     else {
  [15:45:59.668]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.668]                         info, version)
  [15:45:59.668]                     }
  [15:45:59.668]                     base::stop(msg)
  [15:45:59.668]                   }
  [15:45:59.668]                 })
  [15:45:59.668]             }
  [15:45:59.668]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.668]         }
  [15:45:59.668]     }
  [15:45:59.668]     if (base::is.na(TRUE)) {
  [15:45:59.668]     }
  [15:45:59.668]     else {
  [15:45:59.668]         if (TRUE) {
  [15:45:59.668]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.668]                 open = "w")
  [15:45:59.668]         }
  [15:45:59.668]         else {
  [15:45:59.668]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.668]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.668]         }
  [15:45:59.668]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.668]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.668]             base::sink(type = "output", split = FALSE)
  [15:45:59.668]             base::close(...future.stdout)
  [15:45:59.668]         }, add = TRUE)
  [15:45:59.668]     }
  [15:45:59.668]     ...future.frame <- base::sys.nframe()
  [15:45:59.668]     ...future.conditions <- base::list()
  [15:45:59.668]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.668]     ...future.result <- base::tryCatch({
  [15:45:59.668]         base::withCallingHandlers({
  [15:45:59.668]             ...future.value <- base::withVisible(base::local(2))
  [15:45:59.668]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.668]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.668]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.668]                 version = "1.8")
  [15:45:59.668]         }, condition = base::local({
  [15:45:59.668]             c <- base::c
  [15:45:59.668]             inherits <- base::inherits
  [15:45:59.668]             invokeRestart <- base::invokeRestart
  [15:45:59.668]             length <- base::length
  [15:45:59.668]             list <- base::list
  [15:45:59.668]             seq.int <- base::seq.int
  [15:45:59.668]             signalCondition <- base::signalCondition
  [15:45:59.668]             sys.calls <- base::sys.calls
  [15:45:59.668]             Sys.time <- base::Sys.time
  [15:45:59.668]             `[[` <- base::`[[`
  [15:45:59.668]             `+` <- base::`+`
  [15:45:59.668]             `<<-` <- base::`<<-`
  [15:45:59.668]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.668]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.668]                   3L)]
  [15:45:59.668]             }
  [15:45:59.668]             function(cond) {
  [15:45:59.668]                 if (inherits(cond, "error")) {
  [15:45:59.668]                   sessionInformation <- function() {
  [15:45:59.668]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.668]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.668]                       search = base::search(), system = base::Sys.info())
  [15:45:59.668]                   }
  [15:45:59.668]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.668]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.668]                     cond$call), session = sessionInformation(), 
  [15:45:59.668]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.668]                   signalCondition(cond)
  [15:45:59.668]                 }
  [15:45:59.668]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.668]                 ))) {
  [15:45:59.668]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.668]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.668]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.668]                   if (!signal) {
  [15:45:59.668]                     muffleCondition <- function (cond) 
  [15:45:59.668]                     {
  [15:45:59.668]                       inherits <- base::inherits
  [15:45:59.668]                       invokeRestart <- base::invokeRestart
  [15:45:59.668]                       muffled <- FALSE
  [15:45:59.668]                       if (inherits(cond, "message")) {
  [15:45:59.668]                         invokeRestart("muffleMessage")
  [15:45:59.668]                         muffled <- TRUE
  [15:45:59.668]                       }
  [15:45:59.668]                       else if (inherits(cond, "warning")) {
  [15:45:59.668]                         invokeRestart("muffleWarning")
  [15:45:59.668]                         muffled <- TRUE
  [15:45:59.668]                       }
  [15:45:59.668]                       else if (inherits(cond, "condition")) {
  [15:45:59.668]                         computeRestarts <- base::computeRestarts
  [15:45:59.668]                         grepl <- base::grepl
  [15:45:59.668]                         is.null <- base::is.null
  [15:45:59.668]                         restarts <- computeRestarts(cond)
  [15:45:59.668]                         for (restart in restarts) {
  [15:45:59.668]                           name <- restart$name
  [15:45:59.668]                           if (is.null(name)) 
  [15:45:59.668]                             next
  [15:45:59.668]                           if (!grepl("^muffle", name)) 
  [15:45:59.668]                             next
  [15:45:59.668]                           invokeRestart(restart)
  [15:45:59.668]                           muffled <- TRUE
  [15:45:59.668]                           break
  [15:45:59.668]                         }
  [15:45:59.668]                       }
  [15:45:59.668]                       invisible(muffled)
  [15:45:59.668]                     }
  [15:45:59.668]                     muffleCondition(cond)
  [15:45:59.668]                   }
  [15:45:59.668]                 }
  [15:45:59.668]             }
  [15:45:59.668]         }))
  [15:45:59.668]     }, error = function(ex) {
  [15:45:59.668]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.668]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.668]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.668]     }, finally = {
  [15:45:59.668]         {
  [15:45:59.668]             NULL
  [15:45:59.668]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.668]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.668]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.668]                 label = NULL, ...) 
  [15:45:59.668]             {
  [15:45:59.668]                 if (substitute) 
  [15:45:59.668]                   expr <- substitute(expr)
  [15:45:59.668]                 local <- as.logical(local)
  [15:45:59.668]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.668]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.668]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.668]                   label = label, ...)
  [15:45:59.668]                 if (!future$lazy) 
  [15:45:59.668]                   future <- run(future)
  [15:45:59.668]                 invisible(future)
  [15:45:59.668]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.668]         }
  [15:45:59.668]         base::options(...future.oldOptions)
  [15:45:59.668]     })
  [15:45:59.668]     Sys.time
  [15:45:59.668]     if (base::is.na(TRUE)) {
  [15:45:59.668]     }
  [15:45:59.668]     else {
  [15:45:59.668]         base::sink(type = "output", split = FALSE)
  [15:45:59.668]         if (TRUE) {
  [15:45:59.668]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.668]         }
  [15:45:59.668]         else {
  [15:45:59.668]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.668]         }
  [15:45:59.668]         base::close(...future.stdout)
  [15:45:59.668]         ...future.stdout <- NULL
  [15:45:59.668]     }
  [15:45:59.668]     ...future.result$conditions <- ...future.conditions
  [15:45:59.668]     ...future.result
  [15:45:59.668] }
  [15:45:59.673] plan(): Setting new future strategy stack:
  [15:45:59.674] List of future strategies:
  [15:45:59.674] 1. sequential:
  [15:45:59.674]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.674]    - tweaked: FALSE
  [15:45:59.674]    - call: NULL
  [15:45:59.675] plan(): nbrOfWorkers() = 1
  [15:45:59.676] plan(): Setting new future strategy stack:
  [15:45:59.676] List of future strategies:
  [15:45:59.676] 1. sequential:
  [15:45:59.676]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.676]    - tweaked: FALSE
  [15:45:59.676]    - call: plan(strategy)
  [15:45:59.678] plan(): nbrOfWorkers() = 1
  [15:45:59.678] SequentialFuture started (and completed)
  [15:45:59.679] getGlobalsAndPackages() ...
  [15:45:59.679] Searching for globals...
  [15:45:59.680] 
  [15:45:59.680] Searching for globals ... DONE
  [15:45:59.681] - globals: [0] <none>
  [15:45:59.681] getGlobalsAndPackages() ... DONE
  [15:45:59.685] Packages needed by the future expression (n = 0): <none>
  [15:45:59.685] Packages needed by future strategies (n = 0): <none>
  [15:45:59.691] {
  [15:45:59.691]     {
  [15:45:59.691]         ...future.startTime <- base::Sys.time()
  [15:45:59.691]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.691]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.691]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.691]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.691]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.691]         {
  [15:45:59.691]             {
  [15:45:59.691]                 base::local({
  [15:45:59.691]                   has_future <- base::requireNamespace("future", 
  [15:45:59.691]                     quietly = TRUE)
  [15:45:59.691]                   version <- if (has_future) 
  [15:45:59.691]                     utils::packageVersion("future")
  [15:45:59.691]                   else NULL
  [15:45:59.691]                   if (!has_future || version < "1.8.0") {
  [15:45:59.691]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.691]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.691]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.691]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.691]                         "release", "version")], collapse = " "), 
  [15:45:59.691]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.691]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.691]                       info)
  [15:45:59.691]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.691]                     if (!has_future) {
  [15:45:59.691]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.691]                         info)
  [15:45:59.691]                     }
  [15:45:59.691]                     else {
  [15:45:59.691]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.691]                         info, version)
  [15:45:59.691]                     }
  [15:45:59.691]                     base::stop(msg)
  [15:45:59.691]                   }
  [15:45:59.691]                 })
  [15:45:59.691]             }
  [15:45:59.691]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.691]         }
  [15:45:59.691]     }
  [15:45:59.691]     if (base::is.na(TRUE)) {
  [15:45:59.691]     }
  [15:45:59.691]     else {
  [15:45:59.691]         if (TRUE) {
  [15:45:59.691]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.691]                 open = "w")
  [15:45:59.691]         }
  [15:45:59.691]         else {
  [15:45:59.691]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.691]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.691]         }
  [15:45:59.691]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.691]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.691]             base::sink(type = "output", split = FALSE)
  [15:45:59.691]             base::close(...future.stdout)
  [15:45:59.691]         }, add = TRUE)
  [15:45:59.691]     }
  [15:45:59.691]     ...future.frame <- base::sys.nframe()
  [15:45:59.691]     ...future.conditions <- base::list()
  [15:45:59.691]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.691]     ...future.result <- base::tryCatch({
  [15:45:59.691]         base::withCallingHandlers({
  [15:45:59.691]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:59.691]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.691]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.691]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.691]                 version = "1.8")
  [15:45:59.691]         }, condition = base::local({
  [15:45:59.691]             c <- base::c
  [15:45:59.691]             inherits <- base::inherits
  [15:45:59.691]             invokeRestart <- base::invokeRestart
  [15:45:59.691]             length <- base::length
  [15:45:59.691]             list <- base::list
  [15:45:59.691]             seq.int <- base::seq.int
  [15:45:59.691]             signalCondition <- base::signalCondition
  [15:45:59.691]             sys.calls <- base::sys.calls
  [15:45:59.691]             Sys.time <- base::Sys.time
  [15:45:59.691]             `[[` <- base::`[[`
  [15:45:59.691]             `+` <- base::`+`
  [15:45:59.691]             `<<-` <- base::`<<-`
  [15:45:59.691]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.691]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.691]                   3L)]
  [15:45:59.691]             }
  [15:45:59.691]             function(cond) {
  [15:45:59.691]                 if (inherits(cond, "error")) {
  [15:45:59.691]                   sessionInformation <- function() {
  [15:45:59.691]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.691]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.691]                       search = base::search(), system = base::Sys.info())
  [15:45:59.691]                   }
  [15:45:59.691]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.691]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.691]                     cond$call), session = sessionInformation(), 
  [15:45:59.691]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.691]                   signalCondition(cond)
  [15:45:59.691]                 }
  [15:45:59.691]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.691]                 ))) {
  [15:45:59.691]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.691]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.691]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.691]                   if (!signal) {
  [15:45:59.691]                     muffleCondition <- function (cond) 
  [15:45:59.691]                     {
  [15:45:59.691]                       inherits <- base::inherits
  [15:45:59.691]                       invokeRestart <- base::invokeRestart
  [15:45:59.691]                       muffled <- FALSE
  [15:45:59.691]                       if (inherits(cond, "message")) {
  [15:45:59.691]                         invokeRestart("muffleMessage")
  [15:45:59.691]                         muffled <- TRUE
  [15:45:59.691]                       }
  [15:45:59.691]                       else if (inherits(cond, "warning")) {
  [15:45:59.691]                         invokeRestart("muffleWarning")
  [15:45:59.691]                         muffled <- TRUE
  [15:45:59.691]                       }
  [15:45:59.691]                       else if (inherits(cond, "condition")) {
  [15:45:59.691]                         computeRestarts <- base::computeRestarts
  [15:45:59.691]                         grepl <- base::grepl
  [15:45:59.691]                         is.null <- base::is.null
  [15:45:59.691]                         restarts <- computeRestarts(cond)
  [15:45:59.691]                         for (restart in restarts) {
  [15:45:59.691]                           name <- restart$name
  [15:45:59.691]                           if (is.null(name)) 
  [15:45:59.691]                             next
  [15:45:59.691]                           if (!grepl("^muffle", name)) 
  [15:45:59.691]                             next
  [15:45:59.691]                           invokeRestart(restart)
  [15:45:59.691]                           muffled <- TRUE
  [15:45:59.691]                           break
  [15:45:59.691]                         }
  [15:45:59.691]                       }
  [15:45:59.691]                       invisible(muffled)
  [15:45:59.691]                     }
  [15:45:59.691]                     muffleCondition(cond)
  [15:45:59.691]                   }
  [15:45:59.691]                 }
  [15:45:59.691]             }
  [15:45:59.691]         }))
  [15:45:59.691]     }, error = function(ex) {
  [15:45:59.691]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.691]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.691]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.691]     }, finally = {
  [15:45:59.691]         {
  [15:45:59.691]             NULL
  [15:45:59.691]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.691]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.691]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.691]                 label = NULL, ...) 
  [15:45:59.691]             {
  [15:45:59.691]                 if (substitute) 
  [15:45:59.691]                   expr <- substitute(expr)
  [15:45:59.691]                 local <- as.logical(local)
  [15:45:59.691]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.691]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.691]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.691]                   label = label, ...)
  [15:45:59.691]                 if (!future$lazy) 
  [15:45:59.691]                   future <- run(future)
  [15:45:59.691]                 invisible(future)
  [15:45:59.691]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.691]         }
  [15:45:59.691]         base::options(...future.oldOptions)
  [15:45:59.691]     })
  [15:45:59.691]     Sys.time
  [15:45:59.691]     if (base::is.na(TRUE)) {
  [15:45:59.691]     }
  [15:45:59.691]     else {
  [15:45:59.691]         base::sink(type = "output", split = FALSE)
  [15:45:59.691]         if (TRUE) {
  [15:45:59.691]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.691]         }
  [15:45:59.691]         else {
  [15:45:59.691]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.691]         }
  [15:45:59.691]         base::close(...future.stdout)
  [15:45:59.691]         ...future.stdout <- NULL
  [15:45:59.691]     }
  [15:45:59.691]     ...future.result$conditions <- ...future.conditions
  [15:45:59.691]     ...future.result
  [15:45:59.691] }
  [15:45:59.697] plan(): Setting new future strategy stack:
  [15:45:59.697] List of future strategies:
  [15:45:59.697] 1. sequential:
  [15:45:59.697]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.697]    - tweaked: FALSE
  [15:45:59.697]    - call: NULL
  [15:45:59.698] plan(): nbrOfWorkers() = 1
  [15:45:59.700] plan(): Setting new future strategy stack:
  [15:45:59.700] List of future strategies:
  [15:45:59.700] 1. sequential:
  [15:45:59.700]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.700]    - tweaked: FALSE
  [15:45:59.700]    - call: plan(strategy)
  [15:45:59.701] plan(): nbrOfWorkers() = 1
  [15:45:59.702] SequentialFuture started (and completed)
  [15:45:59.704] getGlobalsAndPackages() ...
  [15:45:59.704] Searching for globals...
  [15:45:59.706] - globals found: [1] '{'
  [15:45:59.706] Searching for globals ... DONE
  [15:45:59.707] Resolving globals: FALSE
  [15:45:59.707] 
  [15:45:59.708] 
  [15:45:59.708] getGlobalsAndPackages() ... DONE
  [15:45:59.711] Packages needed by the future expression (n = 0): <none>
  [15:45:59.711] Packages needed by future strategies (n = 0): <none>
  [15:45:59.718] {
  [15:45:59.718]     {
  [15:45:59.718]         ...future.startTime <- base::Sys.time()
  [15:45:59.718]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.718]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.718]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.718]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.718]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.718]         {
  [15:45:59.718]             {
  [15:45:59.718]                 base::local({
  [15:45:59.718]                   has_future <- base::requireNamespace("future", 
  [15:45:59.718]                     quietly = TRUE)
  [15:45:59.718]                   version <- if (has_future) 
  [15:45:59.718]                     utils::packageVersion("future")
  [15:45:59.718]                   else NULL
  [15:45:59.718]                   if (!has_future || version < "1.8.0") {
  [15:45:59.718]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.718]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.718]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.718]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.718]                         "release", "version")], collapse = " "), 
  [15:45:59.718]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.718]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.718]                       info)
  [15:45:59.718]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.718]                     if (!has_future) {
  [15:45:59.718]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.718]                         info)
  [15:45:59.718]                     }
  [15:45:59.718]                     else {
  [15:45:59.718]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.718]                         info, version)
  [15:45:59.718]                     }
  [15:45:59.718]                     base::stop(msg)
  [15:45:59.718]                   }
  [15:45:59.718]                 })
  [15:45:59.718]             }
  [15:45:59.718]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.718]         }
  [15:45:59.718]     }
  [15:45:59.718]     if (base::is.na(TRUE)) {
  [15:45:59.718]     }
  [15:45:59.718]     else {
  [15:45:59.718]         if (TRUE) {
  [15:45:59.718]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.718]                 open = "w")
  [15:45:59.718]         }
  [15:45:59.718]         else {
  [15:45:59.718]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.718]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.718]         }
  [15:45:59.718]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.718]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.718]             base::sink(type = "output", split = FALSE)
  [15:45:59.718]             base::close(...future.stdout)
  [15:45:59.718]         }, add = TRUE)
  [15:45:59.718]     }
  [15:45:59.718]     ...future.frame <- base::sys.nframe()
  [15:45:59.718]     ...future.conditions <- base::list()
  [15:45:59.718]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.718]     ...future.result <- base::tryCatch({
  [15:45:59.718]         base::withCallingHandlers({
  [15:45:59.718]             ...future.value <- base::withVisible(base::local({
  [15:45:59.718]                 4
  [15:45:59.718]             }))
  [15:45:59.718]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.718]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.718]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.718]                 version = "1.8")
  [15:45:59.718]         }, condition = base::local({
  [15:45:59.718]             c <- base::c
  [15:45:59.718]             inherits <- base::inherits
  [15:45:59.718]             invokeRestart <- base::invokeRestart
  [15:45:59.718]             length <- base::length
  [15:45:59.718]             list <- base::list
  [15:45:59.718]             seq.int <- base::seq.int
  [15:45:59.718]             signalCondition <- base::signalCondition
  [15:45:59.718]             sys.calls <- base::sys.calls
  [15:45:59.718]             Sys.time <- base::Sys.time
  [15:45:59.718]             `[[` <- base::`[[`
  [15:45:59.718]             `+` <- base::`+`
  [15:45:59.718]             `<<-` <- base::`<<-`
  [15:45:59.718]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.718]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.718]                   3L)]
  [15:45:59.718]             }
  [15:45:59.718]             function(cond) {
  [15:45:59.718]                 if (inherits(cond, "error")) {
  [15:45:59.718]                   sessionInformation <- function() {
  [15:45:59.718]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.718]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.718]                       search = base::search(), system = base::Sys.info())
  [15:45:59.718]                   }
  [15:45:59.718]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.718]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.718]                     cond$call), session = sessionInformation(), 
  [15:45:59.718]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.718]                   signalCondition(cond)
  [15:45:59.718]                 }
  [15:45:59.718]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.718]                 ))) {
  [15:45:59.718]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.718]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.718]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.718]                   if (!signal) {
  [15:45:59.718]                     muffleCondition <- function (cond) 
  [15:45:59.718]                     {
  [15:45:59.718]                       inherits <- base::inherits
  [15:45:59.718]                       invokeRestart <- base::invokeRestart
  [15:45:59.718]                       muffled <- FALSE
  [15:45:59.718]                       if (inherits(cond, "message")) {
  [15:45:59.718]                         invokeRestart("muffleMessage")
  [15:45:59.718]                         muffled <- TRUE
  [15:45:59.718]                       }
  [15:45:59.718]                       else if (inherits(cond, "warning")) {
  [15:45:59.718]                         invokeRestart("muffleWarning")
  [15:45:59.718]                         muffled <- TRUE
  [15:45:59.718]                       }
  [15:45:59.718]                       else if (inherits(cond, "condition")) {
  [15:45:59.718]                         computeRestarts <- base::computeRestarts
  [15:45:59.718]                         grepl <- base::grepl
  [15:45:59.718]                         is.null <- base::is.null
  [15:45:59.718]                         restarts <- computeRestarts(cond)
  [15:45:59.718]                         for (restart in restarts) {
  [15:45:59.718]                           name <- restart$name
  [15:45:59.718]                           if (is.null(name)) 
  [15:45:59.718]                             next
  [15:45:59.718]                           if (!grepl("^muffle", name)) 
  [15:45:59.718]                             next
  [15:45:59.718]                           invokeRestart(restart)
  [15:45:59.718]                           muffled <- TRUE
  [15:45:59.718]                           break
  [15:45:59.718]                         }
  [15:45:59.718]                       }
  [15:45:59.718]                       invisible(muffled)
  [15:45:59.718]                     }
  [15:45:59.718]                     muffleCondition(cond)
  [15:45:59.718]                   }
  [15:45:59.718]                 }
  [15:45:59.718]             }
  [15:45:59.718]         }))
  [15:45:59.718]     }, error = function(ex) {
  [15:45:59.718]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.718]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.718]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.718]     }, finally = {
  [15:45:59.718]         {
  [15:45:59.718]             NULL
  [15:45:59.718]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.718]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.718]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.718]                 label = NULL, ...) 
  [15:45:59.718]             {
  [15:45:59.718]                 if (substitute) 
  [15:45:59.718]                   expr <- substitute(expr)
  [15:45:59.718]                 local <- as.logical(local)
  [15:45:59.718]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.718]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.718]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.718]                   label = label, ...)
  [15:45:59.718]                 if (!future$lazy) 
  [15:45:59.718]                   future <- run(future)
  [15:45:59.718]                 invisible(future)
  [15:45:59.718]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.718]         }
  [15:45:59.718]         base::options(...future.oldOptions)
  [15:45:59.718]     })
  [15:45:59.718]     Sys.time
  [15:45:59.718]     if (base::is.na(TRUE)) {
  [15:45:59.718]     }
  [15:45:59.718]     else {
  [15:45:59.718]         base::sink(type = "output", split = FALSE)
  [15:45:59.718]         if (TRUE) {
  [15:45:59.718]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.718]         }
  [15:45:59.718]         else {
  [15:45:59.718]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.718]         }
  [15:45:59.718]         base::close(...future.stdout)
  [15:45:59.718]         ...future.stdout <- NULL
  [15:45:59.718]     }
  [15:45:59.718]     ...future.result$conditions <- ...future.conditions
  [15:45:59.718]     ...future.result
  [15:45:59.718] }
  [15:45:59.723] plan(): Setting new future strategy stack:
  [15:45:59.724] List of future strategies:
  [15:45:59.724] 1. sequential:
  [15:45:59.724]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.724]    - tweaked: FALSE
  [15:45:59.724]    - call: NULL
  [15:45:59.725] plan(): nbrOfWorkers() = 1
  [15:45:59.727] plan(): Setting new future strategy stack:
  [15:45:59.731] List of future strategies:
  [15:45:59.731] 1. sequential:
  [15:45:59.731]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.731]    - tweaked: FALSE
  [15:45:59.731]    - call: plan(strategy)
  [15:45:59.732] plan(): nbrOfWorkers() = 1
  [15:45:59.733] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ca2add8678> 
  Classes 'listenv', 'environment' <environment: 0x55ca2ac52b98> 
   Named logi [1:6] TRUE TRUE TRUE TRUE TRUE TRUE
   - attr(*, "names")= chr [1:6] "a" "b" "c" "d" ...
  [15:45:59.749] resolve() on list environment ...
  [15:45:59.749]  recursive: 0
  [15:45:59.752]  length: 6
  [15:45:59.753]  elements: 'a', 'b', 'c', 'd', '', ''
  [15:45:59.753] signalConditionsASAP(numeric, pos=1) ...
  [15:45:59.754] - nx: 6
  [15:45:59.754] - relay: TRUE
  [15:45:59.754] - stdout: TRUE
  [15:45:59.755] - signal: TRUE
  [15:45:59.755] - resignal: FALSE
  [15:45:59.755] - force: TRUE
  [15:45:59.756] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.756] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.756]  - until=2
  [15:45:59.757]  - relaying element #2
  [15:45:59.757] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.757] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.758] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:59.758]  length: 5 (resolved future 1)
  [15:45:59.759] Future #2
  [15:45:59.759] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:59.759] - nx: 6
  [15:45:59.760] - relay: TRUE
  [15:45:59.760] - stdout: TRUE
  [15:45:59.760] - signal: TRUE
  [15:45:59.761] - resignal: FALSE
  [15:45:59.761] - force: TRUE
  [15:45:59.761] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.762] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.762]  - until=2
  [15:45:59.762]  - relaying element #2
  [15:45:59.763] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.763] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.764] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:59.764]  length: 4 (resolved future 2)
  [15:45:59.765] Future #3
  [15:45:59.765] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:59.765] - nx: 6
  [15:45:59.766] - relay: TRUE
  [15:45:59.766] - stdout: TRUE
  [15:45:59.766] - signal: TRUE
  [15:45:59.767] - resignal: FALSE
  [15:45:59.767] - force: TRUE
  [15:45:59.767] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.768] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.768]  - until=3
  [15:45:59.769]  - relaying element #3
  [15:45:59.769] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.770] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.770] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:59.770]  length: 3 (resolved future 3)
  [15:45:59.771] Future #4
  [15:45:59.771] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:59.772] - nx: 6
  [15:45:59.772] - relay: TRUE
  [15:45:59.772] - stdout: TRUE
  [15:45:59.773] - signal: TRUE
  [15:45:59.773] - resignal: FALSE
  [15:45:59.773] - force: TRUE
  [15:45:59.774] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.774] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.774]  - until=4
  [15:45:59.775]  - relaying element #4
  [15:45:59.775] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.776] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.776] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:59.777]  length: 2 (resolved future 4)
  [15:45:59.777] signalConditionsASAP(NULL, pos=5) ...
  [15:45:59.777] - nx: 6
  [15:45:59.778] - relay: TRUE
  [15:45:59.778] - stdout: TRUE
  [15:45:59.778] - signal: TRUE
  [15:45:59.779] - resignal: FALSE
  [15:45:59.779] - force: TRUE
  [15:45:59.779] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.780] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.780]  - until=6
  [15:45:59.780]  - relaying element #6
  [15:45:59.781] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:59.781] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.781] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:59.782]  length: 1 (resolved future 5)
  [15:45:59.782] signalConditionsASAP(numeric, pos=6) ...
  [15:45:59.782] - nx: 6
  [15:45:59.783] - relay: TRUE
  [15:45:59.783] - stdout: TRUE
  [15:45:59.783] - signal: TRUE
  [15:45:59.784] - resignal: FALSE
  [15:45:59.784] - force: TRUE
  [15:45:59.784] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:59.785] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.785]  - until=6
  [15:45:59.785] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.786] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.786] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:59.787]  length: 0 (resolved future 6)
  [15:45:59.787] Relaying remaining futures
  [15:45:59.787] signalConditionsASAP(NULL, pos=0) ...
  [15:45:59.788] - nx: 6
  [15:45:59.788] - relay: TRUE
  [15:45:59.788] - stdout: TRUE
  [15:45:59.788] - signal: TRUE
  [15:45:59.789] - resignal: FALSE
  [15:45:59.789] - force: TRUE
  [15:45:59.789] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.790] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [15:45:59.790] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.791] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.791] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:59.791] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ca28f69198> 
  Dimensions: c(1, 6)
  [15:45:59.794] getGlobalsAndPackages() ...
  [15:45:59.795] Searching for globals...
  [15:45:59.795] 
  [15:45:59.796] Searching for globals ... DONE
  [15:45:59.796] - globals: [0] <none>
  [15:45:59.796] getGlobalsAndPackages() ... DONE
  [15:45:59.799] Packages needed by the future expression (n = 0): <none>
  [15:45:59.799] Packages needed by future strategies (n = 0): <none>
  [15:45:59.810] {
  [15:45:59.810]     {
  [15:45:59.810]         ...future.startTime <- base::Sys.time()
  [15:45:59.810]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.810]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.810]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.810]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.810]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.810]         {
  [15:45:59.810]             {
  [15:45:59.810]                 base::local({
  [15:45:59.810]                   has_future <- base::requireNamespace("future", 
  [15:45:59.810]                     quietly = TRUE)
  [15:45:59.810]                   version <- if (has_future) 
  [15:45:59.810]                     utils::packageVersion("future")
  [15:45:59.810]                   else NULL
  [15:45:59.810]                   if (!has_future || version < "1.8.0") {
  [15:45:59.810]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.810]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.810]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.810]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.810]                         "release", "version")], collapse = " "), 
  [15:45:59.810]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.810]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.810]                       info)
  [15:45:59.810]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.810]                     if (!has_future) {
  [15:45:59.810]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.810]                         info)
  [15:45:59.810]                     }
  [15:45:59.810]                     else {
  [15:45:59.810]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.810]                         info, version)
  [15:45:59.810]                     }
  [15:45:59.810]                     base::stop(msg)
  [15:45:59.810]                   }
  [15:45:59.810]                 })
  [15:45:59.810]             }
  [15:45:59.810]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.810]         }
  [15:45:59.810]     }
  [15:45:59.810]     if (base::is.na(TRUE)) {
  [15:45:59.810]     }
  [15:45:59.810]     else {
  [15:45:59.810]         if (TRUE) {
  [15:45:59.810]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.810]                 open = "w")
  [15:45:59.810]         }
  [15:45:59.810]         else {
  [15:45:59.810]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.810]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.810]         }
  [15:45:59.810]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.810]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.810]             base::sink(type = "output", split = FALSE)
  [15:45:59.810]             base::close(...future.stdout)
  [15:45:59.810]         }, add = TRUE)
  [15:45:59.810]     }
  [15:45:59.810]     ...future.frame <- base::sys.nframe()
  [15:45:59.810]     ...future.conditions <- base::list()
  [15:45:59.810]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.810]     ...future.result <- base::tryCatch({
  [15:45:59.810]         base::withCallingHandlers({
  [15:45:59.810]             ...future.value <- base::withVisible(base::local(2))
  [15:45:59.810]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.810]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.810]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.810]                 version = "1.8")
  [15:45:59.810]         }, condition = base::local({
  [15:45:59.810]             c <- base::c
  [15:45:59.810]             inherits <- base::inherits
  [15:45:59.810]             invokeRestart <- base::invokeRestart
  [15:45:59.810]             length <- base::length
  [15:45:59.810]             list <- base::list
  [15:45:59.810]             seq.int <- base::seq.int
  [15:45:59.810]             signalCondition <- base::signalCondition
  [15:45:59.810]             sys.calls <- base::sys.calls
  [15:45:59.810]             Sys.time <- base::Sys.time
  [15:45:59.810]             `[[` <- base::`[[`
  [15:45:59.810]             `+` <- base::`+`
  [15:45:59.810]             `<<-` <- base::`<<-`
  [15:45:59.810]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.810]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.810]                   3L)]
  [15:45:59.810]             }
  [15:45:59.810]             function(cond) {
  [15:45:59.810]                 if (inherits(cond, "error")) {
  [15:45:59.810]                   sessionInformation <- function() {
  [15:45:59.810]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.810]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.810]                       search = base::search(), system = base::Sys.info())
  [15:45:59.810]                   }
  [15:45:59.810]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.810]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.810]                     cond$call), session = sessionInformation(), 
  [15:45:59.810]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.810]                   signalCondition(cond)
  [15:45:59.810]                 }
  [15:45:59.810]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.810]                 ))) {
  [15:45:59.810]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.810]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.810]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.810]                   if (!signal) {
  [15:45:59.810]                     muffleCondition <- function (cond) 
  [15:45:59.810]                     {
  [15:45:59.810]                       inherits <- base::inherits
  [15:45:59.810]                       invokeRestart <- base::invokeRestart
  [15:45:59.810]                       muffled <- FALSE
  [15:45:59.810]                       if (inherits(cond, "message")) {
  [15:45:59.810]                         invokeRestart("muffleMessage")
  [15:45:59.810]                         muffled <- TRUE
  [15:45:59.810]                       }
  [15:45:59.810]                       else if (inherits(cond, "warning")) {
  [15:45:59.810]                         invokeRestart("muffleWarning")
  [15:45:59.810]                         muffled <- TRUE
  [15:45:59.810]                       }
  [15:45:59.810]                       else if (inherits(cond, "condition")) {
  [15:45:59.810]                         computeRestarts <- base::computeRestarts
  [15:45:59.810]                         grepl <- base::grepl
  [15:45:59.810]                         is.null <- base::is.null
  [15:45:59.810]                         restarts <- computeRestarts(cond)
  [15:45:59.810]                         for (restart in restarts) {
  [15:45:59.810]                           name <- restart$name
  [15:45:59.810]                           if (is.null(name)) 
  [15:45:59.810]                             next
  [15:45:59.810]                           if (!grepl("^muffle", name)) 
  [15:45:59.810]                             next
  [15:45:59.810]                           invokeRestart(restart)
  [15:45:59.810]                           muffled <- TRUE
  [15:45:59.810]                           break
  [15:45:59.810]                         }
  [15:45:59.810]                       }
  [15:45:59.810]                       invisible(muffled)
  [15:45:59.810]                     }
  [15:45:59.810]                     muffleCondition(cond)
  [15:45:59.810]                   }
  [15:45:59.810]                 }
  [15:45:59.810]             }
  [15:45:59.810]         }))
  [15:45:59.810]     }, error = function(ex) {
  [15:45:59.810]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.810]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.810]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.810]     }, finally = {
  [15:45:59.810]         {
  [15:45:59.810]             NULL
  [15:45:59.810]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.810]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.810]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.810]                 label = NULL, ...) 
  [15:45:59.810]             {
  [15:45:59.810]                 if (substitute) 
  [15:45:59.810]                   expr <- substitute(expr)
  [15:45:59.810]                 local <- as.logical(local)
  [15:45:59.810]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.810]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.810]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.810]                   label = label, ...)
  [15:45:59.810]                 if (!future$lazy) 
  [15:45:59.810]                   future <- run(future)
  [15:45:59.810]                 invisible(future)
  [15:45:59.810]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.810]         }
  [15:45:59.810]         base::options(...future.oldOptions)
  [15:45:59.810]     })
  [15:45:59.810]     Sys.time
  [15:45:59.810]     if (base::is.na(TRUE)) {
  [15:45:59.810]     }
  [15:45:59.810]     else {
  [15:45:59.810]         base::sink(type = "output", split = FALSE)
  [15:45:59.810]         if (TRUE) {
  [15:45:59.810]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.810]         }
  [15:45:59.810]         else {
  [15:45:59.810]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.810]         }
  [15:45:59.810]         base::close(...future.stdout)
  [15:45:59.810]         ...future.stdout <- NULL
  [15:45:59.810]     }
  [15:45:59.810]     ...future.result$conditions <- ...future.conditions
  [15:45:59.810]     ...future.result
  [15:45:59.810] }
  [15:45:59.816] plan(): Setting new future strategy stack:
  [15:45:59.816] List of future strategies:
  [15:45:59.816] 1. sequential:
  [15:45:59.816]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.816]    - tweaked: FALSE
  [15:45:59.816]    - call: NULL
  [15:45:59.817] plan(): nbrOfWorkers() = 1
  [15:45:59.818] plan(): Setting new future strategy stack:
  [15:45:59.819] List of future strategies:
  [15:45:59.819] 1. sequential:
  [15:45:59.819]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.819]    - tweaked: FALSE
  [15:45:59.819]    - call: plan(strategy)
  [15:45:59.820] plan(): nbrOfWorkers() = 1
  [15:45:59.821] SequentialFuture started (and completed)
  [15:45:59.821] getGlobalsAndPackages() ...
  [15:45:59.822] Searching for globals...
  [15:45:59.822] 
  [15:45:59.823] Searching for globals ... DONE
  [15:45:59.823] - globals: [0] <none>
  [15:45:59.823] getGlobalsAndPackages() ... DONE
  [15:45:59.826] Packages needed by the future expression (n = 0): <none>
  [15:45:59.826] Packages needed by future strategies (n = 0): <none>
  [15:45:59.833] {
  [15:45:59.833]     {
  [15:45:59.833]         ...future.startTime <- base::Sys.time()
  [15:45:59.833]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.833]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.833]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.833]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.833]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.833]         {
  [15:45:59.833]             {
  [15:45:59.833]                 base::local({
  [15:45:59.833]                   has_future <- base::requireNamespace("future", 
  [15:45:59.833]                     quietly = TRUE)
  [15:45:59.833]                   version <- if (has_future) 
  [15:45:59.833]                     utils::packageVersion("future")
  [15:45:59.833]                   else NULL
  [15:45:59.833]                   if (!has_future || version < "1.8.0") {
  [15:45:59.833]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.833]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.833]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.833]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.833]                         "release", "version")], collapse = " "), 
  [15:45:59.833]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.833]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.833]                       info)
  [15:45:59.833]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.833]                     if (!has_future) {
  [15:45:59.833]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.833]                         info)
  [15:45:59.833]                     }
  [15:45:59.833]                     else {
  [15:45:59.833]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.833]                         info, version)
  [15:45:59.833]                     }
  [15:45:59.833]                     base::stop(msg)
  [15:45:59.833]                   }
  [15:45:59.833]                 })
  [15:45:59.833]             }
  [15:45:59.833]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.833]         }
  [15:45:59.833]     }
  [15:45:59.833]     if (base::is.na(TRUE)) {
  [15:45:59.833]     }
  [15:45:59.833]     else {
  [15:45:59.833]         if (TRUE) {
  [15:45:59.833]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.833]                 open = "w")
  [15:45:59.833]         }
  [15:45:59.833]         else {
  [15:45:59.833]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.833]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.833]         }
  [15:45:59.833]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.833]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.833]             base::sink(type = "output", split = FALSE)
  [15:45:59.833]             base::close(...future.stdout)
  [15:45:59.833]         }, add = TRUE)
  [15:45:59.833]     }
  [15:45:59.833]     ...future.frame <- base::sys.nframe()
  [15:45:59.833]     ...future.conditions <- base::list()
  [15:45:59.833]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.833]     ...future.result <- base::tryCatch({
  [15:45:59.833]         base::withCallingHandlers({
  [15:45:59.833]             ...future.value <- base::withVisible(base::local(NULL))
  [15:45:59.833]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.833]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.833]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.833]                 version = "1.8")
  [15:45:59.833]         }, condition = base::local({
  [15:45:59.833]             c <- base::c
  [15:45:59.833]             inherits <- base::inherits
  [15:45:59.833]             invokeRestart <- base::invokeRestart
  [15:45:59.833]             length <- base::length
  [15:45:59.833]             list <- base::list
  [15:45:59.833]             seq.int <- base::seq.int
  [15:45:59.833]             signalCondition <- base::signalCondition
  [15:45:59.833]             sys.calls <- base::sys.calls
  [15:45:59.833]             Sys.time <- base::Sys.time
  [15:45:59.833]             `[[` <- base::`[[`
  [15:45:59.833]             `+` <- base::`+`
  [15:45:59.833]             `<<-` <- base::`<<-`
  [15:45:59.833]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.833]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.833]                   3L)]
  [15:45:59.833]             }
  [15:45:59.833]             function(cond) {
  [15:45:59.833]                 if (inherits(cond, "error")) {
  [15:45:59.833]                   sessionInformation <- function() {
  [15:45:59.833]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.833]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.833]                       search = base::search(), system = base::Sys.info())
  [15:45:59.833]                   }
  [15:45:59.833]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.833]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.833]                     cond$call), session = sessionInformation(), 
  [15:45:59.833]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.833]                   signalCondition(cond)
  [15:45:59.833]                 }
  [15:45:59.833]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.833]                 ))) {
  [15:45:59.833]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.833]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.833]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.833]                   if (!signal) {
  [15:45:59.833]                     muffleCondition <- function (cond) 
  [15:45:59.833]                     {
  [15:45:59.833]                       inherits <- base::inherits
  [15:45:59.833]                       invokeRestart <- base::invokeRestart
  [15:45:59.833]                       muffled <- FALSE
  [15:45:59.833]                       if (inherits(cond, "message")) {
  [15:45:59.833]                         invokeRestart("muffleMessage")
  [15:45:59.833]                         muffled <- TRUE
  [15:45:59.833]                       }
  [15:45:59.833]                       else if (inherits(cond, "warning")) {
  [15:45:59.833]                         invokeRestart("muffleWarning")
  [15:45:59.833]                         muffled <- TRUE
  [15:45:59.833]                       }
  [15:45:59.833]                       else if (inherits(cond, "condition")) {
  [15:45:59.833]                         computeRestarts <- base::computeRestarts
  [15:45:59.833]                         grepl <- base::grepl
  [15:45:59.833]                         is.null <- base::is.null
  [15:45:59.833]                         restarts <- computeRestarts(cond)
  [15:45:59.833]                         for (restart in restarts) {
  [15:45:59.833]                           name <- restart$name
  [15:45:59.833]                           if (is.null(name)) 
  [15:45:59.833]                             next
  [15:45:59.833]                           if (!grepl("^muffle", name)) 
  [15:45:59.833]                             next
  [15:45:59.833]                           invokeRestart(restart)
  [15:45:59.833]                           muffled <- TRUE
  [15:45:59.833]                           break
  [15:45:59.833]                         }
  [15:45:59.833]                       }
  [15:45:59.833]                       invisible(muffled)
  [15:45:59.833]                     }
  [15:45:59.833]                     muffleCondition(cond)
  [15:45:59.833]                   }
  [15:45:59.833]                 }
  [15:45:59.833]             }
  [15:45:59.833]         }))
  [15:45:59.833]     }, error = function(ex) {
  [15:45:59.833]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.833]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.833]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.833]     }, finally = {
  [15:45:59.833]         {
  [15:45:59.833]             NULL
  [15:45:59.833]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.833]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.833]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.833]                 label = NULL, ...) 
  [15:45:59.833]             {
  [15:45:59.833]                 if (substitute) 
  [15:45:59.833]                   expr <- substitute(expr)
  [15:45:59.833]                 local <- as.logical(local)
  [15:45:59.833]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.833]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.833]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.833]                   label = label, ...)
  [15:45:59.833]                 if (!future$lazy) 
  [15:45:59.833]                   future <- run(future)
  [15:45:59.833]                 invisible(future)
  [15:45:59.833]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.833]         }
  [15:45:59.833]         base::options(...future.oldOptions)
  [15:45:59.833]     })
  [15:45:59.833]     Sys.time
  [15:45:59.833]     if (base::is.na(TRUE)) {
  [15:45:59.833]     }
  [15:45:59.833]     else {
  [15:45:59.833]         base::sink(type = "output", split = FALSE)
  [15:45:59.833]         if (TRUE) {
  [15:45:59.833]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.833]         }
  [15:45:59.833]         else {
  [15:45:59.833]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.833]         }
  [15:45:59.833]         base::close(...future.stdout)
  [15:45:59.833]         ...future.stdout <- NULL
  [15:45:59.833]     }
  [15:45:59.833]     ...future.result$conditions <- ...future.conditions
  [15:45:59.833]     ...future.result
  [15:45:59.833] }
  [15:45:59.838] plan(): Setting new future strategy stack:
  [15:45:59.839] List of future strategies:
  [15:45:59.839] 1. sequential:
  [15:45:59.839]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.839]    - tweaked: FALSE
  [15:45:59.839]    - call: NULL
  [15:45:59.840] plan(): nbrOfWorkers() = 1
  [15:45:59.841] plan(): Setting new future strategy stack:
  [15:45:59.841] List of future strategies:
  [15:45:59.841] 1. sequential:
  [15:45:59.841]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.841]    - tweaked: FALSE
  [15:45:59.841]    - call: plan(strategy)
  [15:45:59.843] plan(): nbrOfWorkers() = 1
  [15:45:59.843] SequentialFuture started (and completed)
  [15:45:59.845] getGlobalsAndPackages() ...
  [15:45:59.845] Searching for globals...
  [15:45:59.847] - globals found: [1] '{'
  [15:45:59.847] Searching for globals ... DONE
  [15:45:59.847] Resolving globals: FALSE
  [15:45:59.848] 
  [15:45:59.849] 
  [15:45:59.849] getGlobalsAndPackages() ... DONE
  [15:45:59.868] Packages needed by the future expression (n = 0): <none>
  [15:45:59.868] Packages needed by future strategies (n = 0): <none>
  [15:45:59.874] {
  [15:45:59.874]     {
  [15:45:59.874]         ...future.startTime <- base::Sys.time()
  [15:45:59.874]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:45:59.874]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:45:59.874]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:45:59.874]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:45:59.874]             future.resolve.recursive = NULL, width = 80L)
  [15:45:59.874]         {
  [15:45:59.874]             {
  [15:45:59.874]                 base::local({
  [15:45:59.874]                   has_future <- base::requireNamespace("future", 
  [15:45:59.874]                     quietly = TRUE)
  [15:45:59.874]                   version <- if (has_future) 
  [15:45:59.874]                     utils::packageVersion("future")
  [15:45:59.874]                   else NULL
  [15:45:59.874]                   if (!has_future || version < "1.8.0") {
  [15:45:59.874]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:45:59.874]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:45:59.874]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:45:59.874]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:45:59.874]                         "release", "version")], collapse = " "), 
  [15:45:59.874]                       hostname = base::Sys.info()[["nodename"]])
  [15:45:59.874]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:45:59.874]                       info)
  [15:45:59.874]                     info <- base::paste(info, collapse = "; ")
  [15:45:59.874]                     if (!has_future) {
  [15:45:59.874]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:45:59.874]                         info)
  [15:45:59.874]                     }
  [15:45:59.874]                     else {
  [15:45:59.874]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:45:59.874]                         info, version)
  [15:45:59.874]                     }
  [15:45:59.874]                     base::stop(msg)
  [15:45:59.874]                   }
  [15:45:59.874]                 })
  [15:45:59.874]             }
  [15:45:59.874]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:45:59.874]         }
  [15:45:59.874]     }
  [15:45:59.874]     if (base::is.na(TRUE)) {
  [15:45:59.874]     }
  [15:45:59.874]     else {
  [15:45:59.874]         if (TRUE) {
  [15:45:59.874]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:45:59.874]                 open = "w")
  [15:45:59.874]         }
  [15:45:59.874]         else {
  [15:45:59.874]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:45:59.874]                 windows = "NUL", "/dev/null"), open = "w")
  [15:45:59.874]         }
  [15:45:59.874]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:45:59.874]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:45:59.874]             base::sink(type = "output", split = FALSE)
  [15:45:59.874]             base::close(...future.stdout)
  [15:45:59.874]         }, add = TRUE)
  [15:45:59.874]     }
  [15:45:59.874]     ...future.frame <- base::sys.nframe()
  [15:45:59.874]     ...future.conditions <- base::list()
  [15:45:59.874]     ...future.rng <- base::globalenv()$.Random.seed
  [15:45:59.874]     ...future.result <- base::tryCatch({
  [15:45:59.874]         base::withCallingHandlers({
  [15:45:59.874]             ...future.value <- base::withVisible(base::local({
  [15:45:59.874]                 4
  [15:45:59.874]             }))
  [15:45:59.874]             future::FutureResult(value = ...future.value$value, 
  [15:45:59.874]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.874]                   ...future.rng), started = ...future.startTime, 
  [15:45:59.874]                 version = "1.8")
  [15:45:59.874]         }, condition = base::local({
  [15:45:59.874]             c <- base::c
  [15:45:59.874]             inherits <- base::inherits
  [15:45:59.874]             invokeRestart <- base::invokeRestart
  [15:45:59.874]             length <- base::length
  [15:45:59.874]             list <- base::list
  [15:45:59.874]             seq.int <- base::seq.int
  [15:45:59.874]             signalCondition <- base::signalCondition
  [15:45:59.874]             sys.calls <- base::sys.calls
  [15:45:59.874]             Sys.time <- base::Sys.time
  [15:45:59.874]             `[[` <- base::`[[`
  [15:45:59.874]             `+` <- base::`+`
  [15:45:59.874]             `<<-` <- base::`<<-`
  [15:45:59.874]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:45:59.874]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:45:59.874]                   3L)]
  [15:45:59.874]             }
  [15:45:59.874]             function(cond) {
  [15:45:59.874]                 if (inherits(cond, "error")) {
  [15:45:59.874]                   sessionInformation <- function() {
  [15:45:59.874]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:45:59.874]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:45:59.874]                       search = base::search(), system = base::Sys.info())
  [15:45:59.874]                   }
  [15:45:59.874]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.874]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:45:59.874]                     cond$call), session = sessionInformation(), 
  [15:45:59.874]                     timestamp = Sys.time(), signaled = 0L)
  [15:45:59.874]                   signalCondition(cond)
  [15:45:59.874]                 }
  [15:45:59.874]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:45:59.874]                 ))) {
  [15:45:59.874]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:45:59.874]                   ...future.conditions[[length(...future.conditions) + 
  [15:45:59.874]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:45:59.874]                   if (!signal) {
  [15:45:59.874]                     muffleCondition <- function (cond) 
  [15:45:59.874]                     {
  [15:45:59.874]                       inherits <- base::inherits
  [15:45:59.874]                       invokeRestart <- base::invokeRestart
  [15:45:59.874]                       muffled <- FALSE
  [15:45:59.874]                       if (inherits(cond, "message")) {
  [15:45:59.874]                         invokeRestart("muffleMessage")
  [15:45:59.874]                         muffled <- TRUE
  [15:45:59.874]                       }
  [15:45:59.874]                       else if (inherits(cond, "warning")) {
  [15:45:59.874]                         invokeRestart("muffleWarning")
  [15:45:59.874]                         muffled <- TRUE
  [15:45:59.874]                       }
  [15:45:59.874]                       else if (inherits(cond, "condition")) {
  [15:45:59.874]                         computeRestarts <- base::computeRestarts
  [15:45:59.874]                         grepl <- base::grepl
  [15:45:59.874]                         is.null <- base::is.null
  [15:45:59.874]                         restarts <- computeRestarts(cond)
  [15:45:59.874]                         for (restart in restarts) {
  [15:45:59.874]                           name <- restart$name
  [15:45:59.874]                           if (is.null(name)) 
  [15:45:59.874]                             next
  [15:45:59.874]                           if (!grepl("^muffle", name)) 
  [15:45:59.874]                             next
  [15:45:59.874]                           invokeRestart(restart)
  [15:45:59.874]                           muffled <- TRUE
  [15:45:59.874]                           break
  [15:45:59.874]                         }
  [15:45:59.874]                       }
  [15:45:59.874]                       invisible(muffled)
  [15:45:59.874]                     }
  [15:45:59.874]                     muffleCondition(cond)
  [15:45:59.874]                   }
  [15:45:59.874]                 }
  [15:45:59.874]             }
  [15:45:59.874]         }))
  [15:45:59.874]     }, error = function(ex) {
  [15:45:59.874]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:45:59.874]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:45:59.874]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:45:59.874]     }, finally = {
  [15:45:59.874]         {
  [15:45:59.874]             NULL
  [15:45:59.874]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:45:59.874]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:45:59.874]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:45:59.874]                 label = NULL, ...) 
  [15:45:59.874]             {
  [15:45:59.874]                 if (substitute) 
  [15:45:59.874]                   expr <- substitute(expr)
  [15:45:59.874]                 local <- as.logical(local)
  [15:45:59.874]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:45:59.874]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:45:59.874]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:45:59.874]                   label = label, ...)
  [15:45:59.874]                 if (!future$lazy) 
  [15:45:59.874]                   future <- run(future)
  [15:45:59.874]                 invisible(future)
  [15:45:59.874]             }), .cleanup = FALSE, .init = FALSE)
  [15:45:59.874]         }
  [15:45:59.874]         base::options(...future.oldOptions)
  [15:45:59.874]     })
  [15:45:59.874]     Sys.time
  [15:45:59.874]     if (base::is.na(TRUE)) {
  [15:45:59.874]     }
  [15:45:59.874]     else {
  [15:45:59.874]         base::sink(type = "output", split = FALSE)
  [15:45:59.874]         if (TRUE) {
  [15:45:59.874]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:45:59.874]         }
  [15:45:59.874]         else {
  [15:45:59.874]             ...future.result["stdout"] <- base::list(NULL)
  [15:45:59.874]         }
  [15:45:59.874]         base::close(...future.stdout)
  [15:45:59.874]         ...future.stdout <- NULL
  [15:45:59.874]     }
  [15:45:59.874]     ...future.result$conditions <- ...future.conditions
  [15:45:59.874]     ...future.result
  [15:45:59.874] }
  [15:45:59.880] plan(): Setting new future strategy stack:
  [15:45:59.880] List of future strategies:
  [15:45:59.880] 1. sequential:
  [15:45:59.880]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.880]    - tweaked: FALSE
  [15:45:59.880]    - call: NULL
  [15:45:59.882] plan(): nbrOfWorkers() = 1
  [15:45:59.883] plan(): Setting new future strategy stack:
  [15:45:59.883] List of future strategies:
  [15:45:59.883] 1. sequential:
  [15:45:59.883]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:45:59.883]    - tweaked: FALSE
  [15:45:59.883]    - call: plan(strategy)
  [15:45:59.885] plan(): nbrOfWorkers() = 1
  [15:45:59.885] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ca2ac0cd10> 
  Classes 'listenv', 'environment' <environment: 0x55ca2ae57910> 
   - 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" ...
  [15:45:59.912] resolve() on list environment ...
  [15:45:59.913]  recursive: 0
  [15:45:59.932]  length: 6
  [15:45:59.933]  elements: 'a', 'b', 'c', 'd', '', ''
  [15:45:59.933] signalConditionsASAP(numeric, pos=1) ...
  [15:45:59.934] - nx: 6
  [15:45:59.934] - relay: TRUE
  [15:45:59.934] - stdout: TRUE
  [15:45:59.935] - signal: TRUE
  [15:45:59.935] - resignal: FALSE
  [15:45:59.935] - force: TRUE
  [15:45:59.935] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.936] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.936]  - until=2
  [15:45:59.937]  - relaying element #2
  [15:45:59.937] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.937] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.938] signalConditionsASAP(NULL, pos=1) ... done
  [15:45:59.938]  length: 5 (resolved future 1)
  [15:45:59.938] Future #2
  [15:45:59.939] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:45:59.939] - nx: 6
  [15:45:59.940] - relay: TRUE
  [15:45:59.940] - stdout: TRUE
  [15:45:59.940] - signal: TRUE
  [15:45:59.941] - resignal: FALSE
  [15:45:59.941] - force: TRUE
  [15:45:59.941] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.942] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.942]  - until=2
  [15:45:59.942]  - relaying element #2
  [15:45:59.943] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.943] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.944] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:45:59.944]  length: 4 (resolved future 2)
  [15:45:59.945] Future #3
  [15:45:59.945] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:45:59.945] - nx: 6
  [15:45:59.946] - relay: TRUE
  [15:45:59.946] - stdout: TRUE
  [15:45:59.946] - signal: TRUE
  [15:45:59.947] - resignal: FALSE
  [15:45:59.947] - force: TRUE
  [15:45:59.947] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.948] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:45:59.948]  - until=3
  [15:45:59.948]  - relaying element #3
  [15:45:59.949] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.949] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.950] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:45:59.950]  length: 3 (resolved future 3)
  [15:45:59.951] Future #4
  [15:45:59.951] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:45:59.951] - nx: 6
  [15:45:59.952] - relay: TRUE
  [15:45:59.952] - stdout: TRUE
  [15:45:59.952] - signal: TRUE
  [15:45:59.953] - resignal: FALSE
  [15:45:59.953] - force: TRUE
  [15:45:59.953] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.954] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:45:59.954]  - until=4
  [15:45:59.954]  - relaying element #4
  [15:45:59.955] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.955] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.956] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:45:59.956]  length: 2 (resolved future 4)
  [15:45:59.956] signalConditionsASAP(NULL, pos=5) ...
  [15:45:59.957] - nx: 6
  [15:45:59.957] - relay: TRUE
  [15:45:59.957] - stdout: TRUE
  [15:45:59.958] - signal: TRUE
  [15:45:59.958] - resignal: FALSE
  [15:45:59.958] - force: TRUE
  [15:45:59.959] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.959] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.959]  - until=6
  [15:45:59.960]  - relaying element #6
  [15:45:59.960] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:59.960] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.961] signalConditionsASAP(NULL, pos=5) ... done
  [15:45:59.961]  length: 1 (resolved future 5)
  [15:45:59.962] signalConditionsASAP(numeric, pos=6) ...
  [15:45:59.962] - nx: 6
  [15:45:59.962] - relay: TRUE
  [15:45:59.963] - stdout: TRUE
  [15:45:59.963] - signal: TRUE
  [15:45:59.963] - resignal: FALSE
  [15:45:59.964] - force: TRUE
  [15:45:59.964] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:45:59.964] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.965]  - until=6
  [15:45:59.965] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.965] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.966] signalConditionsASAP(numeric, pos=6) ... done
  [15:45:59.966]  length: 0 (resolved future 6)
  [15:45:59.966] Relaying remaining futures
  [15:45:59.967] signalConditionsASAP(NULL, pos=0) ...
  [15:45:59.967] - nx: 6
  [15:45:59.967] - relay: TRUE
  [15:45:59.968] - stdout: TRUE
  [15:45:59.968] - signal: TRUE
  [15:45:59.968] - resignal: FALSE
  [15:45:59.969] - force: TRUE
  [15:45:59.969] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.969] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [15:45:59.970] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:45:59.970] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:45:59.971] signalConditionsASAP(NULL, pos=0) ... done
  [15:45:59.971] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ca28f37088> 
   - 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)
  [15:45:59.989] getGlobalsAndPackages() ...
  [15:45:59.990] Searching for globals...
  [15:45:59.991] 
  [15:45:59.991] Searching for globals ... DONE
  [15:45:59.991] - globals: [0] <none>
  [15:45:59.992] getGlobalsAndPackages() ... DONE
  [15:45:59.994] Packages needed by the future expression (n = 0): <none>
  [15:45:59.995] Packages needed by future strategies (n = 0): <none>
  [15:46:00.001] {
  [15:46:00.001]     {
  [15:46:00.001]         ...future.startTime <- base::Sys.time()
  [15:46:00.001]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:46:00.001]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:46:00.001]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:46:00.001]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:46:00.001]             future.resolve.recursive = NULL, width = 80L)
  [15:46:00.001]         {
  [15:46:00.001]             {
  [15:46:00.001]                 base::local({
  [15:46:00.001]                   has_future <- base::requireNamespace("future", 
  [15:46:00.001]                     quietly = TRUE)
  [15:46:00.001]                   version <- if (has_future) 
  [15:46:00.001]                     utils::packageVersion("future")
  [15:46:00.001]                   else NULL
  [15:46:00.001]                   if (!has_future || version < "1.8.0") {
  [15:46:00.001]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:46:00.001]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:46:00.001]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:46:00.001]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:46:00.001]                         "release", "version")], collapse = " "), 
  [15:46:00.001]                       hostname = base::Sys.info()[["nodename"]])
  [15:46:00.001]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:46:00.001]                       info)
  [15:46:00.001]                     info <- base::paste(info, collapse = "; ")
  [15:46:00.001]                     if (!has_future) {
  [15:46:00.001]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:46:00.001]                         info)
  [15:46:00.001]                     }
  [15:46:00.001]                     else {
  [15:46:00.001]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:46:00.001]                         info, version)
  [15:46:00.001]                     }
  [15:46:00.001]                     base::stop(msg)
  [15:46:00.001]                   }
  [15:46:00.001]                 })
  [15:46:00.001]             }
  [15:46:00.001]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:46:00.001]         }
  [15:46:00.001]     }
  [15:46:00.001]     if (base::is.na(TRUE)) {
  [15:46:00.001]     }
  [15:46:00.001]     else {
  [15:46:00.001]         if (TRUE) {
  [15:46:00.001]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:46:00.001]                 open = "w")
  [15:46:00.001]         }
  [15:46:00.001]         else {
  [15:46:00.001]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:46:00.001]                 windows = "NUL", "/dev/null"), open = "w")
  [15:46:00.001]         }
  [15:46:00.001]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:46:00.001]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:46:00.001]             base::sink(type = "output", split = FALSE)
  [15:46:00.001]             base::close(...future.stdout)
  [15:46:00.001]         }, add = TRUE)
  [15:46:00.001]     }
  [15:46:00.001]     ...future.frame <- base::sys.nframe()
  [15:46:00.001]     ...future.conditions <- base::list()
  [15:46:00.001]     ...future.rng <- base::globalenv()$.Random.seed
  [15:46:00.001]     ...future.result <- base::tryCatch({
  [15:46:00.001]         base::withCallingHandlers({
  [15:46:00.001]             ...future.value <- base::withVisible(base::local(2))
  [15:46:00.001]             future::FutureResult(value = ...future.value$value, 
  [15:46:00.001]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.001]                   ...future.rng), started = ...future.startTime, 
  [15:46:00.001]                 version = "1.8")
  [15:46:00.001]         }, condition = base::local({
  [15:46:00.001]             c <- base::c
  [15:46:00.001]             inherits <- base::inherits
  [15:46:00.001]             invokeRestart <- base::invokeRestart
  [15:46:00.001]             length <- base::length
  [15:46:00.001]             list <- base::list
  [15:46:00.001]             seq.int <- base::seq.int
  [15:46:00.001]             signalCondition <- base::signalCondition
  [15:46:00.001]             sys.calls <- base::sys.calls
  [15:46:00.001]             Sys.time <- base::Sys.time
  [15:46:00.001]             `[[` <- base::`[[`
  [15:46:00.001]             `+` <- base::`+`
  [15:46:00.001]             `<<-` <- base::`<<-`
  [15:46:00.001]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:46:00.001]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:46:00.001]                   3L)]
  [15:46:00.001]             }
  [15:46:00.001]             function(cond) {
  [15:46:00.001]                 if (inherits(cond, "error")) {
  [15:46:00.001]                   sessionInformation <- function() {
  [15:46:00.001]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:46:00.001]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:46:00.001]                       search = base::search(), system = base::Sys.info())
  [15:46:00.001]                   }
  [15:46:00.001]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.001]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:46:00.001]                     cond$call), session = sessionInformation(), 
  [15:46:00.001]                     timestamp = Sys.time(), signaled = 0L)
  [15:46:00.001]                   signalCondition(cond)
  [15:46:00.001]                 }
  [15:46:00.001]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:46:00.001]                 ))) {
  [15:46:00.001]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:46:00.001]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.001]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:46:00.001]                   if (!signal) {
  [15:46:00.001]                     muffleCondition <- function (cond) 
  [15:46:00.001]                     {
  [15:46:00.001]                       inherits <- base::inherits
  [15:46:00.001]                       invokeRestart <- base::invokeRestart
  [15:46:00.001]                       muffled <- FALSE
  [15:46:00.001]                       if (inherits(cond, "message")) {
  [15:46:00.001]                         invokeRestart("muffleMessage")
  [15:46:00.001]                         muffled <- TRUE
  [15:46:00.001]                       }
  [15:46:00.001]                       else if (inherits(cond, "warning")) {
  [15:46:00.001]                         invokeRestart("muffleWarning")
  [15:46:00.001]                         muffled <- TRUE
  [15:46:00.001]                       }
  [15:46:00.001]                       else if (inherits(cond, "condition")) {
  [15:46:00.001]                         computeRestarts <- base::computeRestarts
  [15:46:00.001]                         grepl <- base::grepl
  [15:46:00.001]                         is.null <- base::is.null
  [15:46:00.001]                         restarts <- computeRestarts(cond)
  [15:46:00.001]                         for (restart in restarts) {
  [15:46:00.001]                           name <- restart$name
  [15:46:00.001]                           if (is.null(name)) 
  [15:46:00.001]                             next
  [15:46:00.001]                           if (!grepl("^muffle", name)) 
  [15:46:00.001]                             next
  [15:46:00.001]                           invokeRestart(restart)
  [15:46:00.001]                           muffled <- TRUE
  [15:46:00.001]                           break
  [15:46:00.001]                         }
  [15:46:00.001]                       }
  [15:46:00.001]                       invisible(muffled)
  [15:46:00.001]                     }
  [15:46:00.001]                     muffleCondition(cond)
  [15:46:00.001]                   }
  [15:46:00.001]                 }
  [15:46:00.001]             }
  [15:46:00.001]         }))
  [15:46:00.001]     }, error = function(ex) {
  [15:46:00.001]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:46:00.001]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.001]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:46:00.001]     }, finally = {
  [15:46:00.001]         {
  [15:46:00.001]             NULL
  [15:46:00.001]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:46:00.001]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:46:00.001]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:46:00.001]                 label = NULL, ...) 
  [15:46:00.001]             {
  [15:46:00.001]                 if (substitute) 
  [15:46:00.001]                   expr <- substitute(expr)
  [15:46:00.001]                 local <- as.logical(local)
  [15:46:00.001]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:46:00.001]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:46:00.001]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:46:00.001]                   label = label, ...)
  [15:46:00.001]                 if (!future$lazy) 
  [15:46:00.001]                   future <- run(future)
  [15:46:00.001]                 invisible(future)
  [15:46:00.001]             }), .cleanup = FALSE, .init = FALSE)
  [15:46:00.001]         }
  [15:46:00.001]         base::options(...future.oldOptions)
  [15:46:00.001]     })
  [15:46:00.001]     Sys.time
  [15:46:00.001]     if (base::is.na(TRUE)) {
  [15:46:00.001]     }
  [15:46:00.001]     else {
  [15:46:00.001]         base::sink(type = "output", split = FALSE)
  [15:46:00.001]         if (TRUE) {
  [15:46:00.001]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:46:00.001]         }
  [15:46:00.001]         else {
  [15:46:00.001]             ...future.result["stdout"] <- base::list(NULL)
  [15:46:00.001]         }
  [15:46:00.001]         base::close(...future.stdout)
  [15:46:00.001]         ...future.stdout <- NULL
  [15:46:00.001]     }
  [15:46:00.001]     ...future.result$conditions <- ...future.conditions
  [15:46:00.001]     ...future.result
  [15:46:00.001] }
  [15:46:00.007] plan(): Setting new future strategy stack:
  [15:46:00.007] List of future strategies:
  [15:46:00.007] 1. sequential:
  [15:46:00.007]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.007]    - tweaked: FALSE
  [15:46:00.007]    - call: NULL
  [15:46:00.008] plan(): nbrOfWorkers() = 1
  [15:46:00.009] plan(): Setting new future strategy stack:
  [15:46:00.010] List of future strategies:
  [15:46:00.010] 1. sequential:
  [15:46:00.010]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.010]    - tweaked: FALSE
  [15:46:00.010]    - call: plan(strategy)
  [15:46:00.011] plan(): nbrOfWorkers() = 1
  [15:46:00.012] SequentialFuture started (and completed)
  [15:46:00.012] getGlobalsAndPackages() ...
  [15:46:00.012] Searching for globals...
  [15:46:00.013] 
  [15:46:00.014] Searching for globals ... DONE
  [15:46:00.014] - globals: [0] <none>
  [15:46:00.014] getGlobalsAndPackages() ... DONE
  [15:46:00.016] Packages needed by the future expression (n = 0): <none>
  [15:46:00.017] Packages needed by future strategies (n = 0): <none>
  [15:46:00.023] {
  [15:46:00.023]     {
  [15:46:00.023]         ...future.startTime <- base::Sys.time()
  [15:46:00.023]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:46:00.023]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:46:00.023]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:46:00.023]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:46:00.023]             future.resolve.recursive = NULL, width = 80L)
  [15:46:00.023]         {
  [15:46:00.023]             {
  [15:46:00.023]                 base::local({
  [15:46:00.023]                   has_future <- base::requireNamespace("future", 
  [15:46:00.023]                     quietly = TRUE)
  [15:46:00.023]                   version <- if (has_future) 
  [15:46:00.023]                     utils::packageVersion("future")
  [15:46:00.023]                   else NULL
  [15:46:00.023]                   if (!has_future || version < "1.8.0") {
  [15:46:00.023]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:46:00.023]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:46:00.023]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:46:00.023]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:46:00.023]                         "release", "version")], collapse = " "), 
  [15:46:00.023]                       hostname = base::Sys.info()[["nodename"]])
  [15:46:00.023]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:46:00.023]                       info)
  [15:46:00.023]                     info <- base::paste(info, collapse = "; ")
  [15:46:00.023]                     if (!has_future) {
  [15:46:00.023]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:46:00.023]                         info)
  [15:46:00.023]                     }
  [15:46:00.023]                     else {
  [15:46:00.023]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:46:00.023]                         info, version)
  [15:46:00.023]                     }
  [15:46:00.023]                     base::stop(msg)
  [15:46:00.023]                   }
  [15:46:00.023]                 })
  [15:46:00.023]             }
  [15:46:00.023]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:46:00.023]         }
  [15:46:00.023]     }
  [15:46:00.023]     if (base::is.na(TRUE)) {
  [15:46:00.023]     }
  [15:46:00.023]     else {
  [15:46:00.023]         if (TRUE) {
  [15:46:00.023]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:46:00.023]                 open = "w")
  [15:46:00.023]         }
  [15:46:00.023]         else {
  [15:46:00.023]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:46:00.023]                 windows = "NUL", "/dev/null"), open = "w")
  [15:46:00.023]         }
  [15:46:00.023]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:46:00.023]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:46:00.023]             base::sink(type = "output", split = FALSE)
  [15:46:00.023]             base::close(...future.stdout)
  [15:46:00.023]         }, add = TRUE)
  [15:46:00.023]     }
  [15:46:00.023]     ...future.frame <- base::sys.nframe()
  [15:46:00.023]     ...future.conditions <- base::list()
  [15:46:00.023]     ...future.rng <- base::globalenv()$.Random.seed
  [15:46:00.023]     ...future.result <- base::tryCatch({
  [15:46:00.023]         base::withCallingHandlers({
  [15:46:00.023]             ...future.value <- base::withVisible(base::local(NULL))
  [15:46:00.023]             future::FutureResult(value = ...future.value$value, 
  [15:46:00.023]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.023]                   ...future.rng), started = ...future.startTime, 
  [15:46:00.023]                 version = "1.8")
  [15:46:00.023]         }, condition = base::local({
  [15:46:00.023]             c <- base::c
  [15:46:00.023]             inherits <- base::inherits
  [15:46:00.023]             invokeRestart <- base::invokeRestart
  [15:46:00.023]             length <- base::length
  [15:46:00.023]             list <- base::list
  [15:46:00.023]             seq.int <- base::seq.int
  [15:46:00.023]             signalCondition <- base::signalCondition
  [15:46:00.023]             sys.calls <- base::sys.calls
  [15:46:00.023]             Sys.time <- base::Sys.time
  [15:46:00.023]             `[[` <- base::`[[`
  [15:46:00.023]             `+` <- base::`+`
  [15:46:00.023]             `<<-` <- base::`<<-`
  [15:46:00.023]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:46:00.023]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:46:00.023]                   3L)]
  [15:46:00.023]             }
  [15:46:00.023]             function(cond) {
  [15:46:00.023]                 if (inherits(cond, "error")) {
  [15:46:00.023]                   sessionInformation <- function() {
  [15:46:00.023]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:46:00.023]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:46:00.023]                       search = base::search(), system = base::Sys.info())
  [15:46:00.023]                   }
  [15:46:00.023]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.023]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:46:00.023]                     cond$call), session = sessionInformation(), 
  [15:46:00.023]                     timestamp = Sys.time(), signaled = 0L)
  [15:46:00.023]                   signalCondition(cond)
  [15:46:00.023]                 }
  [15:46:00.023]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:46:00.023]                 ))) {
  [15:46:00.023]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:46:00.023]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.023]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:46:00.023]                   if (!signal) {
  [15:46:00.023]                     muffleCondition <- function (cond) 
  [15:46:00.023]                     {
  [15:46:00.023]                       inherits <- base::inherits
  [15:46:00.023]                       invokeRestart <- base::invokeRestart
  [15:46:00.023]                       muffled <- FALSE
  [15:46:00.023]                       if (inherits(cond, "message")) {
  [15:46:00.023]                         invokeRestart("muffleMessage")
  [15:46:00.023]                         muffled <- TRUE
  [15:46:00.023]                       }
  [15:46:00.023]                       else if (inherits(cond, "warning")) {
  [15:46:00.023]                         invokeRestart("muffleWarning")
  [15:46:00.023]                         muffled <- TRUE
  [15:46:00.023]                       }
  [15:46:00.023]                       else if (inherits(cond, "condition")) {
  [15:46:00.023]                         computeRestarts <- base::computeRestarts
  [15:46:00.023]                         grepl <- base::grepl
  [15:46:00.023]                         is.null <- base::is.null
  [15:46:00.023]                         restarts <- computeRestarts(cond)
  [15:46:00.023]                         for (restart in restarts) {
  [15:46:00.023]                           name <- restart$name
  [15:46:00.023]                           if (is.null(name)) 
  [15:46:00.023]                             next
  [15:46:00.023]                           if (!grepl("^muffle", name)) 
  [15:46:00.023]                             next
  [15:46:00.023]                           invokeRestart(restart)
  [15:46:00.023]                           muffled <- TRUE
  [15:46:00.023]                           break
  [15:46:00.023]                         }
  [15:46:00.023]                       }
  [15:46:00.023]                       invisible(muffled)
  [15:46:00.023]                     }
  [15:46:00.023]                     muffleCondition(cond)
  [15:46:00.023]                   }
  [15:46:00.023]                 }
  [15:46:00.023]             }
  [15:46:00.023]         }))
  [15:46:00.023]     }, error = function(ex) {
  [15:46:00.023]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:46:00.023]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.023]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:46:00.023]     }, finally = {
  [15:46:00.023]         {
  [15:46:00.023]             NULL
  [15:46:00.023]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:46:00.023]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:46:00.023]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:46:00.023]                 label = NULL, ...) 
  [15:46:00.023]             {
  [15:46:00.023]                 if (substitute) 
  [15:46:00.023]                   expr <- substitute(expr)
  [15:46:00.023]                 local <- as.logical(local)
  [15:46:00.023]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:46:00.023]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:46:00.023]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:46:00.023]                   label = label, ...)
  [15:46:00.023]                 if (!future$lazy) 
  [15:46:00.023]                   future <- run(future)
  [15:46:00.023]                 invisible(future)
  [15:46:00.023]             }), .cleanup = FALSE, .init = FALSE)
  [15:46:00.023]         }
  [15:46:00.023]         base::options(...future.oldOptions)
  [15:46:00.023]     })
  [15:46:00.023]     Sys.time
  [15:46:00.023]     if (base::is.na(TRUE)) {
  [15:46:00.023]     }
  [15:46:00.023]     else {
  [15:46:00.023]         base::sink(type = "output", split = FALSE)
  [15:46:00.023]         if (TRUE) {
  [15:46:00.023]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:46:00.023]         }
  [15:46:00.023]         else {
  [15:46:00.023]             ...future.result["stdout"] <- base::list(NULL)
  [15:46:00.023]         }
  [15:46:00.023]         base::close(...future.stdout)
  [15:46:00.023]         ...future.stdout <- NULL
  [15:46:00.023]     }
  [15:46:00.023]     ...future.result$conditions <- ...future.conditions
  [15:46:00.023]     ...future.result
  [15:46:00.023] }
  [15:46:00.028] plan(): Setting new future strategy stack:
  [15:46:00.028] List of future strategies:
  [15:46:00.028] 1. sequential:
  [15:46:00.028]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.028]    - tweaked: FALSE
  [15:46:00.028]    - call: NULL
  [15:46:00.029] plan(): nbrOfWorkers() = 1
  [15:46:00.031] plan(): Setting new future strategy stack:
  [15:46:00.031] List of future strategies:
  [15:46:00.031] 1. sequential:
  [15:46:00.031]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.031]    - tweaked: FALSE
  [15:46:00.031]    - call: plan(strategy)
  [15:46:00.032] plan(): nbrOfWorkers() = 1
  [15:46:00.033] SequentialFuture started (and completed)
  [15:46:00.034] getGlobalsAndPackages() ...
  [15:46:00.035] Searching for globals...
  [15:46:00.036] - globals found: [1] '{'
  [15:46:00.037] Searching for globals ... DONE
  [15:46:00.037] Resolving globals: FALSE
  [15:46:00.038] 
  [15:46:00.038] 
  [15:46:00.039] getGlobalsAndPackages() ... DONE
  [15:46:00.041] Packages needed by the future expression (n = 0): <none>
  [15:46:00.041] Packages needed by future strategies (n = 0): <none>
  [15:46:00.064] {
  [15:46:00.064]     {
  [15:46:00.064]         ...future.startTime <- base::Sys.time()
  [15:46:00.064]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:46:00.064]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:46:00.064]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:46:00.064]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:46:00.064]             future.resolve.recursive = NULL, width = 80L)
  [15:46:00.064]         {
  [15:46:00.064]             {
  [15:46:00.064]                 base::local({
  [15:46:00.064]                   has_future <- base::requireNamespace("future", 
  [15:46:00.064]                     quietly = TRUE)
  [15:46:00.064]                   version <- if (has_future) 
  [15:46:00.064]                     utils::packageVersion("future")
  [15:46:00.064]                   else NULL
  [15:46:00.064]                   if (!has_future || version < "1.8.0") {
  [15:46:00.064]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:46:00.064]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:46:00.064]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:46:00.064]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:46:00.064]                         "release", "version")], collapse = " "), 
  [15:46:00.064]                       hostname = base::Sys.info()[["nodename"]])
  [15:46:00.064]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:46:00.064]                       info)
  [15:46:00.064]                     info <- base::paste(info, collapse = "; ")
  [15:46:00.064]                     if (!has_future) {
  [15:46:00.064]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:46:00.064]                         info)
  [15:46:00.064]                     }
  [15:46:00.064]                     else {
  [15:46:00.064]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:46:00.064]                         info, version)
  [15:46:00.064]                     }
  [15:46:00.064]                     base::stop(msg)
  [15:46:00.064]                   }
  [15:46:00.064]                 })
  [15:46:00.064]             }
  [15:46:00.064]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:46:00.064]         }
  [15:46:00.064]     }
  [15:46:00.064]     if (base::is.na(TRUE)) {
  [15:46:00.064]     }
  [15:46:00.064]     else {
  [15:46:00.064]         if (TRUE) {
  [15:46:00.064]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:46:00.064]                 open = "w")
  [15:46:00.064]         }
  [15:46:00.064]         else {
  [15:46:00.064]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:46:00.064]                 windows = "NUL", "/dev/null"), open = "w")
  [15:46:00.064]         }
  [15:46:00.064]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:46:00.064]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:46:00.064]             base::sink(type = "output", split = FALSE)
  [15:46:00.064]             base::close(...future.stdout)
  [15:46:00.064]         }, add = TRUE)
  [15:46:00.064]     }
  [15:46:00.064]     ...future.frame <- base::sys.nframe()
  [15:46:00.064]     ...future.conditions <- base::list()
  [15:46:00.064]     ...future.rng <- base::globalenv()$.Random.seed
  [15:46:00.064]     ...future.result <- base::tryCatch({
  [15:46:00.064]         base::withCallingHandlers({
  [15:46:00.064]             ...future.value <- base::withVisible(base::local({
  [15:46:00.064]                 4
  [15:46:00.064]             }))
  [15:46:00.064]             future::FutureResult(value = ...future.value$value, 
  [15:46:00.064]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.064]                   ...future.rng), started = ...future.startTime, 
  [15:46:00.064]                 version = "1.8")
  [15:46:00.064]         }, condition = base::local({
  [15:46:00.064]             c <- base::c
  [15:46:00.064]             inherits <- base::inherits
  [15:46:00.064]             invokeRestart <- base::invokeRestart
  [15:46:00.064]             length <- base::length
  [15:46:00.064]             list <- base::list
  [15:46:00.064]             seq.int <- base::seq.int
  [15:46:00.064]             signalCondition <- base::signalCondition
  [15:46:00.064]             sys.calls <- base::sys.calls
  [15:46:00.064]             Sys.time <- base::Sys.time
  [15:46:00.064]             `[[` <- base::`[[`
  [15:46:00.064]             `+` <- base::`+`
  [15:46:00.064]             `<<-` <- base::`<<-`
  [15:46:00.064]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [15:46:00.064]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [15:46:00.064]                   3L)]
  [15:46:00.064]             }
  [15:46:00.064]             function(cond) {
  [15:46:00.064]                 if (inherits(cond, "error")) {
  [15:46:00.064]                   sessionInformation <- function() {
  [15:46:00.064]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [15:46:00.064]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [15:46:00.064]                       search = base::search(), system = base::Sys.info())
  [15:46:00.064]                   }
  [15:46:00.064]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.064]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [15:46:00.064]                     cond$call), session = sessionInformation(), 
  [15:46:00.064]                     timestamp = Sys.time(), signaled = 0L)
  [15:46:00.064]                   signalCondition(cond)
  [15:46:00.064]                 }
  [15:46:00.064]                 else if (inherits(cond, c("condition", "immediateCondition"
  [15:46:00.064]                 ))) {
  [15:46:00.064]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [15:46:00.064]                   ...future.conditions[[length(...future.conditions) + 
  [15:46:00.064]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [15:46:00.064]                   if (!signal) {
  [15:46:00.064]                     muffleCondition <- function (cond) 
  [15:46:00.064]                     {
  [15:46:00.064]                       inherits <- base::inherits
  [15:46:00.064]                       invokeRestart <- base::invokeRestart
  [15:46:00.064]                       muffled <- FALSE
  [15:46:00.064]                       if (inherits(cond, "message")) {
  [15:46:00.064]                         invokeRestart("muffleMessage")
  [15:46:00.064]                         muffled <- TRUE
  [15:46:00.064]                       }
  [15:46:00.064]                       else if (inherits(cond, "warning")) {
  [15:46:00.064]                         invokeRestart("muffleWarning")
  [15:46:00.064]                         muffled <- TRUE
  [15:46:00.064]                       }
  [15:46:00.064]                       else if (inherits(cond, "condition")) {
  [15:46:00.064]                         computeRestarts <- base::computeRestarts
  [15:46:00.064]                         grepl <- base::grepl
  [15:46:00.064]                         is.null <- base::is.null
  [15:46:00.064]                         restarts <- computeRestarts(cond)
  [15:46:00.064]                         for (restart in restarts) {
  [15:46:00.064]                           name <- restart$name
  [15:46:00.064]                           if (is.null(name)) 
  [15:46:00.064]                             next
  [15:46:00.064]                           if (!grepl("^muffle", name)) 
  [15:46:00.064]                             next
  [15:46:00.064]                           invokeRestart(restart)
  [15:46:00.064]                           muffled <- TRUE
  [15:46:00.064]                           break
  [15:46:00.064]                         }
  [15:46:00.064]                       }
  [15:46:00.064]                       invisible(muffled)
  [15:46:00.064]                     }
  [15:46:00.064]                     muffleCondition(cond)
  [15:46:00.064]                   }
  [15:46:00.064]                 }
  [15:46:00.064]             }
  [15:46:00.064]         }))
  [15:46:00.064]     }, error = function(ex) {
  [15:46:00.064]         base::structure(base::list(value = NULL, visible = NULL, 
  [15:46:00.064]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [15:46:00.064]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [15:46:00.064]     }, finally = {
  [15:46:00.064]         {
  [15:46:00.064]             NULL
  [15:46:00.064]             future::plan(list(function (expr, envir = parent.frame(), 
  [15:46:00.064]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [15:46:00.064]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [15:46:00.064]                 label = NULL, ...) 
  [15:46:00.064]             {
  [15:46:00.064]                 if (substitute) 
  [15:46:00.064]                   expr <- substitute(expr)
  [15:46:00.064]                 local <- as.logical(local)
  [15:46:00.064]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [15:46:00.064]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [15:46:00.064]                   globals = globals, local = local, earlySignal = earlySignal, 
  [15:46:00.064]                   label = label, ...)
  [15:46:00.064]                 if (!future$lazy) 
  [15:46:00.064]                   future <- run(future)
  [15:46:00.064]                 invisible(future)
  [15:46:00.064]             }), .cleanup = FALSE, .init = FALSE)
  [15:46:00.064]         }
  [15:46:00.064]         base::options(...future.oldOptions)
  [15:46:00.064]     })
  [15:46:00.064]     Sys.time
  [15:46:00.064]     if (base::is.na(TRUE)) {
  [15:46:00.064]     }
  [15:46:00.064]     else {
  [15:46:00.064]         base::sink(type = "output", split = FALSE)
  [15:46:00.064]         if (TRUE) {
  [15:46:00.064]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [15:46:00.064]         }
  [15:46:00.064]         else {
  [15:46:00.064]             ...future.result["stdout"] <- base::list(NULL)
  [15:46:00.064]         }
  [15:46:00.064]         base::close(...future.stdout)
  [15:46:00.064]         ...future.stdout <- NULL
  [15:46:00.064]     }
  [15:46:00.064]     ...future.result$conditions <- ...future.conditions
  [15:46:00.064]     ...future.result
  [15:46:00.064] }
  [15:46:00.070] plan(): Setting new future strategy stack:
  [15:46:00.070] List of future strategies:
  [15:46:00.070] 1. sequential:
  [15:46:00.070]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.070]    - tweaked: FALSE
  [15:46:00.070]    - call: NULL
  [15:46:00.072] plan(): nbrOfWorkers() = 1
  [15:46:00.073] plan(): Setting new future strategy stack:
  [15:46:00.073] List of future strategies:
  [15:46:00.073] 1. sequential:
  [15:46:00.073]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [15:46:00.073]    - tweaked: FALSE
  [15:46:00.073]    - call: plan(strategy)
  [15:46:00.098] plan(): nbrOfWorkers() = 1
  [15:46:00.099] SequentialFuture started (and completed)
  Classes 'listenv', 'environment' <environment: 0x55ca2ac6d110> 
  Classes 'listenv', 'environment' <environment: 0x55ca2913dfb0> 
   - 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" ...
  [15:46:00.120] resolve() on list environment ...
  [15:46:00.121]  recursive: 0
  [15:46:00.124]  length: 6
  [15:46:00.124]  elements: 'a', 'b', 'c', 'd', '', ''
  [15:46:00.125] signalConditionsASAP(numeric, pos=1) ...
  [15:46:00.125] - nx: 6
  [15:46:00.126] - relay: TRUE
  [15:46:00.126] - stdout: TRUE
  [15:46:00.126] - signal: TRUE
  [15:46:00.126] - resignal: FALSE
  [15:46:00.127] - force: TRUE
  [15:46:00.127] - relayed: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.127] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.128]  - until=2
  [15:46:00.128]  - relaying element #2
  [15:46:00.128] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.129] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.129] signalConditionsASAP(NULL, pos=1) ... done
  [15:46:00.129]  length: 5 (resolved future 1)
  [15:46:00.130] Future #2
  [15:46:00.130] signalConditionsASAP(SequentialFuture, pos=2) ...
  [15:46:00.131] - nx: 6
  [15:46:00.131] - relay: TRUE
  [15:46:00.131] - stdout: TRUE
  [15:46:00.131] - signal: TRUE
  [15:46:00.132] - resignal: FALSE
  [15:46:00.132] - force: TRUE
  [15:46:00.132] - relayed: [n=6] TRUE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.133] - queued futures: [n=6] FALSE, FALSE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.133]  - until=2
  [15:46:00.133]  - relaying element #2
  [15:46:00.134] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.134] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.134] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [15:46:00.135]  length: 4 (resolved future 2)
  [15:46:00.135] Future #3
  [15:46:00.136] signalConditionsASAP(SequentialFuture, pos=3) ...
  [15:46:00.136] - nx: 6
  [15:46:00.136] - relay: TRUE
  [15:46:00.137] - stdout: TRUE
  [15:46:00.137] - signal: TRUE
  [15:46:00.137] - resignal: FALSE
  [15:46:00.137] - force: TRUE
  [15:46:00.138] - relayed: [n=6] TRUE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.138] - queued futures: [n=6] FALSE, TRUE, FALSE, FALSE, FALSE, FALSE
  [15:46:00.138]  - until=3
  [15:46:00.139]  - relaying element #3
  [15:46:00.139] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:46:00.140] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:46:00.140] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [15:46:00.140]  length: 3 (resolved future 3)
  [15:46:00.141] Future #4
  [15:46:00.141] signalConditionsASAP(SequentialFuture, pos=4) ...
  [15:46:00.141] - nx: 6
  [15:46:00.142] - relay: TRUE
  [15:46:00.142] - stdout: TRUE
  [15:46:00.142] - signal: TRUE
  [15:46:00.143] - resignal: FALSE
  [15:46:00.143] - force: TRUE
  [15:46:00.143] - relayed: [n=6] TRUE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:46:00.144] - queued futures: [n=6] FALSE, TRUE, TRUE, FALSE, FALSE, FALSE
  [15:46:00.144]  - until=4
  [15:46:00.145]  - relaying element #4
  [15:46:00.145] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.146] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.146] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [15:46:00.146]  length: 2 (resolved future 4)
  [15:46:00.147] signalConditionsASAP(NULL, pos=5) ...
  [15:46:00.147] - nx: 6
  [15:46:00.148] - relay: TRUE
  [15:46:00.148] - stdout: TRUE
  [15:46:00.148] - signal: TRUE
  [15:46:00.148] - resignal: FALSE
  [15:46:00.149] - force: TRUE
  [15:46:00.149] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.149] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.150]  - until=6
  [15:46:00.150]  - relaying element #6
  [15:46:00.151] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:46:00.151] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.151] signalConditionsASAP(NULL, pos=5) ... done
  [15:46:00.152]  length: 1 (resolved future 5)
  [15:46:00.152] signalConditionsASAP(numeric, pos=6) ...
  [15:46:00.152] - nx: 6
  [15:46:00.153] - relay: TRUE
  [15:46:00.153] - stdout: TRUE
  [15:46:00.153] - signal: TRUE
  [15:46:00.154] - resignal: FALSE
  [15:46:00.154] - force: TRUE
  [15:46:00.154] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, FALSE
  [15:46:00.155] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.155]  - until=6
  [15:46:00.155] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:46:00.156] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.156] signalConditionsASAP(numeric, pos=6) ... done
  [15:46:00.156]  length: 0 (resolved future 6)
  [15:46:00.157] Relaying remaining futures
  [15:46:00.157] signalConditionsASAP(NULL, pos=0) ...
  [15:46:00.157] - nx: 6
  [15:46:00.158] - relay: TRUE
  [15:46:00.158] - stdout: TRUE
  [15:46:00.158] - signal: TRUE
  [15:46:00.159] - resignal: FALSE
  [15:46:00.159] - force: TRUE
  [15:46:00.159] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:46:00.160] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
   - flush all
  [15:46:00.160] - relayed: [n=6] TRUE, TRUE, TRUE, TRUE, TRUE, TRUE
  [15:46:00.161] - queued futures: [n=6] FALSE, TRUE, TRUE, TRUE, FALSE, FALSE
  [15:46:00.161] signalConditionsASAP(NULL, pos=0) ... done
  [15:46:00.161] resolve() on list environment ... DONE
  Classes 'listenv', 'environment' <environment: 0x55ca29a437e8> 
   - 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)
  [15:46:00.173] getGlobalsAndPackages() ...
  [15:46:00.173] Searching for globals...
  [15:46:00.175] 
  [15:46:00.175] Searching for globals ... DONE
  [15:46:00.175] - globals: [0] <none>
  [15:46:00.176] getGlobalsAndPackages() ... DONE
  [15:46:00.178] Packages needed by the future expression (n = 0): <none>
  [15:46:00.179] Packages needed by future strategies (n = 0): <none>
  [15:46:00.186] {
  [15:46:00.186]     {
  [15:46:00.186]         ...future.startTime <- base::Sys.time()
  [15:46:00.186]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [15:46:00.186]             future.globals.onMissing = NULL, future.globals.maxSize = NULL, 
  [15:46:00.186]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [15:46:00.186]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [15:46:00.186]             future.resolve.recursive = NULL, width = 80L)
  [15:46:00.186]         {
  [15:46:00.186]             {
  [15:46:00.186]                 base::local({
  [15:46:00.186]                   has_future <- base::requireNamespace("future", 
  [15:46:00.186]                     quietly = TRUE)
  [15:46:00.186]                   version <- if (has_future) 
  [15:46:00.186]                     utils::packageVersion("future")
  [15:46:00.186]                   else NULL
  [15:46:00.186]                   if (!has_future || version < "1.8.0") {
  [15:46:00.186]                     info <- base::c(r_version = base::gsub("R version ", 
  [15:46:00.186]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [15:46:00.186]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [15:46:00.186]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [15:46:00.186]                         "release", "version")], collapse = " "), 
  [15:46:00.186]                       hostname = base::Sys.info()[["nodename"]])
  [15:46:00.186]                     info <- base::sprintf("%s: %s", base::names(info), 
  [15:46:00.186]                       info)
  [15:46:00.186]                     info <- base::paste(info, collapse = "; ")
  [15:46:00.186]                     if (!has_future) {
  [15:46:00.186]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [15:46:00.186]                         info)
  [15:46:00.186]                     }
  [15:46:00.186]                     else {
  [15:46:00.186]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [15:46:00.186]                         info, version)
  [15:46:00.186]                     }
  [15:46:00.186]                     base::stop(msg)
  [15:46:00.186]                   }
  [15:46:00.186]                 })
  [15:46:00.186]             }
  [15:46:00.186]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [15:46:00.186]         }
  [15:46:00.186]     }
  [15:46:00.186]     if (base::is.na(TRUE)) {
  [15:46:00.186]     }
  [15:46:00.186]     else {
  [15:46:00.186]         if (TRUE) {
  [15:46:00.186]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [15:46:00.186]                 open = "w")
  [15:46:00.186]         }
  [15:46:00.186]         else {
  [15:46:00.186]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [15:46:00.186]                 windows = "NUL", "/dev/null"), open = "w")
  [15:46:00.186]         }
  [15:46:00.186]         base::sink(...future.stdout, type = "output", split = FALSE)
  [15:46:00.186]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [15:46:00.186]             base::sink(type = "output", split = FALSE)
  [15:46:00.186]             base::close(...future.stdout)
  [15:46:00.186]         }, add = TRUE)
  [15:46:00.186]     }
  [15:46:00.186]     ...future.frame <- base::sys.nframe()
  [15:46:00.186]     ...future.conditions <- base::list()
  [15:46:00.186]     ...future.rng <- base::globalenv()$.Random.seed
  [15:46:00.186]     ...future.result <- base::tryCatch({
  [15:46:00.186]         base::withCallingHandlers({
  [15:46:00.186]             ...future.value <- base::withVisible(base::local(2))
  [15:46:00.186]             future::FutureResult(value = ...future.value$value, 
  [15:46:00.186]                 visible = ...fut