Running ‘000.sessionDetails.R’ [0s/1s]
  Running ‘ClusterRegistry.R’ [2s/12s]
  Running ‘Future-class.R’ [1s/5s]
  Running ‘FutureError.R’ [1s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/2s]
  Running ‘as.cluster.R’ [1s/4s]
  Running ‘availableCores.R’ [1s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/2s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [6s/35s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [8s/14s]
  Running ‘dotdotdot.R’ [1s/6s]
  Running ‘early-signaling.R’ [2s/14s]
  Running ‘future,labels.R’ [1s/1s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/6s]
  Running ‘futureAssign_OP.R’ [2s/5s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/2s]
  Running ‘futureCall.R’ [4s/12s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [15s/49s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [3s/9s]
  Running ‘globals,manual.R’ [2s/3s]
  Running ‘globals,resolve.R’ [1s/5s]
  Running ‘globals,subassignment.R’ [3s/8s]
  Running ‘globals,toolarge.R’ [1s/5s]
  Running ‘globals,tricky.R’ [6s/14s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [1s/5s]
  Running ‘makeClusterPSOCK.R’ [1s/3s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [0s/1s]
  Running ‘multicore,multithreading.R’ [1s/2s]
  Running ‘multicore.R’ [1s/2s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [4s/15s]
  Running ‘nbrOfWorkers.R’ [3s/15s]
  Running ‘nested_futures,mc.cores.R’ [4s/29s]
  Running ‘nested_futures.R’ [1s/2s]
  Running ‘non-exportable,connections.R’ [1s/5s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [2s/5s]
  Running ‘relaying.R’ [1s/3s]
  Running ‘remote.R’ [1s/5s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/11s]
  Running ‘reserved-keyword-functions.R’ [1s/2s]
  Running ‘resolve.R’ [2s/5s]
  Running ‘resolved-non-blocking-test.R’ [2s/36s]
  Running ‘rng.R’ [9s/19s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/8s]
  Running ‘stdout.R’ [2s/6s]
  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/futureAssign_OP.R’ failed.
Complete output:
  > source("incl/start.R")
  [21:18:55.270] plan(): Setting new future strategy stack:
  [21:18:55.271] List of future strategies:
  [21:18:55.271] 1. sequential:
  [21:18:55.271]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.271]    - tweaked: FALSE
  [21:18:55.271]    - call: future::plan("sequential")
  [21:18:55.273] plan(): nbrOfWorkers() = 1
  > 
  > message("*** %<-% ...")
  *** %<-% ...
  > 
  > for (cores in 1:availCores) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  +   
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  + 
  +   for (strategy in supportedStrategies(cores)) {
  +     message(sprintf("*** %%<-%% with %s futures ...", sQuote(strategy)))
  +     plan(strategy)
  + 
  +     rm(list = intersect(c("x", "y"), ls()))
  + 
  +     message("** Future evaluation without globals")
  +     v1 %<-% { x <- 1 }
  +     stopifnot(!exists("x", inherits = FALSE), identical(v1, 1))
  + 
  +     message("** Future evaluation with globals")
  +     a <- 2
  +     v2 %<-% { x <- a }
  +     stopifnot(!exists("x", inherits = FALSE), identical(v2, a))
  + 
  +     message("** Future evaluation with errors")
  +     v3 %<-% {
  +       x <- 3
  +       stop("Woops!")
  +       x
  +     }
  +     stopifnot(!exists("x", inherits = FALSE))
  +     res <- tryCatch(identical(v3, 3), error = identity)
  +     stopifnot(inherits(res, "error"))
  + 
  + 
  +     y <- listenv::listenv()
  +     for (ii in 1:3) {
  +       y[[ii]] %<-% {
  +         if (ii %% 2 == 0) stop("Woops!")
  +         ii
  +       }
  +     }
  +     res <- tryCatch(as.list(y), error = identity)
  +     stopifnot(inherits(res, "error"))
  +     z <- y[c(1, 3)]
  +     z <- unlist(z)
  +     stopifnot(all(z == c(1, 3)))
  +     res <- tryCatch(y[[2]], error = identity)
  +     stopifnot(inherits(res, "error"))
  +     res <- tryCatch(y[1:2], error = identity)
  +     stopifnot(inherits(res, "error"))
  + 
  + 
  +     message("** Future evaluation with a poor-man's \"progress bar\"")
  +     v4 %<-% {
  +       cat("Processing: ")
  +       for (ii in 1:10) { cat(".") }
  +       cat(" [100%]\n")
  +       4
  +     }
  + 
  + 
  +     message("** Collecting results")
  +     printf("v1 = %s\n", v1)
  +     stopifnot(v1 == 1)
  + 
  +     printf("v2 = %s\n", v2)
  +     stopifnot(v2 == a)
  + 
  +     stopifnot(tryCatch({
  +       printf("v3 = %s\n", v3)
  +     }, error = function(ex) {
  +       printf("v3: <%s> (as expect)\n", class(ex)[1])
  +       TRUE
  +     }))
  + 
  +     printf("v4 = %s\n", v4)
  +     #stopifnot(v4 == 4)
  + 
  + 
  +     message("** Left-to-right and right-to-left future assignments")
  +     c %<-% 1
  +     printf("c = %s\n", c)
  +     1 %->% d
  +     printf("d = %s\n", d)
  +     stopifnot(d == c)
  + 
  + 
  + 
  +     message("** Nested future assignments")
  +     a %<-% {
  +       b <- 1
  +       c %<-% 2
  +       3 -> d
  +       4 %->% e
  +       b + c + d + e
  +     }
  +     printf("a = %s\n", a)
  +     stopifnot(a == 10)
  + 
  +     { a + 1 } %->% b
  +     printf("b = %s\n", b)
  +     stopifnot(b == a + 1)
  + 
  +     message(sprintf("*** %%<-%% with %s futures ... DONE", sQuote(strategy)))
  +   } # for (strategy in ...)
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  *** %<-% with 'sequential' futures ...
  [21:18:55.590] plan(): Setting new future strategy stack:
  [21:18:55.593] List of future strategies:
  [21:18:55.593] 1. sequential:
  [21:18:55.593]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.593]    - tweaked: FALSE
  [21:18:55.593]    - call: plan(strategy)
  [21:18:55.653] plan(): nbrOfWorkers() = 1
  ** Future evaluation without globals
  [21:18:55.657] getGlobalsAndPackages() ...
  [21:18:55.657] Searching for globals...
  [21:18:55.681] - globals found: [2] '{', '<-'
  [21:18:55.682] Searching for globals ... DONE
  [21:18:55.682] Resolving globals: FALSE
  [21:18:55.683] 
  [21:18:55.683] 
  [21:18:55.684] getGlobalsAndPackages() ... DONE
  [21:18:55.687] Packages needed by the future expression (n = 0): <none>
  [21:18:55.687] Packages needed by future strategies (n = 0): <none>
  [21:18:55.692] {
  [21:18:55.692]     {
  [21:18:55.692]         ...future.startTime <- base::Sys.time()
  [21:18:55.692]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.692]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.692]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:18:55.692]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.692]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.692]         {
  [21:18:55.692]             {
  [21:18:55.692]                 base::local({
  [21:18:55.692]                   has_future <- base::requireNamespace("future", 
  [21:18:55.692]                     quietly = TRUE)
  [21:18:55.692]                   version <- if (has_future) 
  [21:18:55.692]                     utils::packageVersion("future")
  [21:18:55.692]                   else NULL
  [21:18:55.692]                   if (!has_future || version < "1.8.0") {
  [21:18:55.692]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.692]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.692]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.692]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.692]                         "release", "version")], collapse = " "), 
  [21:18:55.692]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.692]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.692]                       info)
  [21:18:55.692]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.692]                     if (!has_future) {
  [21:18:55.692]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.692]                         info)
  [21:18:55.692]                     }
  [21:18:55.692]                     else {
  [21:18:55.692]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.692]                         info, version)
  [21:18:55.692]                     }
  [21:18:55.692]                     base::stop(msg)
  [21:18:55.692]                   }
  [21:18:55.692]                 })
  [21:18:55.692]             }
  [21:18:55.692]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.692]         }
  [21:18:55.692]     }
  [21:18:55.692]     if (base::is.na(TRUE)) {
  [21:18:55.692]     }
  [21:18:55.692]     else {
  [21:18:55.692]         if (TRUE) {
  [21:18:55.692]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.692]                 open = "w")
  [21:18:55.692]         }
  [21:18:55.692]         else {
  [21:18:55.692]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.692]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.692]         }
  [21:18:55.692]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.692]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.692]             base::sink(type = "output", split = FALSE)
  [21:18:55.692]             base::close(...future.stdout)
  [21:18:55.692]         }, add = TRUE)
  [21:18:55.692]     }
  [21:18:55.692]     ...future.frame <- base::sys.nframe()
  [21:18:55.692]     ...future.conditions <- base::list()
  [21:18:55.692]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.692]     ...future.result <- base::tryCatch({
  [21:18:55.692]         base::withCallingHandlers({
  [21:18:55.692]             ...future.value <- base::withVisible(base::local({
  [21:18:55.692]                 x <- 1
  [21:18:55.692]             }))
  [21:18:55.692]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.692]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.692]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.692]                 version = "1.8")
  [21:18:55.692]         }, condition = base::local({
  [21:18:55.692]             c <- base::c
  [21:18:55.692]             inherits <- base::inherits
  [21:18:55.692]             invokeRestart <- base::invokeRestart
  [21:18:55.692]             length <- base::length
  [21:18:55.692]             list <- base::list
  [21:18:55.692]             seq.int <- base::seq.int
  [21:18:55.692]             signalCondition <- base::signalCondition
  [21:18:55.692]             sys.calls <- base::sys.calls
  [21:18:55.692]             Sys.time <- base::Sys.time
  [21:18:55.692]             `[[` <- base::`[[`
  [21:18:55.692]             `+` <- base::`+`
  [21:18:55.692]             `<<-` <- base::`<<-`
  [21:18:55.692]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.692]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.692]                   3L)]
  [21:18:55.692]             }
  [21:18:55.692]             function(cond) {
  [21:18:55.692]                 if (inherits(cond, "error")) {
  [21:18:55.692]                   sessionInformation <- function() {
  [21:18:55.692]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.692]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.692]                       search = base::search(), system = base::Sys.info())
  [21:18:55.692]                   }
  [21:18:55.692]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.692]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.692]                     cond$call), session = sessionInformation(), 
  [21:18:55.692]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.692]                   signalCondition(cond)
  [21:18:55.692]                 }
  [21:18:55.692]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.692]                 ))) {
  [21:18:55.692]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.692]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.692]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.692]                   if (!signal) {
  [21:18:55.692]                     muffleCondition <- function (cond) 
  [21:18:55.692]                     {
  [21:18:55.692]                       inherits <- base::inherits
  [21:18:55.692]                       invokeRestart <- base::invokeRestart
  [21:18:55.692]                       muffled <- FALSE
  [21:18:55.692]                       if (inherits(cond, "message")) {
  [21:18:55.692]                         invokeRestart("muffleMessage")
  [21:18:55.692]                         muffled <- TRUE
  [21:18:55.692]                       }
  [21:18:55.692]                       else if (inherits(cond, "warning")) {
  [21:18:55.692]                         invokeRestart("muffleWarning")
  [21:18:55.692]                         muffled <- TRUE
  [21:18:55.692]                       }
  [21:18:55.692]                       else if (inherits(cond, "condition")) {
  [21:18:55.692]                         computeRestarts <- base::computeRestarts
  [21:18:55.692]                         grepl <- base::grepl
  [21:18:55.692]                         is.null <- base::is.null
  [21:18:55.692]                         restarts <- computeRestarts(cond)
  [21:18:55.692]                         for (restart in restarts) {
  [21:18:55.692]                           name <- restart$name
  [21:18:55.692]                           if (is.null(name)) 
  [21:18:55.692]                             next
  [21:18:55.692]                           if (!grepl("^muffle", name)) 
  [21:18:55.692]                             next
  [21:18:55.692]                           invokeRestart(restart)
  [21:18:55.692]                           muffled <- TRUE
  [21:18:55.692]                           break
  [21:18:55.692]                         }
  [21:18:55.692]                       }
  [21:18:55.692]                       invisible(muffled)
  [21:18:55.692]                     }
  [21:18:55.692]                     muffleCondition(cond)
  [21:18:55.692]                   }
  [21:18:55.692]                 }
  [21:18:55.692]             }
  [21:18:55.692]         }))
  [21:18:55.692]     }, error = function(ex) {
  [21:18:55.692]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.692]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.692]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.692]     }, finally = {
  [21:18:55.692]         {
  [21:18:55.692]             NULL
  [21:18:55.692]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.692]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.692]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.692]                 label = NULL, ...) 
  [21:18:55.692]             {
  [21:18:55.692]                 if (substitute) 
  [21:18:55.692]                   expr <- substitute(expr)
  [21:18:55.692]                 local <- as.logical(local)
  [21:18:55.692]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.692]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.692]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.692]                   label = label, ...)
  [21:18:55.692]                 if (!future$lazy) 
  [21:18:55.692]                   future <- run(future)
  [21:18:55.692]                 invisible(future)
  [21:18:55.692]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.692]         }
  [21:18:55.692]         base::options(...future.oldOptions)
  [21:18:55.692]     })
  [21:18:55.692]     Sys.time
  [21:18:55.692]     if (base::is.na(TRUE)) {
  [21:18:55.692]     }
  [21:18:55.692]     else {
  [21:18:55.692]         base::sink(type = "output", split = FALSE)
  [21:18:55.692]         if (TRUE) {
  [21:18:55.692]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.692]         }
  [21:18:55.692]         else {
  [21:18:55.692]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.692]         }
  [21:18:55.692]         base::close(...future.stdout)
  [21:18:55.692]         ...future.stdout <- NULL
  [21:18:55.692]     }
  [21:18:55.692]     ...future.result$conditions <- ...future.conditions
  [21:18:55.692]     ...future.result
  [21:18:55.692] }
  [21:18:55.713] plan(): Setting new future strategy stack:
  [21:18:55.713] List of future strategies:
  [21:18:55.713] 1. sequential:
  [21:18:55.713]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.713]    - tweaked: FALSE
  [21:18:55.713]    - call: NULL
  [21:18:55.714] plan(): nbrOfWorkers() = 1
  [21:18:55.715] plan(): Setting new future strategy stack:
  [21:18:55.716] List of future strategies:
  [21:18:55.716] 1. sequential:
  [21:18:55.716]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.716]    - tweaked: FALSE
  [21:18:55.716]    - call: plan(strategy)
  [21:18:55.717] plan(): nbrOfWorkers() = 1
  [21:18:55.717] SequentialFuture started (and completed)
  ** Future evaluation with globals
  [21:18:55.719] getGlobalsAndPackages() ...
  [21:18:55.720] Searching for globals...
  [21:18:55.721] - globals found: [3] '{', '<-', 'a'
  [21:18:55.721] Searching for globals ... DONE
  [21:18:55.722] Resolving globals: FALSE
  [21:18:55.723] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:55.723] - globals: [1] 'a'
  [21:18:55.724] 
  [21:18:55.724] getGlobalsAndPackages() ... DONE
  [21:18:55.725] Packages needed by the future expression (n = 0): <none>
  [21:18:55.742] Packages needed by future strategies (n = 0): <none>
  [21:18:55.746] {
  [21:18:55.746]     {
  [21:18:55.746]         ...future.startTime <- base::Sys.time()
  [21:18:55.746]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.746]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.746]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:55.746]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.746]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.746]         {
  [21:18:55.746]             {
  [21:18:55.746]                 base::local({
  [21:18:55.746]                   has_future <- base::requireNamespace("future", 
  [21:18:55.746]                     quietly = TRUE)
  [21:18:55.746]                   version <- if (has_future) 
  [21:18:55.746]                     utils::packageVersion("future")
  [21:18:55.746]                   else NULL
  [21:18:55.746]                   if (!has_future || version < "1.8.0") {
  [21:18:55.746]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.746]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.746]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.746]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.746]                         "release", "version")], collapse = " "), 
  [21:18:55.746]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.746]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.746]                       info)
  [21:18:55.746]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.746]                     if (!has_future) {
  [21:18:55.746]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.746]                         info)
  [21:18:55.746]                     }
  [21:18:55.746]                     else {
  [21:18:55.746]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.746]                         info, version)
  [21:18:55.746]                     }
  [21:18:55.746]                     base::stop(msg)
  [21:18:55.746]                   }
  [21:18:55.746]                 })
  [21:18:55.746]             }
  [21:18:55.746]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.746]         }
  [21:18:55.746]     }
  [21:18:55.746]     if (base::is.na(TRUE)) {
  [21:18:55.746]     }
  [21:18:55.746]     else {
  [21:18:55.746]         if (TRUE) {
  [21:18:55.746]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.746]                 open = "w")
  [21:18:55.746]         }
  [21:18:55.746]         else {
  [21:18:55.746]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.746]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.746]         }
  [21:18:55.746]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.746]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.746]             base::sink(type = "output", split = FALSE)
  [21:18:55.746]             base::close(...future.stdout)
  [21:18:55.746]         }, add = TRUE)
  [21:18:55.746]     }
  [21:18:55.746]     ...future.frame <- base::sys.nframe()
  [21:18:55.746]     ...future.conditions <- base::list()
  [21:18:55.746]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.746]     ...future.result <- base::tryCatch({
  [21:18:55.746]         base::withCallingHandlers({
  [21:18:55.746]             ...future.value <- base::withVisible(base::local({
  [21:18:55.746]                 x <- a
  [21:18:55.746]             }))
  [21:18:55.746]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.746]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.746]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.746]                 version = "1.8")
  [21:18:55.746]         }, condition = base::local({
  [21:18:55.746]             c <- base::c
  [21:18:55.746]             inherits <- base::inherits
  [21:18:55.746]             invokeRestart <- base::invokeRestart
  [21:18:55.746]             length <- base::length
  [21:18:55.746]             list <- base::list
  [21:18:55.746]             seq.int <- base::seq.int
  [21:18:55.746]             signalCondition <- base::signalCondition
  [21:18:55.746]             sys.calls <- base::sys.calls
  [21:18:55.746]             Sys.time <- base::Sys.time
  [21:18:55.746]             `[[` <- base::`[[`
  [21:18:55.746]             `+` <- base::`+`
  [21:18:55.746]             `<<-` <- base::`<<-`
  [21:18:55.746]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.746]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.746]                   3L)]
  [21:18:55.746]             }
  [21:18:55.746]             function(cond) {
  [21:18:55.746]                 if (inherits(cond, "error")) {
  [21:18:55.746]                   sessionInformation <- function() {
  [21:18:55.746]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.746]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.746]                       search = base::search(), system = base::Sys.info())
  [21:18:55.746]                   }
  [21:18:55.746]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.746]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.746]                     cond$call), session = sessionInformation(), 
  [21:18:55.746]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.746]                   signalCondition(cond)
  [21:18:55.746]                 }
  [21:18:55.746]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.746]                 ))) {
  [21:18:55.746]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.746]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.746]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.746]                   if (!signal) {
  [21:18:55.746]                     muffleCondition <- function (cond) 
  [21:18:55.746]                     {
  [21:18:55.746]                       inherits <- base::inherits
  [21:18:55.746]                       invokeRestart <- base::invokeRestart
  [21:18:55.746]                       muffled <- FALSE
  [21:18:55.746]                       if (inherits(cond, "message")) {
  [21:18:55.746]                         invokeRestart("muffleMessage")
  [21:18:55.746]                         muffled <- TRUE
  [21:18:55.746]                       }
  [21:18:55.746]                       else if (inherits(cond, "warning")) {
  [21:18:55.746]                         invokeRestart("muffleWarning")
  [21:18:55.746]                         muffled <- TRUE
  [21:18:55.746]                       }
  [21:18:55.746]                       else if (inherits(cond, "condition")) {
  [21:18:55.746]                         computeRestarts <- base::computeRestarts
  [21:18:55.746]                         grepl <- base::grepl
  [21:18:55.746]                         is.null <- base::is.null
  [21:18:55.746]                         restarts <- computeRestarts(cond)
  [21:18:55.746]                         for (restart in restarts) {
  [21:18:55.746]                           name <- restart$name
  [21:18:55.746]                           if (is.null(name)) 
  [21:18:55.746]                             next
  [21:18:55.746]                           if (!grepl("^muffle", name)) 
  [21:18:55.746]                             next
  [21:18:55.746]                           invokeRestart(restart)
  [21:18:55.746]                           muffled <- TRUE
  [21:18:55.746]                           break
  [21:18:55.746]                         }
  [21:18:55.746]                       }
  [21:18:55.746]                       invisible(muffled)
  [21:18:55.746]                     }
  [21:18:55.746]                     muffleCondition(cond)
  [21:18:55.746]                   }
  [21:18:55.746]                 }
  [21:18:55.746]             }
  [21:18:55.746]         }))
  [21:18:55.746]     }, error = function(ex) {
  [21:18:55.746]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.746]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.746]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.746]     }, finally = {
  [21:18:55.746]         {
  [21:18:55.746]             NULL
  [21:18:55.746]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.746]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.746]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.746]                 label = NULL, ...) 
  [21:18:55.746]             {
  [21:18:55.746]                 if (substitute) 
  [21:18:55.746]                   expr <- substitute(expr)
  [21:18:55.746]                 local <- as.logical(local)
  [21:18:55.746]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.746]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.746]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.746]                   label = label, ...)
  [21:18:55.746]                 if (!future$lazy) 
  [21:18:55.746]                   future <- run(future)
  [21:18:55.746]                 invisible(future)
  [21:18:55.746]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.746]         }
  [21:18:55.746]         base::options(...future.oldOptions)
  [21:18:55.746]     })
  [21:18:55.746]     Sys.time
  [21:18:55.746]     if (base::is.na(TRUE)) {
  [21:18:55.746]     }
  [21:18:55.746]     else {
  [21:18:55.746]         base::sink(type = "output", split = FALSE)
  [21:18:55.746]         if (TRUE) {
  [21:18:55.746]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.746]         }
  [21:18:55.746]         else {
  [21:18:55.746]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.746]         }
  [21:18:55.746]         base::close(...future.stdout)
  [21:18:55.746]         ...future.stdout <- NULL
  [21:18:55.746]     }
  [21:18:55.746]     ...future.result$conditions <- ...future.conditions
  [21:18:55.746]     ...future.result
  [21:18:55.746] }
  [21:18:55.751] plan(): Setting new future strategy stack:
  [21:18:55.751] List of future strategies:
  [21:18:55.751] 1. sequential:
  [21:18:55.751]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.751]    - tweaked: FALSE
  [21:18:55.751]    - call: NULL
  [21:18:55.752] plan(): nbrOfWorkers() = 1
  [21:18:55.753] plan(): Setting new future strategy stack:
  [21:18:55.753] List of future strategies:
  [21:18:55.753] 1. sequential:
  [21:18:55.753]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.753]    - tweaked: FALSE
  [21:18:55.753]    - call: plan(strategy)
  [21:18:55.754] plan(): nbrOfWorkers() = 1
  [21:18:55.755] SequentialFuture started (and completed)
  ** Future evaluation with errors
  [21:18:55.776] getGlobalsAndPackages() ...
  [21:18:55.776] Searching for globals...
  [21:18:55.778] - globals found: [3] '{', '<-', 'stop'
  [21:18:55.779] Searching for globals ... DONE
  [21:18:55.779] Resolving globals: FALSE
  [21:18:55.780] 
  [21:18:55.780] 
  [21:18:55.780] getGlobalsAndPackages() ... DONE
  [21:18:55.782] Packages needed by the future expression (n = 0): <none>
  [21:18:55.782] Packages needed by future strategies (n = 0): <none>
  [21:18:55.786] {
  [21:18:55.786]     {
  [21:18:55.786]         ...future.startTime <- base::Sys.time()
  [21:18:55.786]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.786]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.786]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:55.786]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.786]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.786]         {
  [21:18:55.786]             {
  [21:18:55.786]                 base::local({
  [21:18:55.786]                   has_future <- base::requireNamespace("future", 
  [21:18:55.786]                     quietly = TRUE)
  [21:18:55.786]                   version <- if (has_future) 
  [21:18:55.786]                     utils::packageVersion("future")
  [21:18:55.786]                   else NULL
  [21:18:55.786]                   if (!has_future || version < "1.8.0") {
  [21:18:55.786]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.786]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.786]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.786]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.786]                         "release", "version")], collapse = " "), 
  [21:18:55.786]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.786]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.786]                       info)
  [21:18:55.786]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.786]                     if (!has_future) {
  [21:18:55.786]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.786]                         info)
  [21:18:55.786]                     }
  [21:18:55.786]                     else {
  [21:18:55.786]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.786]                         info, version)
  [21:18:55.786]                     }
  [21:18:55.786]                     base::stop(msg)
  [21:18:55.786]                   }
  [21:18:55.786]                 })
  [21:18:55.786]             }
  [21:18:55.786]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.786]         }
  [21:18:55.786]     }
  [21:18:55.786]     if (base::is.na(TRUE)) {
  [21:18:55.786]     }
  [21:18:55.786]     else {
  [21:18:55.786]         if (TRUE) {
  [21:18:55.786]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.786]                 open = "w")
  [21:18:55.786]         }
  [21:18:55.786]         else {
  [21:18:55.786]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.786]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.786]         }
  [21:18:55.786]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.786]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.786]             base::sink(type = "output", split = FALSE)
  [21:18:55.786]             base::close(...future.stdout)
  [21:18:55.786]         }, add = TRUE)
  [21:18:55.786]     }
  [21:18:55.786]     ...future.frame <- base::sys.nframe()
  [21:18:55.786]     ...future.conditions <- base::list()
  [21:18:55.786]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.786]     ...future.result <- base::tryCatch({
  [21:18:55.786]         base::withCallingHandlers({
  [21:18:55.786]             ...future.value <- base::withVisible(base::local({
  [21:18:55.786]                 x <- 3
  [21:18:55.786]                 stop("Woops!")
  [21:18:55.786]                 x
  [21:18:55.786]             }))
  [21:18:55.786]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.786]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.786]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.786]                 version = "1.8")
  [21:18:55.786]         }, condition = base::local({
  [21:18:55.786]             c <- base::c
  [21:18:55.786]             inherits <- base::inherits
  [21:18:55.786]             invokeRestart <- base::invokeRestart
  [21:18:55.786]             length <- base::length
  [21:18:55.786]             list <- base::list
  [21:18:55.786]             seq.int <- base::seq.int
  [21:18:55.786]             signalCondition <- base::signalCondition
  [21:18:55.786]             sys.calls <- base::sys.calls
  [21:18:55.786]             Sys.time <- base::Sys.time
  [21:18:55.786]             `[[` <- base::`[[`
  [21:18:55.786]             `+` <- base::`+`
  [21:18:55.786]             `<<-` <- base::`<<-`
  [21:18:55.786]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.786]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.786]                   3L)]
  [21:18:55.786]             }
  [21:18:55.786]             function(cond) {
  [21:18:55.786]                 if (inherits(cond, "error")) {
  [21:18:55.786]                   sessionInformation <- function() {
  [21:18:55.786]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.786]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.786]                       search = base::search(), system = base::Sys.info())
  [21:18:55.786]                   }
  [21:18:55.786]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.786]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.786]                     cond$call), session = sessionInformation(), 
  [21:18:55.786]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.786]                   signalCondition(cond)
  [21:18:55.786]                 }
  [21:18:55.786]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.786]                 ))) {
  [21:18:55.786]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.786]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.786]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.786]                   if (!signal) {
  [21:18:55.786]                     muffleCondition <- function (cond) 
  [21:18:55.786]                     {
  [21:18:55.786]                       inherits <- base::inherits
  [21:18:55.786]                       invokeRestart <- base::invokeRestart
  [21:18:55.786]                       muffled <- FALSE
  [21:18:55.786]                       if (inherits(cond, "message")) {
  [21:18:55.786]                         invokeRestart("muffleMessage")
  [21:18:55.786]                         muffled <- TRUE
  [21:18:55.786]                       }
  [21:18:55.786]                       else if (inherits(cond, "warning")) {
  [21:18:55.786]                         invokeRestart("muffleWarning")
  [21:18:55.786]                         muffled <- TRUE
  [21:18:55.786]                       }
  [21:18:55.786]                       else if (inherits(cond, "condition")) {
  [21:18:55.786]                         computeRestarts <- base::computeRestarts
  [21:18:55.786]                         grepl <- base::grepl
  [21:18:55.786]                         is.null <- base::is.null
  [21:18:55.786]                         restarts <- computeRestarts(cond)
  [21:18:55.786]                         for (restart in restarts) {
  [21:18:55.786]                           name <- restart$name
  [21:18:55.786]                           if (is.null(name)) 
  [21:18:55.786]                             next
  [21:18:55.786]                           if (!grepl("^muffle", name)) 
  [21:18:55.786]                             next
  [21:18:55.786]                           invokeRestart(restart)
  [21:18:55.786]                           muffled <- TRUE
  [21:18:55.786]                           break
  [21:18:55.786]                         }
  [21:18:55.786]                       }
  [21:18:55.786]                       invisible(muffled)
  [21:18:55.786]                     }
  [21:18:55.786]                     muffleCondition(cond)
  [21:18:55.786]                   }
  [21:18:55.786]                 }
  [21:18:55.786]             }
  [21:18:55.786]         }))
  [21:18:55.786]     }, error = function(ex) {
  [21:18:55.786]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.786]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.786]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.786]     }, finally = {
  [21:18:55.786]         {
  [21:18:55.786]             NULL
  [21:18:55.786]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.786]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.786]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.786]                 label = NULL, ...) 
  [21:18:55.786]             {
  [21:18:55.786]                 if (substitute) 
  [21:18:55.786]                   expr <- substitute(expr)
  [21:18:55.786]                 local <- as.logical(local)
  [21:18:55.786]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.786]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.786]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.786]                   label = label, ...)
  [21:18:55.786]                 if (!future$lazy) 
  [21:18:55.786]                   future <- run(future)
  [21:18:55.786]                 invisible(future)
  [21:18:55.786]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.786]         }
  [21:18:55.786]         base::options(...future.oldOptions)
  [21:18:55.786]     })
  [21:18:55.786]     Sys.time
  [21:18:55.786]     if (base::is.na(TRUE)) {
  [21:18:55.786]     }
  [21:18:55.786]     else {
  [21:18:55.786]         base::sink(type = "output", split = FALSE)
  [21:18:55.786]         if (TRUE) {
  [21:18:55.786]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.786]         }
  [21:18:55.786]         else {
  [21:18:55.786]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.786]         }
  [21:18:55.786]         base::close(...future.stdout)
  [21:18:55.786]         ...future.stdout <- NULL
  [21:18:55.786]     }
  [21:18:55.786]     ...future.result$conditions <- ...future.conditions
  [21:18:55.786]     ...future.result
  [21:18:55.786] }
  [21:18:55.806] plan(): Setting new future strategy stack:
  [21:18:55.807] List of future strategies:
  [21:18:55.807] 1. sequential:
  [21:18:55.807]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.807]    - tweaked: FALSE
  [21:18:55.807]    - call: NULL
  [21:18:55.808] plan(): nbrOfWorkers() = 1
  [21:18:55.809] plan(): Setting new future strategy stack:
  [21:18:55.810] List of future strategies:
  [21:18:55.810] 1. sequential:
  [21:18:55.810]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.810]    - tweaked: FALSE
  [21:18:55.810]    - call: plan(strategy)
  [21:18:55.811] plan(): nbrOfWorkers() = 1
  [21:18:55.811] SequentialFuture started (and completed)
  [21:18:55.811] signalConditions() ...
  [21:18:55.812]  - include = 'immediateCondition'
  [21:18:55.812]  - exclude = 
  [21:18:55.812]  - resignal = FALSE
  [21:18:55.813]  - Number of conditions: 1
  [21:18:55.813] signalConditions() ... done
  [21:18:55.813] signalConditions() ...
  [21:18:55.814]  - include = 'immediateCondition'
  [21:18:55.814]  - exclude = 
  [21:18:55.814]  - resignal = FALSE
  [21:18:55.815]  - Number of conditions: 1
  [21:18:55.815] signalConditions() ... done
  [21:18:55.815] Future state: 'finished'
  [21:18:55.816] signalConditions() ...
  [21:18:55.816]  - include = 'condition'
  [21:18:55.816]  - exclude = 'immediateCondition'
  [21:18:55.816]  - resignal = TRUE
  [21:18:55.817]  - Number of conditions: 1
  [21:18:55.817]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:55.817] signalConditions() ... done
  [21:18:55.819] getGlobalsAndPackages() ...
  [21:18:55.819] Searching for globals...
  [21:18:55.839] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:55.839] Searching for globals ... DONE
  [21:18:55.840] Resolving globals: FALSE
  [21:18:55.841] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:55.841] - globals: [1] 'ii'
  [21:18:55.841] 
  [21:18:55.842] getGlobalsAndPackages() ... DONE
  [21:18:55.843] Packages needed by the future expression (n = 0): <none>
  [21:18:55.843] Packages needed by future strategies (n = 0): <none>
  [21:18:55.847] {
  [21:18:55.847]     {
  [21:18:55.847]         ...future.startTime <- base::Sys.time()
  [21:18:55.847]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.847]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.847]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:55.847]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.847]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.847]         {
  [21:18:55.847]             {
  [21:18:55.847]                 base::local({
  [21:18:55.847]                   has_future <- base::requireNamespace("future", 
  [21:18:55.847]                     quietly = TRUE)
  [21:18:55.847]                   version <- if (has_future) 
  [21:18:55.847]                     utils::packageVersion("future")
  [21:18:55.847]                   else NULL
  [21:18:55.847]                   if (!has_future || version < "1.8.0") {
  [21:18:55.847]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.847]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.847]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.847]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.847]                         "release", "version")], collapse = " "), 
  [21:18:55.847]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.847]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.847]                       info)
  [21:18:55.847]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.847]                     if (!has_future) {
  [21:18:55.847]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.847]                         info)
  [21:18:55.847]                     }
  [21:18:55.847]                     else {
  [21:18:55.847]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.847]                         info, version)
  [21:18:55.847]                     }
  [21:18:55.847]                     base::stop(msg)
  [21:18:55.847]                   }
  [21:18:55.847]                 })
  [21:18:55.847]             }
  [21:18:55.847]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.847]         }
  [21:18:55.847]     }
  [21:18:55.847]     if (base::is.na(TRUE)) {
  [21:18:55.847]     }
  [21:18:55.847]     else {
  [21:18:55.847]         if (TRUE) {
  [21:18:55.847]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.847]                 open = "w")
  [21:18:55.847]         }
  [21:18:55.847]         else {
  [21:18:55.847]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.847]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.847]         }
  [21:18:55.847]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.847]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.847]             base::sink(type = "output", split = FALSE)
  [21:18:55.847]             base::close(...future.stdout)
  [21:18:55.847]         }, add = TRUE)
  [21:18:55.847]     }
  [21:18:55.847]     ...future.frame <- base::sys.nframe()
  [21:18:55.847]     ...future.conditions <- base::list()
  [21:18:55.847]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.847]     ...future.result <- base::tryCatch({
  [21:18:55.847]         base::withCallingHandlers({
  [21:18:55.847]             ...future.value <- base::withVisible(base::local({
  [21:18:55.847]                 if (ii%%2 == 0) 
  [21:18:55.847]                   stop("Woops!")
  [21:18:55.847]                 ii
  [21:18:55.847]             }))
  [21:18:55.847]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.847]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.847]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.847]                 version = "1.8")
  [21:18:55.847]         }, condition = base::local({
  [21:18:55.847]             c <- base::c
  [21:18:55.847]             inherits <- base::inherits
  [21:18:55.847]             invokeRestart <- base::invokeRestart
  [21:18:55.847]             length <- base::length
  [21:18:55.847]             list <- base::list
  [21:18:55.847]             seq.int <- base::seq.int
  [21:18:55.847]             signalCondition <- base::signalCondition
  [21:18:55.847]             sys.calls <- base::sys.calls
  [21:18:55.847]             Sys.time <- base::Sys.time
  [21:18:55.847]             `[[` <- base::`[[`
  [21:18:55.847]             `+` <- base::`+`
  [21:18:55.847]             `<<-` <- base::`<<-`
  [21:18:55.847]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.847]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.847]                   3L)]
  [21:18:55.847]             }
  [21:18:55.847]             function(cond) {
  [21:18:55.847]                 if (inherits(cond, "error")) {
  [21:18:55.847]                   sessionInformation <- function() {
  [21:18:55.847]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.847]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.847]                       search = base::search(), system = base::Sys.info())
  [21:18:55.847]                   }
  [21:18:55.847]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.847]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.847]                     cond$call), session = sessionInformation(), 
  [21:18:55.847]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.847]                   signalCondition(cond)
  [21:18:55.847]                 }
  [21:18:55.847]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.847]                 ))) {
  [21:18:55.847]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.847]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.847]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.847]                   if (!signal) {
  [21:18:55.847]                     muffleCondition <- function (cond) 
  [21:18:55.847]                     {
  [21:18:55.847]                       inherits <- base::inherits
  [21:18:55.847]                       invokeRestart <- base::invokeRestart
  [21:18:55.847]                       muffled <- FALSE
  [21:18:55.847]                       if (inherits(cond, "message")) {
  [21:18:55.847]                         invokeRestart("muffleMessage")
  [21:18:55.847]                         muffled <- TRUE
  [21:18:55.847]                       }
  [21:18:55.847]                       else if (inherits(cond, "warning")) {
  [21:18:55.847]                         invokeRestart("muffleWarning")
  [21:18:55.847]                         muffled <- TRUE
  [21:18:55.847]                       }
  [21:18:55.847]                       else if (inherits(cond, "condition")) {
  [21:18:55.847]                         computeRestarts <- base::computeRestarts
  [21:18:55.847]                         grepl <- base::grepl
  [21:18:55.847]                         is.null <- base::is.null
  [21:18:55.847]                         restarts <- computeRestarts(cond)
  [21:18:55.847]                         for (restart in restarts) {
  [21:18:55.847]                           name <- restart$name
  [21:18:55.847]                           if (is.null(name)) 
  [21:18:55.847]                             next
  [21:18:55.847]                           if (!grepl("^muffle", name)) 
  [21:18:55.847]                             next
  [21:18:55.847]                           invokeRestart(restart)
  [21:18:55.847]                           muffled <- TRUE
  [21:18:55.847]                           break
  [21:18:55.847]                         }
  [21:18:55.847]                       }
  [21:18:55.847]                       invisible(muffled)
  [21:18:55.847]                     }
  [21:18:55.847]                     muffleCondition(cond)
  [21:18:55.847]                   }
  [21:18:55.847]                 }
  [21:18:55.847]             }
  [21:18:55.847]         }))
  [21:18:55.847]     }, error = function(ex) {
  [21:18:55.847]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.847]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.847]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.847]     }, finally = {
  [21:18:55.847]         {
  [21:18:55.847]             NULL
  [21:18:55.847]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.847]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.847]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.847]                 label = NULL, ...) 
  [21:18:55.847]             {
  [21:18:55.847]                 if (substitute) 
  [21:18:55.847]                   expr <- substitute(expr)
  [21:18:55.847]                 local <- as.logical(local)
  [21:18:55.847]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.847]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.847]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.847]                   label = label, ...)
  [21:18:55.847]                 if (!future$lazy) 
  [21:18:55.847]                   future <- run(future)
  [21:18:55.847]                 invisible(future)
  [21:18:55.847]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.847]         }
  [21:18:55.847]         base::options(...future.oldOptions)
  [21:18:55.847]     })
  [21:18:55.847]     Sys.time
  [21:18:55.847]     if (base::is.na(TRUE)) {
  [21:18:55.847]     }
  [21:18:55.847]     else {
  [21:18:55.847]         base::sink(type = "output", split = FALSE)
  [21:18:55.847]         if (TRUE) {
  [21:18:55.847]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.847]         }
  [21:18:55.847]         else {
  [21:18:55.847]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.847]         }
  [21:18:55.847]         base::close(...future.stdout)
  [21:18:55.847]         ...future.stdout <- NULL
  [21:18:55.847]     }
  [21:18:55.847]     ...future.result$conditions <- ...future.conditions
  [21:18:55.847]     ...future.result
  [21:18:55.847] }
  [21:18:55.852] plan(): Setting new future strategy stack:
  [21:18:55.852] List of future strategies:
  [21:18:55.852] 1. sequential:
  [21:18:55.852]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.852]    - tweaked: FALSE
  [21:18:55.852]    - call: NULL
  [21:18:55.853] plan(): nbrOfWorkers() = 1
  [21:18:55.870] plan(): Setting new future strategy stack:
  [21:18:55.871] List of future strategies:
  [21:18:55.871] 1. sequential:
  [21:18:55.871]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.871]    - tweaked: FALSE
  [21:18:55.871]    - call: plan(strategy)
  [21:18:55.872] plan(): nbrOfWorkers() = 1
  [21:18:55.872] SequentialFuture started (and completed)
  [21:18:55.873] getGlobalsAndPackages() ...
  [21:18:55.873] Searching for globals...
  [21:18:55.876] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:55.876] Searching for globals ... DONE
  [21:18:55.877] Resolving globals: FALSE
  [21:18:55.878] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:55.878] - globals: [1] 'ii'
  [21:18:55.878] 
  [21:18:55.878] getGlobalsAndPackages() ... DONE
  [21:18:55.880] Packages needed by the future expression (n = 0): <none>
  [21:18:55.880] Packages needed by future strategies (n = 0): <none>
  [21:18:55.885] {
  [21:18:55.885]     {
  [21:18:55.885]         ...future.startTime <- base::Sys.time()
  [21:18:55.885]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.885]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.885]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:55.885]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.885]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.885]         {
  [21:18:55.885]             {
  [21:18:55.885]                 base::local({
  [21:18:55.885]                   has_future <- base::requireNamespace("future", 
  [21:18:55.885]                     quietly = TRUE)
  [21:18:55.885]                   version <- if (has_future) 
  [21:18:55.885]                     utils::packageVersion("future")
  [21:18:55.885]                   else NULL
  [21:18:55.885]                   if (!has_future || version < "1.8.0") {
  [21:18:55.885]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.885]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.885]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.885]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.885]                         "release", "version")], collapse = " "), 
  [21:18:55.885]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.885]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.885]                       info)
  [21:18:55.885]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.885]                     if (!has_future) {
  [21:18:55.885]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.885]                         info)
  [21:18:55.885]                     }
  [21:18:55.885]                     else {
  [21:18:55.885]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.885]                         info, version)
  [21:18:55.885]                     }
  [21:18:55.885]                     base::stop(msg)
  [21:18:55.885]                   }
  [21:18:55.885]                 })
  [21:18:55.885]             }
  [21:18:55.885]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.885]         }
  [21:18:55.885]     }
  [21:18:55.885]     if (base::is.na(TRUE)) {
  [21:18:55.885]     }
  [21:18:55.885]     else {
  [21:18:55.885]         if (TRUE) {
  [21:18:55.885]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.885]                 open = "w")
  [21:18:55.885]         }
  [21:18:55.885]         else {
  [21:18:55.885]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.885]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.885]         }
  [21:18:55.885]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.885]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.885]             base::sink(type = "output", split = FALSE)
  [21:18:55.885]             base::close(...future.stdout)
  [21:18:55.885]         }, add = TRUE)
  [21:18:55.885]     }
  [21:18:55.885]     ...future.frame <- base::sys.nframe()
  [21:18:55.885]     ...future.conditions <- base::list()
  [21:18:55.885]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.885]     ...future.result <- base::tryCatch({
  [21:18:55.885]         base::withCallingHandlers({
  [21:18:55.885]             ...future.value <- base::withVisible(base::local({
  [21:18:55.885]                 if (ii%%2 == 0) 
  [21:18:55.885]                   stop("Woops!")
  [21:18:55.885]                 ii
  [21:18:55.885]             }))
  [21:18:55.885]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.885]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.885]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.885]                 version = "1.8")
  [21:18:55.885]         }, condition = base::local({
  [21:18:55.885]             c <- base::c
  [21:18:55.885]             inherits <- base::inherits
  [21:18:55.885]             invokeRestart <- base::invokeRestart
  [21:18:55.885]             length <- base::length
  [21:18:55.885]             list <- base::list
  [21:18:55.885]             seq.int <- base::seq.int
  [21:18:55.885]             signalCondition <- base::signalCondition
  [21:18:55.885]             sys.calls <- base::sys.calls
  [21:18:55.885]             Sys.time <- base::Sys.time
  [21:18:55.885]             `[[` <- base::`[[`
  [21:18:55.885]             `+` <- base::`+`
  [21:18:55.885]             `<<-` <- base::`<<-`
  [21:18:55.885]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.885]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.885]                   3L)]
  [21:18:55.885]             }
  [21:18:55.885]             function(cond) {
  [21:18:55.885]                 if (inherits(cond, "error")) {
  [21:18:55.885]                   sessionInformation <- function() {
  [21:18:55.885]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.885]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.885]                       search = base::search(), system = base::Sys.info())
  [21:18:55.885]                   }
  [21:18:55.885]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.885]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.885]                     cond$call), session = sessionInformation(), 
  [21:18:55.885]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.885]                   signalCondition(cond)
  [21:18:55.885]                 }
  [21:18:55.885]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.885]                 ))) {
  [21:18:55.885]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.885]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.885]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.885]                   if (!signal) {
  [21:18:55.885]                     muffleCondition <- function (cond) 
  [21:18:55.885]                     {
  [21:18:55.885]                       inherits <- base::inherits
  [21:18:55.885]                       invokeRestart <- base::invokeRestart
  [21:18:55.885]                       muffled <- FALSE
  [21:18:55.885]                       if (inherits(cond, "message")) {
  [21:18:55.885]                         invokeRestart("muffleMessage")
  [21:18:55.885]                         muffled <- TRUE
  [21:18:55.885]                       }
  [21:18:55.885]                       else if (inherits(cond, "warning")) {
  [21:18:55.885]                         invokeRestart("muffleWarning")
  [21:18:55.885]                         muffled <- TRUE
  [21:18:55.885]                       }
  [21:18:55.885]                       else if (inherits(cond, "condition")) {
  [21:18:55.885]                         computeRestarts <- base::computeRestarts
  [21:18:55.885]                         grepl <- base::grepl
  [21:18:55.885]                         is.null <- base::is.null
  [21:18:55.885]                         restarts <- computeRestarts(cond)
  [21:18:55.885]                         for (restart in restarts) {
  [21:18:55.885]                           name <- restart$name
  [21:18:55.885]                           if (is.null(name)) 
  [21:18:55.885]                             next
  [21:18:55.885]                           if (!grepl("^muffle", name)) 
  [21:18:55.885]                             next
  [21:18:55.885]                           invokeRestart(restart)
  [21:18:55.885]                           muffled <- TRUE
  [21:18:55.885]                           break
  [21:18:55.885]                         }
  [21:18:55.885]                       }
  [21:18:55.885]                       invisible(muffled)
  [21:18:55.885]                     }
  [21:18:55.885]                     muffleCondition(cond)
  [21:18:55.885]                   }
  [21:18:55.885]                 }
  [21:18:55.885]             }
  [21:18:55.885]         }))
  [21:18:55.885]     }, error = function(ex) {
  [21:18:55.885]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.885]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.885]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.885]     }, finally = {
  [21:18:55.885]         {
  [21:18:55.885]             NULL
  [21:18:55.885]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.885]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.885]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.885]                 label = NULL, ...) 
  [21:18:55.885]             {
  [21:18:55.885]                 if (substitute) 
  [21:18:55.885]                   expr <- substitute(expr)
  [21:18:55.885]                 local <- as.logical(local)
  [21:18:55.885]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.885]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.885]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.885]                   label = label, ...)
  [21:18:55.885]                 if (!future$lazy) 
  [21:18:55.885]                   future <- run(future)
  [21:18:55.885]                 invisible(future)
  [21:18:55.885]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.885]         }
  [21:18:55.885]         base::options(...future.oldOptions)
  [21:18:55.885]     })
  [21:18:55.885]     Sys.time
  [21:18:55.885]     if (base::is.na(TRUE)) {
  [21:18:55.885]     }
  [21:18:55.885]     else {
  [21:18:55.885]         base::sink(type = "output", split = FALSE)
  [21:18:55.885]         if (TRUE) {
  [21:18:55.885]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.885]         }
  [21:18:55.885]         else {
  [21:18:55.885]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.885]         }
  [21:18:55.885]         base::close(...future.stdout)
  [21:18:55.885]         ...future.stdout <- NULL
  [21:18:55.885]     }
  [21:18:55.885]     ...future.result$conditions <- ...future.conditions
  [21:18:55.885]     ...future.result
  [21:18:55.885] }
  [21:18:55.905] plan(): Setting new future strategy stack:
  [21:18:55.906] List of future strategies:
  [21:18:55.906] 1. sequential:
  [21:18:55.906]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.906]    - tweaked: FALSE
  [21:18:55.906]    - call: NULL
  [21:18:55.907] plan(): nbrOfWorkers() = 1
  [21:18:55.908] plan(): Setting new future strategy stack:
  [21:18:55.909] List of future strategies:
  [21:18:55.909] 1. sequential:
  [21:18:55.909]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.909]    - tweaked: FALSE
  [21:18:55.909]    - call: plan(strategy)
  [21:18:55.910] plan(): nbrOfWorkers() = 1
  [21:18:55.910] SequentialFuture started (and completed)
  [21:18:55.910] signalConditions() ...
  [21:18:55.911]  - include = 'immediateCondition'
  [21:18:55.911]  - exclude = 
  [21:18:55.911]  - resignal = FALSE
  [21:18:55.912]  - Number of conditions: 1
  [21:18:55.915] signalConditions() ... done
  [21:18:55.916] getGlobalsAndPackages() ...
  [21:18:55.917] Searching for globals...
  [21:18:55.936] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:55.953] Searching for globals ... DONE
  [21:18:55.954] Resolving globals: FALSE
  [21:18:55.955] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:55.955] - globals: [1] 'ii'
  [21:18:55.955] 
  [21:18:55.956] getGlobalsAndPackages() ... DONE
  [21:18:55.957] Packages needed by the future expression (n = 0): <none>
  [21:18:55.957] Packages needed by future strategies (n = 0): <none>
  [21:18:55.962] {
  [21:18:55.962]     {
  [21:18:55.962]         ...future.startTime <- base::Sys.time()
  [21:18:55.962]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:55.962]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:55.962]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:55.962]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:55.962]             future.resolve.recursive = NULL, width = 80L)
  [21:18:55.962]         {
  [21:18:55.962]             {
  [21:18:55.962]                 base::local({
  [21:18:55.962]                   has_future <- base::requireNamespace("future", 
  [21:18:55.962]                     quietly = TRUE)
  [21:18:55.962]                   version <- if (has_future) 
  [21:18:55.962]                     utils::packageVersion("future")
  [21:18:55.962]                   else NULL
  [21:18:55.962]                   if (!has_future || version < "1.8.0") {
  [21:18:55.962]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:55.962]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:55.962]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:55.962]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:55.962]                         "release", "version")], collapse = " "), 
  [21:18:55.962]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:55.962]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:55.962]                       info)
  [21:18:55.962]                     info <- base::paste(info, collapse = "; ")
  [21:18:55.962]                     if (!has_future) {
  [21:18:55.962]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:55.962]                         info)
  [21:18:55.962]                     }
  [21:18:55.962]                     else {
  [21:18:55.962]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:55.962]                         info, version)
  [21:18:55.962]                     }
  [21:18:55.962]                     base::stop(msg)
  [21:18:55.962]                   }
  [21:18:55.962]                 })
  [21:18:55.962]             }
  [21:18:55.962]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:55.962]         }
  [21:18:55.962]     }
  [21:18:55.962]     if (base::is.na(TRUE)) {
  [21:18:55.962]     }
  [21:18:55.962]     else {
  [21:18:55.962]         if (TRUE) {
  [21:18:55.962]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:55.962]                 open = "w")
  [21:18:55.962]         }
  [21:18:55.962]         else {
  [21:18:55.962]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:55.962]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:55.962]         }
  [21:18:55.962]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:55.962]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:55.962]             base::sink(type = "output", split = FALSE)
  [21:18:55.962]             base::close(...future.stdout)
  [21:18:55.962]         }, add = TRUE)
  [21:18:55.962]     }
  [21:18:55.962]     ...future.frame <- base::sys.nframe()
  [21:18:55.962]     ...future.conditions <- base::list()
  [21:18:55.962]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:55.962]     ...future.result <- base::tryCatch({
  [21:18:55.962]         base::withCallingHandlers({
  [21:18:55.962]             ...future.value <- base::withVisible(base::local({
  [21:18:55.962]                 if (ii%%2 == 0) 
  [21:18:55.962]                   stop("Woops!")
  [21:18:55.962]                 ii
  [21:18:55.962]             }))
  [21:18:55.962]             future::FutureResult(value = ...future.value$value, 
  [21:18:55.962]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.962]                   ...future.rng), started = ...future.startTime, 
  [21:18:55.962]                 version = "1.8")
  [21:18:55.962]         }, condition = base::local({
  [21:18:55.962]             c <- base::c
  [21:18:55.962]             inherits <- base::inherits
  [21:18:55.962]             invokeRestart <- base::invokeRestart
  [21:18:55.962]             length <- base::length
  [21:18:55.962]             list <- base::list
  [21:18:55.962]             seq.int <- base::seq.int
  [21:18:55.962]             signalCondition <- base::signalCondition
  [21:18:55.962]             sys.calls <- base::sys.calls
  [21:18:55.962]             Sys.time <- base::Sys.time
  [21:18:55.962]             `[[` <- base::`[[`
  [21:18:55.962]             `+` <- base::`+`
  [21:18:55.962]             `<<-` <- base::`<<-`
  [21:18:55.962]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:55.962]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:55.962]                   3L)]
  [21:18:55.962]             }
  [21:18:55.962]             function(cond) {
  [21:18:55.962]                 if (inherits(cond, "error")) {
  [21:18:55.962]                   sessionInformation <- function() {
  [21:18:55.962]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:55.962]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:55.962]                       search = base::search(), system = base::Sys.info())
  [21:18:55.962]                   }
  [21:18:55.962]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.962]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:55.962]                     cond$call), session = sessionInformation(), 
  [21:18:55.962]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:55.962]                   signalCondition(cond)
  [21:18:55.962]                 }
  [21:18:55.962]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:55.962]                 ))) {
  [21:18:55.962]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:55.962]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:55.962]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:55.962]                   if (!signal) {
  [21:18:55.962]                     muffleCondition <- function (cond) 
  [21:18:55.962]                     {
  [21:18:55.962]                       inherits <- base::inherits
  [21:18:55.962]                       invokeRestart <- base::invokeRestart
  [21:18:55.962]                       muffled <- FALSE
  [21:18:55.962]                       if (inherits(cond, "message")) {
  [21:18:55.962]                         invokeRestart("muffleMessage")
  [21:18:55.962]                         muffled <- TRUE
  [21:18:55.962]                       }
  [21:18:55.962]                       else if (inherits(cond, "warning")) {
  [21:18:55.962]                         invokeRestart("muffleWarning")
  [21:18:55.962]                         muffled <- TRUE
  [21:18:55.962]                       }
  [21:18:55.962]                       else if (inherits(cond, "condition")) {
  [21:18:55.962]                         computeRestarts <- base::computeRestarts
  [21:18:55.962]                         grepl <- base::grepl
  [21:18:55.962]                         is.null <- base::is.null
  [21:18:55.962]                         restarts <- computeRestarts(cond)
  [21:18:55.962]                         for (restart in restarts) {
  [21:18:55.962]                           name <- restart$name
  [21:18:55.962]                           if (is.null(name)) 
  [21:18:55.962]                             next
  [21:18:55.962]                           if (!grepl("^muffle", name)) 
  [21:18:55.962]                             next
  [21:18:55.962]                           invokeRestart(restart)
  [21:18:55.962]                           muffled <- TRUE
  [21:18:55.962]                           break
  [21:18:55.962]                         }
  [21:18:55.962]                       }
  [21:18:55.962]                       invisible(muffled)
  [21:18:55.962]                     }
  [21:18:55.962]                     muffleCondition(cond)
  [21:18:55.962]                   }
  [21:18:55.962]                 }
  [21:18:55.962]             }
  [21:18:55.962]         }))
  [21:18:55.962]     }, error = function(ex) {
  [21:18:55.962]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:55.962]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:55.962]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:55.962]     }, finally = {
  [21:18:55.962]         {
  [21:18:55.962]             NULL
  [21:18:55.962]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:55.962]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:55.962]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:55.962]                 label = NULL, ...) 
  [21:18:55.962]             {
  [21:18:55.962]                 if (substitute) 
  [21:18:55.962]                   expr <- substitute(expr)
  [21:18:55.962]                 local <- as.logical(local)
  [21:18:55.962]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:55.962]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:55.962]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:55.962]                   label = label, ...)
  [21:18:55.962]                 if (!future$lazy) 
  [21:18:55.962]                   future <- run(future)
  [21:18:55.962]                 invisible(future)
  [21:18:55.962]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:55.962]         }
  [21:18:55.962]         base::options(...future.oldOptions)
  [21:18:55.962]     })
  [21:18:55.962]     Sys.time
  [21:18:55.962]     if (base::is.na(TRUE)) {
  [21:18:55.962]     }
  [21:18:55.962]     else {
  [21:18:55.962]         base::sink(type = "output", split = FALSE)
  [21:18:55.962]         if (TRUE) {
  [21:18:55.962]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:55.962]         }
  [21:18:55.962]         else {
  [21:18:55.962]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:55.962]         }
  [21:18:55.962]         base::close(...future.stdout)
  [21:18:55.962]         ...future.stdout <- NULL
  [21:18:55.962]     }
  [21:18:55.962]     ...future.result$conditions <- ...future.conditions
  [21:18:55.962]     ...future.result
  [21:18:55.962] }
  [21:18:55.982] plan(): Setting new future strategy stack:
  [21:18:55.983] List of future strategies:
  [21:18:55.983] 1. sequential:
  [21:18:55.983]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.983]    - tweaked: FALSE
  [21:18:55.983]    - call: NULL
  [21:18:55.984] plan(): nbrOfWorkers() = 1
  [21:18:55.985] plan(): Setting new future strategy stack:
  [21:18:55.985] List of future strategies:
  [21:18:55.985] 1. sequential:
  [21:18:55.985]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:55.985]    - tweaked: FALSE
  [21:18:55.985]    - call: plan(strategy)
  [21:18:55.986] plan(): nbrOfWorkers() = 1
  [21:18:55.986] SequentialFuture started (and completed)
  [21:18:55.987] signalConditions() ...
  [21:18:55.988]  - include = 'immediateCondition'
  [21:18:55.988]  - exclude = 
  [21:18:55.988]  - resignal = FALSE
  [21:18:55.989]  - Number of conditions: 1
  [21:18:55.989] signalConditions() ... done
  [21:18:55.989] Future state: 'finished'
  [21:18:55.990] signalConditions() ...
  [21:18:55.990]  - include = 'condition'
  [21:18:55.990]  - exclude = 'immediateCondition'
  [21:18:55.990]  - resignal = TRUE
  [21:18:55.991]  - Number of conditions: 1
  [21:18:55.991]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:55.991] signalConditions() ... done
  Warning in get(var, envir = x, inherits = FALSE) :
    restarting interrupted promise evaluation
  [21:18:55.994] signalConditions() ...
  [21:18:55.994]  - include = 'immediateCondition'
  [21:18:55.994]  - exclude = 
  [21:18:55.995]  - resignal = FALSE
  [21:18:55.995]  - Number of conditions: 1
  [21:18:55.995] signalConditions() ... done
  [21:18:55.996] Future state: 'finished'
  [21:18:55.996] signalConditions() ...
  [21:18:55.996]  - include = 'condition'
  [21:18:55.997]  - exclude = 'immediateCondition'
  [21:18:55.997]  - resignal = TRUE
  [21:18:55.997]  - Number of conditions: 1
  [21:18:55.997]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.014] signalConditions() ... done
  Warning in get(var, envir = x, inherits = FALSE) :
    restarting interrupted promise evaluation
  [21:18:56.015] signalConditions() ...
  [21:18:56.015]  - include = 'immediateCondition'
  [21:18:56.015]  - exclude = 
  [21:18:56.016]  - resignal = FALSE
  [21:18:56.016]  - Number of conditions: 1
  [21:18:56.016] signalConditions() ... done
  [21:18:56.017] Future state: 'finished'
  [21:18:56.017] signalConditions() ...
  [21:18:56.017]  - include = 'condition'
  [21:18:56.017]  - exclude = 'immediateCondition'
  [21:18:56.018]  - resignal = TRUE
  [21:18:56.018]  - Number of conditions: 1
  [21:18:56.018]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.019] signalConditions() ... done
  ** Future evaluation with a poor-man's "progress bar"
  [21:18:56.019] getGlobalsAndPackages() ...
  [21:18:56.020] Searching for globals...
  [21:18:56.022] - globals found: [4] '{', 'cat', 'for', ':'
  [21:18:56.023] Searching for globals ... DONE
  [21:18:56.023] Resolving globals: FALSE
  [21:18:56.024] 
  [21:18:56.024] 
  [21:18:56.024] getGlobalsAndPackages() ... DONE
  [21:18:56.026] Packages needed by the future expression (n = 0): <none>
  [21:18:56.026] Packages needed by future strategies (n = 0): <none>
  [21:18:56.046] {
  [21:18:56.046]     {
  [21:18:56.046]         ...future.startTime <- base::Sys.time()
  [21:18:56.046]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.046]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.046]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.046]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.046]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.046]         {
  [21:18:56.046]             {
  [21:18:56.046]                 base::local({
  [21:18:56.046]                   has_future <- base::requireNamespace("future", 
  [21:18:56.046]                     quietly = TRUE)
  [21:18:56.046]                   version <- if (has_future) 
  [21:18:56.046]                     utils::packageVersion("future")
  [21:18:56.046]                   else NULL
  [21:18:56.046]                   if (!has_future || version < "1.8.0") {
  [21:18:56.046]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.046]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.046]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.046]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.046]                         "release", "version")], collapse = " "), 
  [21:18:56.046]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.046]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.046]                       info)
  [21:18:56.046]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.046]                     if (!has_future) {
  [21:18:56.046]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.046]                         info)
  [21:18:56.046]                     }
  [21:18:56.046]                     else {
  [21:18:56.046]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.046]                         info, version)
  [21:18:56.046]                     }
  [21:18:56.046]                     base::stop(msg)
  [21:18:56.046]                   }
  [21:18:56.046]                 })
  [21:18:56.046]             }
  [21:18:56.046]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.046]         }
  [21:18:56.046]     }
  [21:18:56.046]     if (base::is.na(TRUE)) {
  [21:18:56.046]     }
  [21:18:56.046]     else {
  [21:18:56.046]         if (TRUE) {
  [21:18:56.046]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.046]                 open = "w")
  [21:18:56.046]         }
  [21:18:56.046]         else {
  [21:18:56.046]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.046]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.046]         }
  [21:18:56.046]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.046]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.046]             base::sink(type = "output", split = FALSE)
  [21:18:56.046]             base::close(...future.stdout)
  [21:18:56.046]         }, add = TRUE)
  [21:18:56.046]     }
  [21:18:56.046]     ...future.frame <- base::sys.nframe()
  [21:18:56.046]     ...future.conditions <- base::list()
  [21:18:56.046]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.046]     ...future.result <- base::tryCatch({
  [21:18:56.046]         base::withCallingHandlers({
  [21:18:56.046]             ...future.value <- base::withVisible(base::local({
  [21:18:56.046]                 cat("Processing: ")
  [21:18:56.046]                 for (ii in 1:10) {
  [21:18:56.046]                   cat(".")
  [21:18:56.046]                 }
  [21:18:56.046]                 cat(" [100%]\n")
  [21:18:56.046]                 4
  [21:18:56.046]             }))
  [21:18:56.046]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.046]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.046]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.046]                 version = "1.8")
  [21:18:56.046]         }, condition = base::local({
  [21:18:56.046]             c <- base::c
  [21:18:56.046]             inherits <- base::inherits
  [21:18:56.046]             invokeRestart <- base::invokeRestart
  [21:18:56.046]             length <- base::length
  [21:18:56.046]             list <- base::list
  [21:18:56.046]             seq.int <- base::seq.int
  [21:18:56.046]             signalCondition <- base::signalCondition
  [21:18:56.046]             sys.calls <- base::sys.calls
  [21:18:56.046]             Sys.time <- base::Sys.time
  [21:18:56.046]             `[[` <- base::`[[`
  [21:18:56.046]             `+` <- base::`+`
  [21:18:56.046]             `<<-` <- base::`<<-`
  [21:18:56.046]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.046]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.046]                   3L)]
  [21:18:56.046]             }
  [21:18:56.046]             function(cond) {
  [21:18:56.046]                 if (inherits(cond, "error")) {
  [21:18:56.046]                   sessionInformation <- function() {
  [21:18:56.046]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.046]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.046]                       search = base::search(), system = base::Sys.info())
  [21:18:56.046]                   }
  [21:18:56.046]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.046]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.046]                     cond$call), session = sessionInformation(), 
  [21:18:56.046]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.046]                   signalCondition(cond)
  [21:18:56.046]                 }
  [21:18:56.046]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.046]                 ))) {
  [21:18:56.046]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.046]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.046]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.046]                   if (!signal) {
  [21:18:56.046]                     muffleCondition <- function (cond) 
  [21:18:56.046]                     {
  [21:18:56.046]                       inherits <- base::inherits
  [21:18:56.046]                       invokeRestart <- base::invokeRestart
  [21:18:56.046]                       muffled <- FALSE
  [21:18:56.046]                       if (inherits(cond, "message")) {
  [21:18:56.046]                         invokeRestart("muffleMessage")
  [21:18:56.046]                         muffled <- TRUE
  [21:18:56.046]                       }
  [21:18:56.046]                       else if (inherits(cond, "warning")) {
  [21:18:56.046]                         invokeRestart("muffleWarning")
  [21:18:56.046]                         muffled <- TRUE
  [21:18:56.046]                       }
  [21:18:56.046]                       else if (inherits(cond, "condition")) {
  [21:18:56.046]                         computeRestarts <- base::computeRestarts
  [21:18:56.046]                         grepl <- base::grepl
  [21:18:56.046]                         is.null <- base::is.null
  [21:18:56.046]                         restarts <- computeRestarts(cond)
  [21:18:56.046]                         for (restart in restarts) {
  [21:18:56.046]                           name <- restart$name
  [21:18:56.046]                           if (is.null(name)) 
  [21:18:56.046]                             next
  [21:18:56.046]                           if (!grepl("^muffle", name)) 
  [21:18:56.046]                             next
  [21:18:56.046]                           invokeRestart(restart)
  [21:18:56.046]                           muffled <- TRUE
  [21:18:56.046]                           break
  [21:18:56.046]                         }
  [21:18:56.046]                       }
  [21:18:56.046]                       invisible(muffled)
  [21:18:56.046]                     }
  [21:18:56.046]                     muffleCondition(cond)
  [21:18:56.046]                   }
  [21:18:56.046]                 }
  [21:18:56.046]             }
  [21:18:56.046]         }))
  [21:18:56.046]     }, error = function(ex) {
  [21:18:56.046]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.046]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.046]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.046]     }, finally = {
  [21:18:56.046]         {
  [21:18:56.046]             NULL
  [21:18:56.046]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.046]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.046]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.046]                 label = NULL, ...) 
  [21:18:56.046]             {
  [21:18:56.046]                 if (substitute) 
  [21:18:56.046]                   expr <- substitute(expr)
  [21:18:56.046]                 local <- as.logical(local)
  [21:18:56.046]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.046]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.046]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.046]                   label = label, ...)
  [21:18:56.046]                 if (!future$lazy) 
  [21:18:56.046]                   future <- run(future)
  [21:18:56.046]                 invisible(future)
  [21:18:56.046]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.046]         }
  [21:18:56.046]         base::options(...future.oldOptions)
  [21:18:56.046]     })
  [21:18:56.046]     Sys.time
  [21:18:56.046]     if (base::is.na(TRUE)) {
  [21:18:56.046]     }
  [21:18:56.046]     else {
  [21:18:56.046]         base::sink(type = "output", split = FALSE)
  [21:18:56.046]         if (TRUE) {
  [21:18:56.046]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.046]         }
  [21:18:56.046]         else {
  [21:18:56.046]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.046]         }
  [21:18:56.046]         base::close(...future.stdout)
  [21:18:56.046]         ...future.stdout <- NULL
  [21:18:56.046]     }
  [21:18:56.046]     ...future.result$conditions <- ...future.conditions
  [21:18:56.046]     ...future.result
  [21:18:56.046] }
  [21:18:56.051] plan(): Setting new future strategy stack:
  [21:18:56.052] List of future strategies:
  [21:18:56.052] 1. sequential:
  [21:18:56.052]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.052]    - tweaked: FALSE
  [21:18:56.052]    - call: NULL
  [21:18:56.052] plan(): nbrOfWorkers() = 1
  [21:18:56.054] plan(): Setting new future strategy stack:
  [21:18:56.054] List of future strategies:
  [21:18:56.054] 1. sequential:
  [21:18:56.054]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.054]    - tweaked: FALSE
  [21:18:56.054]    - call: plan(strategy)
  [21:18:56.055] plan(): nbrOfWorkers() = 1
  [21:18:56.055] SequentialFuture started (and completed)
  ** Collecting results
  v1 = 1
  v2 = 2
  Warning in sprintf(...) : restarting interrupted promise evaluation
  [21:18:56.059] signalConditions() ...
  [21:18:56.059]  - include = 'immediateCondition'
  [21:18:56.059]  - exclude = 
  [21:18:56.060]  - resignal = FALSE
  [21:18:56.060]  - Number of conditions: 1
  [21:18:56.060] signalConditions() ... done
  [21:18:56.061] Future state: 'finished'
  [21:18:56.061] signalConditions() ...
  [21:18:56.061]  - include = 'condition'
  [21:18:56.062]  - exclude = 'immediateCondition'
  [21:18:56.078]  - resignal = TRUE
  [21:18:56.078]  - Number of conditions: 1
  [21:18:56.079]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.079] signalConditions() ... done
  v3: <simpleError> (as expect)
  Processing: .......... [100%]
  v4 = 4
  ** Left-to-right and right-to-left future assignments
  [21:18:56.080] getGlobalsAndPackages() ...
  [21:18:56.080] Searching for globals...
  [21:18:56.081] 
  [21:18:56.081] Searching for globals ... DONE
  [21:18:56.082] - globals: [0] <none>
  [21:18:56.082] getGlobalsAndPackages() ... DONE
  [21:18:56.084] Packages needed by the future expression (n = 0): <none>
  [21:18:56.084] Packages needed by future strategies (n = 0): <none>
  [21:18:56.091] {
  [21:18:56.091]     {
  [21:18:56.091]         ...future.startTime <- base::Sys.time()
  [21:18:56.091]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.091]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.091]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.091]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.091]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.091]         {
  [21:18:56.091]             {
  [21:18:56.091]                 base::local({
  [21:18:56.091]                   has_future <- base::requireNamespace("future", 
  [21:18:56.091]                     quietly = TRUE)
  [21:18:56.091]                   version <- if (has_future) 
  [21:18:56.091]                     utils::packageVersion("future")
  [21:18:56.091]                   else NULL
  [21:18:56.091]                   if (!has_future || version < "1.8.0") {
  [21:18:56.091]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.091]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.091]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.091]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.091]                         "release", "version")], collapse = " "), 
  [21:18:56.091]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.091]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.091]                       info)
  [21:18:56.091]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.091]                     if (!has_future) {
  [21:18:56.091]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.091]                         info)
  [21:18:56.091]                     }
  [21:18:56.091]                     else {
  [21:18:56.091]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.091]                         info, version)
  [21:18:56.091]                     }
  [21:18:56.091]                     base::stop(msg)
  [21:18:56.091]                   }
  [21:18:56.091]                 })
  [21:18:56.091]             }
  [21:18:56.091]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.091]         }
  [21:18:56.091]     }
  [21:18:56.091]     if (base::is.na(TRUE)) {
  [21:18:56.091]     }
  [21:18:56.091]     else {
  [21:18:56.091]         if (TRUE) {
  [21:18:56.091]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.091]                 open = "w")
  [21:18:56.091]         }
  [21:18:56.091]         else {
  [21:18:56.091]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.091]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.091]         }
  [21:18:56.091]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.091]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.091]             base::sink(type = "output", split = FALSE)
  [21:18:56.091]             base::close(...future.stdout)
  [21:18:56.091]         }, add = TRUE)
  [21:18:56.091]     }
  [21:18:56.091]     ...future.frame <- base::sys.nframe()
  [21:18:56.091]     ...future.conditions <- base::list()
  [21:18:56.091]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.091]     ...future.result <- base::tryCatch({
  [21:18:56.091]         base::withCallingHandlers({
  [21:18:56.091]             ...future.value <- base::withVisible(base::local(1))
  [21:18:56.091]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.091]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.091]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.091]                 version = "1.8")
  [21:18:56.091]         }, condition = base::local({
  [21:18:56.091]             c <- base::c
  [21:18:56.091]             inherits <- base::inherits
  [21:18:56.091]             invokeRestart <- base::invokeRestart
  [21:18:56.091]             length <- base::length
  [21:18:56.091]             list <- base::list
  [21:18:56.091]             seq.int <- base::seq.int
  [21:18:56.091]             signalCondition <- base::signalCondition
  [21:18:56.091]             sys.calls <- base::sys.calls
  [21:18:56.091]             Sys.time <- base::Sys.time
  [21:18:56.091]             `[[` <- base::`[[`
  [21:18:56.091]             `+` <- base::`+`
  [21:18:56.091]             `<<-` <- base::`<<-`
  [21:18:56.091]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.091]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.091]                   3L)]
  [21:18:56.091]             }
  [21:18:56.091]             function(cond) {
  [21:18:56.091]                 if (inherits(cond, "error")) {
  [21:18:56.091]                   sessionInformation <- function() {
  [21:18:56.091]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.091]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.091]                       search = base::search(), system = base::Sys.info())
  [21:18:56.091]                   }
  [21:18:56.091]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.091]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.091]                     cond$call), session = sessionInformation(), 
  [21:18:56.091]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.091]                   signalCondition(cond)
  [21:18:56.091]                 }
  [21:18:56.091]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.091]                 ))) {
  [21:18:56.091]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.091]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.091]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.091]                   if (!signal) {
  [21:18:56.091]                     muffleCondition <- function (cond) 
  [21:18:56.091]                     {
  [21:18:56.091]                       inherits <- base::inherits
  [21:18:56.091]                       invokeRestart <- base::invokeRestart
  [21:18:56.091]                       muffled <- FALSE
  [21:18:56.091]                       if (inherits(cond, "message")) {
  [21:18:56.091]                         invokeRestart("muffleMessage")
  [21:18:56.091]                         muffled <- TRUE
  [21:18:56.091]                       }
  [21:18:56.091]                       else if (inherits(cond, "warning")) {
  [21:18:56.091]                         invokeRestart("muffleWarning")
  [21:18:56.091]                         muffled <- TRUE
  [21:18:56.091]                       }
  [21:18:56.091]                       else if (inherits(cond, "condition")) {
  [21:18:56.091]                         computeRestarts <- base::computeRestarts
  [21:18:56.091]                         grepl <- base::grepl
  [21:18:56.091]                         is.null <- base::is.null
  [21:18:56.091]                         restarts <- computeRestarts(cond)
  [21:18:56.091]                         for (restart in restarts) {
  [21:18:56.091]                           name <- restart$name
  [21:18:56.091]                           if (is.null(name)) 
  [21:18:56.091]                             next
  [21:18:56.091]                           if (!grepl("^muffle", name)) 
  [21:18:56.091]                             next
  [21:18:56.091]                           invokeRestart(restart)
  [21:18:56.091]                           muffled <- TRUE
  [21:18:56.091]                           break
  [21:18:56.091]                         }
  [21:18:56.091]                       }
  [21:18:56.091]                       invisible(muffled)
  [21:18:56.091]                     }
  [21:18:56.091]                     muffleCondition(cond)
  [21:18:56.091]                   }
  [21:18:56.091]                 }
  [21:18:56.091]             }
  [21:18:56.091]         }))
  [21:18:56.091]     }, error = function(ex) {
  [21:18:56.091]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.091]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.091]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.091]     }, finally = {
  [21:18:56.091]         {
  [21:18:56.091]             NULL
  [21:18:56.091]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.091]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.091]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.091]                 label = NULL, ...) 
  [21:18:56.091]             {
  [21:18:56.091]                 if (substitute) 
  [21:18:56.091]                   expr <- substitute(expr)
  [21:18:56.091]                 local <- as.logical(local)
  [21:18:56.091]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.091]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.091]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.091]                   label = label, ...)
  [21:18:56.091]                 if (!future$lazy) 
  [21:18:56.091]                   future <- run(future)
  [21:18:56.091]                 invisible(future)
  [21:18:56.091]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.091]         }
  [21:18:56.091]         base::options(...future.oldOptions)
  [21:18:56.091]     })
  [21:18:56.091]     Sys.time
  [21:18:56.091]     if (base::is.na(TRUE)) {
  [21:18:56.091]     }
  [21:18:56.091]     else {
  [21:18:56.091]         base::sink(type = "output", split = FALSE)
  [21:18:56.091]         if (TRUE) {
  [21:18:56.091]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.091]         }
  [21:18:56.091]         else {
  [21:18:56.091]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.091]         }
  [21:18:56.091]         base::close(...future.stdout)
  [21:18:56.091]         ...future.stdout <- NULL
  [21:18:56.091]     }
  [21:18:56.091]     ...future.result$conditions <- ...future.conditions
  [21:18:56.091]     ...future.result
  [21:18:56.091] }
  [21:18:56.112] plan(): Setting new future strategy stack:
  [21:18:56.112] List of future strategies:
  [21:18:56.112] 1. sequential:
  [21:18:56.112]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.112]    - tweaked: FALSE
  [21:18:56.112]    - call: NULL
  [21:18:56.113] plan(): nbrOfWorkers() = 1
  [21:18:56.114] plan(): Setting new future strategy stack:
  [21:18:56.114] List of future strategies:
  [21:18:56.114] 1. sequential:
  [21:18:56.114]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.114]    - tweaked: FALSE
  [21:18:56.114]    - call: plan(strategy)
  [21:18:56.115] plan(): nbrOfWorkers() = 1
  [21:18:56.116] SequentialFuture started (and completed)
  c = 1
  [21:18:56.117] getGlobalsAndPackages() ...
  [21:18:56.117] Searching for globals...
  [21:18:56.118] 
  [21:18:56.118] Searching for globals ... DONE
  [21:18:56.119] - globals: [0] <none>
  [21:18:56.119] getGlobalsAndPackages() ... DONE
  [21:18:56.120] Packages needed by the future expression (n = 0): <none>
  [21:18:56.121] Packages needed by future strategies (n = 0): <none>
  [21:18:56.125] {
  [21:18:56.125]     {
  [21:18:56.125]         ...future.startTime <- base::Sys.time()
  [21:18:56.125]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.125]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.125]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.125]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.125]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.125]         {
  [21:18:56.125]             {
  [21:18:56.125]                 base::local({
  [21:18:56.125]                   has_future <- base::requireNamespace("future", 
  [21:18:56.125]                     quietly = TRUE)
  [21:18:56.125]                   version <- if (has_future) 
  [21:18:56.125]                     utils::packageVersion("future")
  [21:18:56.125]                   else NULL
  [21:18:56.125]                   if (!has_future || version < "1.8.0") {
  [21:18:56.125]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.125]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.125]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.125]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.125]                         "release", "version")], collapse = " "), 
  [21:18:56.125]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.125]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.125]                       info)
  [21:18:56.125]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.125]                     if (!has_future) {
  [21:18:56.125]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.125]                         info)
  [21:18:56.125]                     }
  [21:18:56.125]                     else {
  [21:18:56.125]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.125]                         info, version)
  [21:18:56.125]                     }
  [21:18:56.125]                     base::stop(msg)
  [21:18:56.125]                   }
  [21:18:56.125]                 })
  [21:18:56.125]             }
  [21:18:56.125]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.125]         }
  [21:18:56.125]     }
  [21:18:56.125]     if (base::is.na(TRUE)) {
  [21:18:56.125]     }
  [21:18:56.125]     else {
  [21:18:56.125]         if (TRUE) {
  [21:18:56.125]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.125]                 open = "w")
  [21:18:56.125]         }
  [21:18:56.125]         else {
  [21:18:56.125]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.125]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.125]         }
  [21:18:56.125]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.125]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.125]             base::sink(type = "output", split = FALSE)
  [21:18:56.125]             base::close(...future.stdout)
  [21:18:56.125]         }, add = TRUE)
  [21:18:56.125]     }
  [21:18:56.125]     ...future.frame <- base::sys.nframe()
  [21:18:56.125]     ...future.conditions <- base::list()
  [21:18:56.125]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.125]     ...future.result <- base::tryCatch({
  [21:18:56.125]         base::withCallingHandlers({
  [21:18:56.125]             ...future.value <- base::withVisible(base::local(1))
  [21:18:56.125]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.125]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.125]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.125]                 version = "1.8")
  [21:18:56.125]         }, condition = base::local({
  [21:18:56.125]             c <- base::c
  [21:18:56.125]             inherits <- base::inherits
  [21:18:56.125]             invokeRestart <- base::invokeRestart
  [21:18:56.125]             length <- base::length
  [21:18:56.125]             list <- base::list
  [21:18:56.125]             seq.int <- base::seq.int
  [21:18:56.125]             signalCondition <- base::signalCondition
  [21:18:56.125]             sys.calls <- base::sys.calls
  [21:18:56.125]             Sys.time <- base::Sys.time
  [21:18:56.125]             `[[` <- base::`[[`
  [21:18:56.125]             `+` <- base::`+`
  [21:18:56.125]             `<<-` <- base::`<<-`
  [21:18:56.125]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.125]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.125]                   3L)]
  [21:18:56.125]             }
  [21:18:56.125]             function(cond) {
  [21:18:56.125]                 if (inherits(cond, "error")) {
  [21:18:56.125]                   sessionInformation <- function() {
  [21:18:56.125]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.125]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.125]                       search = base::search(), system = base::Sys.info())
  [21:18:56.125]                   }
  [21:18:56.125]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.125]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.125]                     cond$call), session = sessionInformation(), 
  [21:18:56.125]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.125]                   signalCondition(cond)
  [21:18:56.125]                 }
  [21:18:56.125]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.125]                 ))) {
  [21:18:56.125]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.125]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.125]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.125]                   if (!signal) {
  [21:18:56.125]                     muffleCondition <- function (cond) 
  [21:18:56.125]                     {
  [21:18:56.125]                       inherits <- base::inherits
  [21:18:56.125]                       invokeRestart <- base::invokeRestart
  [21:18:56.125]                       muffled <- FALSE
  [21:18:56.125]                       if (inherits(cond, "message")) {
  [21:18:56.125]                         invokeRestart("muffleMessage")
  [21:18:56.125]                         muffled <- TRUE
  [21:18:56.125]                       }
  [21:18:56.125]                       else if (inherits(cond, "warning")) {
  [21:18:56.125]                         invokeRestart("muffleWarning")
  [21:18:56.125]                         muffled <- TRUE
  [21:18:56.125]                       }
  [21:18:56.125]                       else if (inherits(cond, "condition")) {
  [21:18:56.125]                         computeRestarts <- base::computeRestarts
  [21:18:56.125]                         grepl <- base::grepl
  [21:18:56.125]                         is.null <- base::is.null
  [21:18:56.125]                         restarts <- computeRestarts(cond)
  [21:18:56.125]                         for (restart in restarts) {
  [21:18:56.125]                           name <- restart$name
  [21:18:56.125]                           if (is.null(name)) 
  [21:18:56.125]                             next
  [21:18:56.125]                           if (!grepl("^muffle", name)) 
  [21:18:56.125]                             next
  [21:18:56.125]                           invokeRestart(restart)
  [21:18:56.125]                           muffled <- TRUE
  [21:18:56.125]                           break
  [21:18:56.125]                         }
  [21:18:56.125]                       }
  [21:18:56.125]                       invisible(muffled)
  [21:18:56.125]                     }
  [21:18:56.125]                     muffleCondition(cond)
  [21:18:56.125]                   }
  [21:18:56.125]                 }
  [21:18:56.125]             }
  [21:18:56.125]         }))
  [21:18:56.125]     }, error = function(ex) {
  [21:18:56.125]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.125]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.125]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.125]     }, finally = {
  [21:18:56.125]         {
  [21:18:56.125]             NULL
  [21:18:56.125]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.125]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.125]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.125]                 label = NULL, ...) 
  [21:18:56.125]             {
  [21:18:56.125]                 if (substitute) 
  [21:18:56.125]                   expr <- substitute(expr)
  [21:18:56.125]                 local <- as.logical(local)
  [21:18:56.125]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.125]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.125]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.125]                   label = label, ...)
  [21:18:56.125]                 if (!future$lazy) 
  [21:18:56.125]                   future <- run(future)
  [21:18:56.125]                 invisible(future)
  [21:18:56.125]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.125]         }
  [21:18:56.125]         base::options(...future.oldOptions)
  [21:18:56.125]     })
  [21:18:56.125]     Sys.time
  [21:18:56.125]     if (base::is.na(TRUE)) {
  [21:18:56.125]     }
  [21:18:56.125]     else {
  [21:18:56.125]         base::sink(type = "output", split = FALSE)
  [21:18:56.125]         if (TRUE) {
  [21:18:56.125]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.125]         }
  [21:18:56.125]         else {
  [21:18:56.125]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.125]         }
  [21:18:56.125]         base::close(...future.stdout)
  [21:18:56.125]         ...future.stdout <- NULL
  [21:18:56.125]     }
  [21:18:56.125]     ...future.result$conditions <- ...future.conditions
  [21:18:56.125]     ...future.result
  [21:18:56.125] }
  [21:18:56.133] plan(): Setting new future strategy stack:
  [21:18:56.134] List of future strategies:
  [21:18:56.134] 1. sequential:
  [21:18:56.134]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.134]    - tweaked: FALSE
  [21:18:56.134]    - call: NULL
  [21:18:56.135] plan(): nbrOfWorkers() = 1
  [21:18:56.136] plan(): Setting new future strategy stack:
  [21:18:56.136] List of future strategies:
  [21:18:56.136] 1. sequential:
  [21:18:56.136]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.136]    - tweaked: FALSE
  [21:18:56.136]    - call: plan(strategy)
  [21:18:56.137] plan(): nbrOfWorkers() = 1
  [21:18:56.137] SequentialFuture started (and completed)
  d = 1
  ** Nested future assignments
  [21:18:56.138] getGlobalsAndPackages() ...
  [21:18:56.139] Searching for globals...
  [21:18:56.143] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
  [21:18:56.144] Searching for globals ... DONE
  [21:18:56.144] Resolving globals: FALSE
  [21:18:56.145] 
  [21:18:56.145] - packages: [1] 'future'
  [21:18:56.162] getGlobalsAndPackages() ... DONE
  [21:18:56.164] Packages needed by the future expression (n = 0): <none>
  [21:18:56.164] Packages needed by future strategies (n = 0): <none>
  [21:18:56.168] {
  [21:18:56.168]     {
  [21:18:56.168]         ...future.startTime <- base::Sys.time()
  [21:18:56.168]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.168]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.168]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.168]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.168]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.168]         {
  [21:18:56.168]             {
  [21:18:56.168]                 base::local({
  [21:18:56.168]                   has_future <- base::requireNamespace("future", 
  [21:18:56.168]                     quietly = TRUE)
  [21:18:56.168]                   version <- if (has_future) 
  [21:18:56.168]                     utils::packageVersion("future")
  [21:18:56.168]                   else NULL
  [21:18:56.168]                   if (!has_future || version < "1.8.0") {
  [21:18:56.168]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.168]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.168]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.168]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.168]                         "release", "version")], collapse = " "), 
  [21:18:56.168]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.168]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.168]                       info)
  [21:18:56.168]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.168]                     if (!has_future) {
  [21:18:56.168]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.168]                         info)
  [21:18:56.168]                     }
  [21:18:56.168]                     else {
  [21:18:56.168]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.168]                         info, version)
  [21:18:56.168]                     }
  [21:18:56.168]                     base::stop(msg)
  [21:18:56.168]                   }
  [21:18:56.168]                 })
  [21:18:56.168]             }
  [21:18:56.168]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.168]         }
  [21:18:56.168]     }
  [21:18:56.168]     if (base::is.na(TRUE)) {
  [21:18:56.168]     }
  [21:18:56.168]     else {
  [21:18:56.168]         if (TRUE) {
  [21:18:56.168]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.168]                 open = "w")
  [21:18:56.168]         }
  [21:18:56.168]         else {
  [21:18:56.168]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.168]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.168]         }
  [21:18:56.168]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.168]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.168]             base::sink(type = "output", split = FALSE)
  [21:18:56.168]             base::close(...future.stdout)
  [21:18:56.168]         }, add = TRUE)
  [21:18:56.168]     }
  [21:18:56.168]     ...future.frame <- base::sys.nframe()
  [21:18:56.168]     ...future.conditions <- base::list()
  [21:18:56.168]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.168]     ...future.result <- base::tryCatch({
  [21:18:56.168]         base::withCallingHandlers({
  [21:18:56.168]             ...future.value <- base::withVisible(base::local({
  [21:18:56.168]                 b <- 1
  [21:18:56.168]                 c %<-% 2
  [21:18:56.168]                 d <- 3
  [21:18:56.168]                 4 %->% e
  [21:18:56.168]                 b + c + d + e
  [21:18:56.168]             }))
  [21:18:56.168]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.168]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.168]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.168]                 version = "1.8")
  [21:18:56.168]         }, condition = base::local({
  [21:18:56.168]             c <- base::c
  [21:18:56.168]             inherits <- base::inherits
  [21:18:56.168]             invokeRestart <- base::invokeRestart
  [21:18:56.168]             length <- base::length
  [21:18:56.168]             list <- base::list
  [21:18:56.168]             seq.int <- base::seq.int
  [21:18:56.168]             signalCondition <- base::signalCondition
  [21:18:56.168]             sys.calls <- base::sys.calls
  [21:18:56.168]             Sys.time <- base::Sys.time
  [21:18:56.168]             `[[` <- base::`[[`
  [21:18:56.168]             `+` <- base::`+`
  [21:18:56.168]             `<<-` <- base::`<<-`
  [21:18:56.168]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.168]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.168]                   3L)]
  [21:18:56.168]             }
  [21:18:56.168]             function(cond) {
  [21:18:56.168]                 if (inherits(cond, "error")) {
  [21:18:56.168]                   sessionInformation <- function() {
  [21:18:56.168]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.168]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.168]                       search = base::search(), system = base::Sys.info())
  [21:18:56.168]                   }
  [21:18:56.168]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.168]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.168]                     cond$call), session = sessionInformation(), 
  [21:18:56.168]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.168]                   signalCondition(cond)
  [21:18:56.168]                 }
  [21:18:56.168]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.168]                 ))) {
  [21:18:56.168]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.168]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.168]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.168]                   if (!signal) {
  [21:18:56.168]                     muffleCondition <- function (cond) 
  [21:18:56.168]                     {
  [21:18:56.168]                       inherits <- base::inherits
  [21:18:56.168]                       invokeRestart <- base::invokeRestart
  [21:18:56.168]                       muffled <- FALSE
  [21:18:56.168]                       if (inherits(cond, "message")) {
  [21:18:56.168]                         invokeRestart("muffleMessage")
  [21:18:56.168]                         muffled <- TRUE
  [21:18:56.168]                       }
  [21:18:56.168]                       else if (inherits(cond, "warning")) {
  [21:18:56.168]                         invokeRestart("muffleWarning")
  [21:18:56.168]                         muffled <- TRUE
  [21:18:56.168]                       }
  [21:18:56.168]                       else if (inherits(cond, "condition")) {
  [21:18:56.168]                         computeRestarts <- base::computeRestarts
  [21:18:56.168]                         grepl <- base::grepl
  [21:18:56.168]                         is.null <- base::is.null
  [21:18:56.168]                         restarts <- computeRestarts(cond)
  [21:18:56.168]                         for (restart in restarts) {
  [21:18:56.168]                           name <- restart$name
  [21:18:56.168]                           if (is.null(name)) 
  [21:18:56.168]                             next
  [21:18:56.168]                           if (!grepl("^muffle", name)) 
  [21:18:56.168]                             next
  [21:18:56.168]                           invokeRestart(restart)
  [21:18:56.168]                           muffled <- TRUE
  [21:18:56.168]                           break
  [21:18:56.168]                         }
  [21:18:56.168]                       }
  [21:18:56.168]                       invisible(muffled)
  [21:18:56.168]                     }
  [21:18:56.168]                     muffleCondition(cond)
  [21:18:56.168]                   }
  [21:18:56.168]                 }
  [21:18:56.168]             }
  [21:18:56.168]         }))
  [21:18:56.168]     }, error = function(ex) {
  [21:18:56.168]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.168]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.168]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.168]     }, finally = {
  [21:18:56.168]         {
  [21:18:56.168]             NULL
  [21:18:56.168]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.168]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.168]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.168]                 label = NULL, ...) 
  [21:18:56.168]             {
  [21:18:56.168]                 if (substitute) 
  [21:18:56.168]                   expr <- substitute(expr)
  [21:18:56.168]                 local <- as.logical(local)
  [21:18:56.168]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.168]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.168]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.168]                   label = label, ...)
  [21:18:56.168]                 if (!future$lazy) 
  [21:18:56.168]                   future <- run(future)
  [21:18:56.168]                 invisible(future)
  [21:18:56.168]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.168]         }
  [21:18:56.168]         base::options(...future.oldOptions)
  [21:18:56.168]     })
  [21:18:56.168]     Sys.time
  [21:18:56.168]     if (base::is.na(TRUE)) {
  [21:18:56.168]     }
  [21:18:56.168]     else {
  [21:18:56.168]         base::sink(type = "output", split = FALSE)
  [21:18:56.168]         if (TRUE) {
  [21:18:56.168]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.168]         }
  [21:18:56.168]         else {
  [21:18:56.168]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.168]         }
  [21:18:56.168]         base::close(...future.stdout)
  [21:18:56.168]         ...future.stdout <- NULL
  [21:18:56.168]     }
  [21:18:56.168]     ...future.result$conditions <- ...future.conditions
  [21:18:56.168]     ...future.result
  [21:18:56.168] }
  [21:18:56.183] plan(): Setting new future strategy stack:
  [21:18:56.183] List of future strategies:
  [21:18:56.183] 1. sequential:
  [21:18:56.183]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.183]    - tweaked: FALSE
  [21:18:56.183]    - call: NULL
  [21:18:56.184] plan(): nbrOfWorkers() = 1
  [21:18:56.287] plan(): Setting new future strategy stack:
  [21:18:56.287] List of future strategies:
  [21:18:56.287] 1. sequential:
  [21:18:56.287]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.287]    - tweaked: FALSE
  [21:18:56.287]    - call: plan(strategy)
  [21:18:56.288] plan(): nbrOfWorkers() = 1
  [21:18:56.289] SequentialFuture started (and completed)
  [21:18:56.289] signalConditions() ...
  [21:18:56.290]  - include = 'immediateCondition'
  [21:18:56.290]  - exclude = 
  [21:18:56.290]  - resignal = FALSE
  [21:18:56.290]  - Number of conditions: 32
  [21:18:56.291] signalConditions() ... done
  [21:18:56.291] signalConditions() ...
  [21:18:56.292]  - include = 'immediateCondition'
  [21:18:56.292]  - exclude = 
  [21:18:56.292]  - resignal = FALSE
  [21:18:56.292]  - Number of conditions: 32
  [21:18:56.293] signalConditions() ... done
  [21:18:56.293] Future state: 'finished'
  [21:18:56.293] signalConditions() ...
  [21:18:56.293]  - include = 'condition'
  [21:18:56.294]  - exclude = 'immediateCondition'
  [21:18:56.294]  - resignal = TRUE
  [21:18:56.294]  - Number of conditions: 32
  [21:18:56.294]  - Condition #1: 'simpleMessage', 'message', 'condition'
  [21:18:56.185] getGlobalsAndPackages() ...
  [21:18:56.295]  - Condition #2: 'simpleMessage', 'message', 'condition'
  [21:18:56.186] Searching for globals...
  [21:18:56.295]  - Condition #3: 'simpleMessage', 'message', 'condition'
  [21:18:56.187] 
  [21:18:56.295]  - Condition #4: 'simpleMessage', 'message', 'condition'
  [21:18:56.187] Searching for globals ... DONE
  [21:18:56.296]  - Condition #5: 'simpleMessage', 'message', 'condition'
  [21:18:56.188] - globals: [0] <none>
  [21:18:56.296]  - Condition #6: 'simpleMessage', 'message', 'condition'
  [21:18:56.188] getGlobalsAndPackages() ... DONE
  [21:18:56.296]  - Condition #7: 'simpleMessage', 'message', 'condition'
  [21:18:56.198] Packages needed by the future expression (n = 0): <none>
  [21:18:56.297]  - Condition #8: 'simpleMessage', 'message', 'condition'
  [21:18:56.199] Packages needed by future strategies (n = 0): <none>
  [21:18:56.297]  - Condition #9: 'simpleMessage', 'message', 'condition'
  [21:18:56.203] {
  [21:18:56.203]     {
  [21:18:56.203]         ...future.startTime <- base::Sys.time()
  [21:18:56.203]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.203]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.203]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.203]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.203]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.203]         {
  [21:18:56.203]             {
  [21:18:56.203]                 base::local({
  [21:18:56.203]                   has_future <- base::requireNamespace("future", 
  [21:18:56.203]                     quietly = TRUE)
  [21:18:56.203]                   version <- if (has_future) 
  [21:18:56.203]                     utils::packageVersion("future")
  [21:18:56.203]                   else NULL
  [21:18:56.203]                   if (!has_future || version < "1.8.0") {
  [21:18:56.203]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.203]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.203]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.203]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.203]                         "release", "version")], collapse = " "), 
  [21:18:56.203]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.203]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.203]                       info)
  [21:18:56.203]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.203]                     if (!has_future) {
  [21:18:56.203]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.203]                         info)
  [21:18:56.203]                     }
  [21:18:56.203]                     else {
  [21:18:56.203]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.203]                         info, version)
  [21:18:56.203]                     }
  [21:18:56.203]                     base::stop(msg)
  [21:18:56.203]                   }
  [21:18:56.203]                 })
  [21:18:56.203]             }
  [21:18:56.203]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.203]         }
  [21:18:56.203]     }
  [21:18:56.203]     if (base::is.na(TRUE)) {
  [21:18:56.203]     }
  [21:18:56.203]     else {
  [21:18:56.203]         if (TRUE) {
  [21:18:56.203]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.203]                 open = "w")
  [21:18:56.203]         }
  [21:18:56.203]         else {
  [21:18:56.203]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.203]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.203]         }
  [21:18:56.203]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.203]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.203]             base::sink(type = "output", split = FALSE)
  [21:18:56.203]             base::close(...future.stdout)
  [21:18:56.203]         }, add = TRUE)
  [21:18:56.203]     }
  [21:18:56.203]     ...future.frame <- base::sys.nframe()
  [21:18:56.203]     ...future.conditions <- base::list()
  [21:18:56.203]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.203]     ...future.result <- base::tryCatch({
  [21:18:56.203]         base::withCallingHandlers({
  [21:18:56.203]             ...future.value <- base::withVisible(base::local(2))
  [21:18:56.203]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.203]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.203]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.203]                 version = "1.8")
  [21:18:56.203]         }, condition = base::local({
  [21:18:56.203]             c <- base::c
  [21:18:56.203]             inherits <- base::inherits
  [21:18:56.203]             invokeRestart <- base::invokeRestart
  [21:18:56.203]             length <- base::length
  [21:18:56.203]             list <- base::list
  [21:18:56.203]             seq.int <- base::seq.int
  [21:18:56.203]             signalCondition <- base::signalCondition
  [21:18:56.203]             sys.calls <- base::sys.calls
  [21:18:56.203]             Sys.time <- base::Sys.time
  [21:18:56.203]             `[[` <- base::`[[`
  [21:18:56.203]             `+` <- base::`+`
  [21:18:56.203]             `<<-` <- base::`<<-`
  [21:18:56.203]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.203]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.203]                   3L)]
  [21:18:56.203]             }
  [21:18:56.203]             function(cond) {
  [21:18:56.203]                 if (inherits(cond, "error")) {
  [21:18:56.203]                   sessionInformation <- function() {
  [21:18:56.203]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.203]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.203]                       search = base::search(), system = base::Sys.info())
  [21:18:56.203]                   }
  [21:18:56.203]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.203]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.203]                     cond$call), session = sessionInformation(), 
  [21:18:56.203]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.203]                   signalCondition(cond)
  [21:18:56.203]                 }
  [21:18:56.203]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.203]                 ))) {
  [21:18:56.203]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.203]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.203]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.203]                   if (!signal) {
  [21:18:56.203]                     muffleCondition <- function (cond) 
  [21:18:56.203]                     {
  [21:18:56.203]                       inherits <- base::inherits
  [21:18:56.203]                       invokeRestart <- base::invokeRestart
  [21:18:56.203]                       muffled <- FALSE
  [21:18:56.203]                       if (inherits(cond, "message")) {
  [21:18:56.203]                         invokeRestart("muffleMessage")
  [21:18:56.203]                         muffled <- TRUE
  [21:18:56.203]                       }
  [21:18:56.203]                       else if (inherits(cond, "warning")) {
  [21:18:56.203]                         invokeRestart("muffleWarning")
  [21:18:56.203]                         muffled <- TRUE
  [21:18:56.203]                       }
  [21:18:56.203]                       else if (inherits(cond, "condition")) {
  [21:18:56.203]                         computeRestarts <- base::computeRestarts
  [21:18:56.203]                         grepl <- base::grepl
  [21:18:56.203]                         is.null <- base::is.null
  [21:18:56.203]                         restarts <- computeRestarts(cond)
  [21:18:56.203]                         for (restart in restarts) {
  [21:18:56.203]                           name <- restart$name
  [21:18:56.203]                           if (is.null(name)) 
  [21:18:56.203]                             next
  [21:18:56.203]                           if (!grepl("^muffle", name)) 
  [21:18:56.203]                             next
  [21:18:56.203]                           invokeRestart(restart)
  [21:18:56.203]                           muffled <- TRUE
  [21:18:56.203]                           break
  [21:18:56.203]                         }
  [21:18:56.203]                       }
  [21:18:56.203]                       invisible(muffled)
  [21:18:56.203]                     }
  [21:18:56.203]                     muffleCondition(cond)
  [21:18:56.203]                   }
  [21:18:56.203]                 }
  [21:18:56.203]             }
  [21:18:56.203]         }))
  [21:18:56.203]     }, error = function(ex) {
  [21:18:56.203]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.203]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.203]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.203]     }, finally = {
  [21:18:56.203]         {
  [21:18:56.203]             NULL
  [21:18:56.203]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.203]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.203]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.203]                 label = NULL, ...) 
  [21:18:56.203]             {
  [21:18:56.203]                 if (substitute) 
  [21:18:56.203]                   expr <- substitute(expr)
  [21:18:56.203]                 local <- as.logical(local)
  [21:18:56.203]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.203]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.203]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.203]                   label = label, ...)
  [21:18:56.203]                 if (!future$lazy) 
  [21:18:56.203]                   future <- run(future)
  [21:18:56.203]                 invisible(future)
  [21:18:56.203]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.203]         }
  [21:18:56.203]         base::options(...future.oldOptions)
  [21:18:56.203]     })
  [21:18:56.203]     Sys.time
  [21:18:56.203]     if (base::is.na(TRUE)) {
  [21:18:56.203]     }
  [21:18:56.203]     else {
  [21:18:56.203]         base::sink(type = "output", split = FALSE)
  [21:18:56.203]         if (TRUE) {
  [21:18:56.203]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.203]         }
  [21:18:56.203]         else {
  [21:18:56.203]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.203]         }
  [21:18:56.203]         base::close(...future.stdout)
  [21:18:56.203]         ...future.stdout <- NULL
  [21:18:56.203]     }
  [21:18:56.203]     ...future.result$conditions <- ...future.conditions
  [21:18:56.203]     ...future.result
  [21:18:56.203] }
  [21:18:56.298]  - Condition #10: 'simpleMessage', 'message', 'condition'
  [21:18:56.224] plan(): Setting new future strategy stack:
  [21:18:56.298]  - Condition #11: 'simpleMessage', 'message', 'condition'
  [21:18:56.224] List of future strategies:
  [21:18:56.224] 1. sequential:
  [21:18:56.224]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.224]    - tweaked: FALSE
  [21:18:56.224]    - call: NULL
  [21:18:56.298]  - Condition #12: 'simpleMessage', 'message', 'condition'
  [21:18:56.225] plan(): nbrOfWorkers() = 1
  [21:18:56.299]  - Condition #13: 'simpleMessage', 'message', 'condition'
  [21:18:56.227] plan(): Setting new future strategy stack:
  [21:18:56.299]  - Condition #14: 'simpleMessage', 'message', 'condition'
  [21:18:56.227] List of future strategies:
  [21:18:56.227] 1. sequential:
  [21:18:56.227]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.227]    - tweaked: FALSE
  [21:18:56.227]    - call: NULL
  [21:18:56.299]  - Condition #15: 'simpleMessage', 'message', 'condition'
  [21:18:56.228] plan(): nbrOfWorkers() = 1
  [21:18:56.300]  - Condition #16: 'simpleMessage', 'message', 'condition'
  [21:18:56.232] SequentialFuture started (and completed)
  [21:18:56.300]  - Condition #17: 'simpleMessage', 'message', 'condition'
  [21:18:56.234] getGlobalsAndPackages() ...
  [21:18:56.301]  - Condition #18: 'simpleMessage', 'message', 'condition'
  [21:18:56.234] Searching for globals...
  [21:18:56.301]  - Condition #19: 'simpleMessage', 'message', 'condition'
  [21:18:56.235] 
  [21:18:56.301]  - Condition #20: 'simpleMessage', 'message', 'condition'
  [21:18:56.235] Searching for globals ... DONE
  [21:18:56.318]  - Condition #21: 'simpleMessage', 'message', 'condition'
  [21:18:56.236] - globals: [0] <none>
  [21:18:56.318]  - Condition #22: 'simpleMessage', 'message', 'condition'
  [21:18:56.236] getGlobalsAndPackages() ... DONE
  [21:18:56.319]  - Condition #23: 'simpleMessage', 'message', 'condition'
  [21:18:56.254] Packages needed by the future expression (n = 0): <none>
  [21:18:56.319]  - Condition #24: 'simpleMessage', 'message', 'condition'
  [21:18:56.255] Packages needed by future strategies (n = 0): <none>
  [21:18:56.319]  - Condition #25: 'simpleMessage', 'message', 'condition'
  [21:18:56.260] {
  [21:18:56.260]     {
  [21:18:56.260]         ...future.startTime <- base::Sys.time()
  [21:18:56.260]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.260]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.260]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.260]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.260]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.260]         {
  [21:18:56.260]             {
  [21:18:56.260]                 base::local({
  [21:18:56.260]                   has_future <- base::requireNamespace("future", 
  [21:18:56.260]                     quietly = TRUE)
  [21:18:56.260]                   version <- if (has_future) 
  [21:18:56.260]                     utils::packageVersion("future")
  [21:18:56.260]                   else NULL
  [21:18:56.260]                   if (!has_future || version < "1.8.0") {
  [21:18:56.260]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.260]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.260]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.260]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.260]                         "release", "version")], collapse = " "), 
  [21:18:56.260]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.260]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.260]                       info)
  [21:18:56.260]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.260]                     if (!has_future) {
  [21:18:56.260]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.260]                         info)
  [21:18:56.260]                     }
  [21:18:56.260]                     else {
  [21:18:56.260]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.260]                         info, version)
  [21:18:56.260]                     }
  [21:18:56.260]                     base::stop(msg)
  [21:18:56.260]                   }
  [21:18:56.260]                 })
  [21:18:56.260]             }
  [21:18:56.260]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.260]         }
  [21:18:56.260]     }
  [21:18:56.260]     if (base::is.na(TRUE)) {
  [21:18:56.260]     }
  [21:18:56.260]     else {
  [21:18:56.260]         if (TRUE) {
  [21:18:56.260]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.260]                 open = "w")
  [21:18:56.260]         }
  [21:18:56.260]         else {
  [21:18:56.260]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.260]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.260]         }
  [21:18:56.260]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.260]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.260]             base::sink(type = "output", split = FALSE)
  [21:18:56.260]             base::close(...future.stdout)
  [21:18:56.260]         }, add = TRUE)
  [21:18:56.260]     }
  [21:18:56.260]     ...future.frame <- base::sys.nframe()
  [21:18:56.260]     ...future.conditions <- base::list()
  [21:18:56.260]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.260]     ...future.result <- base::tryCatch({
  [21:18:56.260]         base::withCallingHandlers({
  [21:18:56.260]             ...future.value <- base::withVisible(base::local(4))
  [21:18:56.260]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.260]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.260]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.260]                 version = "1.8")
  [21:18:56.260]         }, condition = base::local({
  [21:18:56.260]             c <- base::c
  [21:18:56.260]             inherits <- base::inherits
  [21:18:56.260]             invokeRestart <- base::invokeRestart
  [21:18:56.260]             length <- base::length
  [21:18:56.260]             list <- base::list
  [21:18:56.260]             seq.int <- base::seq.int
  [21:18:56.260]             signalCondition <- base::signalCondition
  [21:18:56.260]             sys.calls <- base::sys.calls
  [21:18:56.260]             Sys.time <- base::Sys.time
  [21:18:56.260]             `[[` <- base::`[[`
  [21:18:56.260]             `+` <- base::`+`
  [21:18:56.260]             `<<-` <- base::`<<-`
  [21:18:56.260]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.260]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.260]                   3L)]
  [21:18:56.260]             }
  [21:18:56.260]             function(cond) {
  [21:18:56.260]                 if (inherits(cond, "error")) {
  [21:18:56.260]                   sessionInformation <- function() {
  [21:18:56.260]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.260]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.260]                       search = base::search(), system = base::Sys.info())
  [21:18:56.260]                   }
  [21:18:56.260]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.260]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.260]                     cond$call), session = sessionInformation(), 
  [21:18:56.260]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.260]                   signalCondition(cond)
  [21:18:56.260]                 }
  [21:18:56.260]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.260]                 ))) {
  [21:18:56.260]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.260]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.260]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.260]                   if (!signal) {
  [21:18:56.260]                     muffleCondition <- function (cond) 
  [21:18:56.260]                     {
  [21:18:56.260]                       inherits <- base::inherits
  [21:18:56.260]                       invokeRestart <- base::invokeRestart
  [21:18:56.260]                       muffled <- FALSE
  [21:18:56.260]                       if (inherits(cond, "message")) {
  [21:18:56.260]                         invokeRestart("muffleMessage")
  [21:18:56.260]                         muffled <- TRUE
  [21:18:56.260]                       }
  [21:18:56.260]                       else if (inherits(cond, "warning")) {
  [21:18:56.260]                         invokeRestart("muffleWarning")
  [21:18:56.260]                         muffled <- TRUE
  [21:18:56.260]                       }
  [21:18:56.260]                       else if (inherits(cond, "condition")) {
  [21:18:56.260]                         computeRestarts <- base::computeRestarts
  [21:18:56.260]                         grepl <- base::grepl
  [21:18:56.260]                         is.null <- base::is.null
  [21:18:56.260]                         restarts <- computeRestarts(cond)
  [21:18:56.260]                         for (restart in restarts) {
  [21:18:56.260]                           name <- restart$name
  [21:18:56.260]                           if (is.null(name)) 
  [21:18:56.260]                             next
  [21:18:56.260]                           if (!grepl("^muffle", name)) 
  [21:18:56.260]                             next
  [21:18:56.260]                           invokeRestart(restart)
  [21:18:56.260]                           muffled <- TRUE
  [21:18:56.260]                           break
  [21:18:56.260]                         }
  [21:18:56.260]                       }
  [21:18:56.260]                       invisible(muffled)
  [21:18:56.260]                     }
  [21:18:56.260]                     muffleCondition(cond)
  [21:18:56.260]                   }
  [21:18:56.260]                 }
  [21:18:56.260]             }
  [21:18:56.260]         }))
  [21:18:56.260]     }, error = function(ex) {
  [21:18:56.260]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.260]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.260]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.260]     }, finally = {
  [21:18:56.260]         {
  [21:18:56.260]             NULL
  [21:18:56.260]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.260]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.260]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.260]                 label = NULL, ...) 
  [21:18:56.260]             {
  [21:18:56.260]                 if (substitute) 
  [21:18:56.260]                   expr <- substitute(expr)
  [21:18:56.260]                 local <- as.logical(local)
  [21:18:56.260]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.260]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.260]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.260]                   label = label, ...)
  [21:18:56.260]                 if (!future$lazy) 
  [21:18:56.260]                   future <- run(future)
  [21:18:56.260]                 invisible(future)
  [21:18:56.260]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.260]         }
  [21:18:56.260]         base::options(...future.oldOptions)
  [21:18:56.260]     })
  [21:18:56.260]     Sys.time
  [21:18:56.260]     if (base::is.na(TRUE)) {
  [21:18:56.260]     }
  [21:18:56.260]     else {
  [21:18:56.260]         base::sink(type = "output", split = FALSE)
  [21:18:56.260]         if (TRUE) {
  [21:18:56.260]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.260]         }
  [21:18:56.260]         else {
  [21:18:56.260]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.260]         }
  [21:18:56.260]         base::close(...future.stdout)
  [21:18:56.260]         ...future.stdout <- NULL
  [21:18:56.260]     }
  [21:18:56.260]     ...future.result$conditions <- ...future.conditions
  [21:18:56.260]     ...future.result
  [21:18:56.260] }
  [21:18:56.320]  - Condition #26: 'simpleMessage', 'message', 'condition'
  [21:18:56.264] plan(): Setting new future strategy stack:
  [21:18:56.320]  - Condition #27: 'simpleMessage', 'message', 'condition'
  [21:18:56.265] List of future strategies:
  [21:18:56.265] 1. sequential:
  [21:18:56.265]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.265]    - tweaked: FALSE
  [21:18:56.265]    - call: NULL
  [21:18:56.320]  - Condition #28: 'simpleMessage', 'message', 'condition'
  [21:18:56.266] plan(): nbrOfWorkers() = 1
  [21:18:56.321]  - Condition #29: 'simpleMessage', 'message', 'condition'
  [21:18:56.267] plan(): Setting new future strategy stack:
  [21:18:56.321]  - Condition #30: 'simpleMessage', 'message', 'condition'
  [21:18:56.268] List of future strategies:
  [21:18:56.268] 1. sequential:
  [21:18:56.268]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.268]    - tweaked: FALSE
  [21:18:56.268]    - call: NULL
  [21:18:56.322]  - Condition #31: 'simpleMessage', 'message', 'condition'
  [21:18:56.269] plan(): nbrOfWorkers() = 1
  [21:18:56.322]  - Condition #32: 'simpleMessage', 'message', 'condition'
  [21:18:56.269] SequentialFuture started (and completed)
  [21:18:56.322] signalConditions() ... done
  a = 10
  [21:18:56.323] getGlobalsAndPackages() ...
  [21:18:56.324] Searching for globals...
  [21:18:56.325] - globals found: [3] '{', '+', 'a'
  [21:18:56.326] Searching for globals ... DONE
  [21:18:56.326] Resolving globals: FALSE
  [21:18:56.327] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:56.327] - globals: [1] 'a'
  [21:18:56.328] 
  [21:18:56.328] getGlobalsAndPackages() ... DONE
  [21:18:56.329] Packages needed by the future expression (n = 0): <none>
  [21:18:56.330] Packages needed by future strategies (n = 0): <none>
  [21:18:56.334] {
  [21:18:56.334]     {
  [21:18:56.334]         ...future.startTime <- base::Sys.time()
  [21:18:56.334]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.334]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.334]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.334]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.334]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.334]         {
  [21:18:56.334]             {
  [21:18:56.334]                 base::local({
  [21:18:56.334]                   has_future <- base::requireNamespace("future", 
  [21:18:56.334]                     quietly = TRUE)
  [21:18:56.334]                   version <- if (has_future) 
  [21:18:56.334]                     utils::packageVersion("future")
  [21:18:56.334]                   else NULL
  [21:18:56.334]                   if (!has_future || version < "1.8.0") {
  [21:18:56.334]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.334]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.334]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.334]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.334]                         "release", "version")], collapse = " "), 
  [21:18:56.334]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:56.334]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.334]                       info)
  [21:18:56.334]                     info <- base::paste(info, collapse = "; ")
  [21:18:56.334]                     if (!has_future) {
  [21:18:56.334]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.334]                         info)
  [21:18:56.334]                     }
  [21:18:56.334]                     else {
  [21:18:56.334]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.334]                         info, version)
  [21:18:56.334]                     }
  [21:18:56.334]                     base::stop(msg)
  [21:18:56.334]                   }
  [21:18:56.334]                 })
  [21:18:56.334]             }
  [21:18:56.334]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.334]         }
  [21:18:56.334]     }
  [21:18:56.334]     if (base::is.na(TRUE)) {
  [21:18:56.334]     }
  [21:18:56.334]     else {
  [21:18:56.334]         if (TRUE) {
  [21:18:56.334]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.334]                 open = "w")
  [21:18:56.334]         }
  [21:18:56.334]         else {
  [21:18:56.334]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.334]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.334]         }
  [21:18:56.334]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.334]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.334]             base::sink(type = "output", split = FALSE)
  [21:18:56.334]             base::close(...future.stdout)
  [21:18:56.334]         }, add = TRUE)
  [21:18:56.334]     }
  [21:18:56.334]     ...future.frame <- base::sys.nframe()
  [21:18:56.334]     ...future.conditions <- base::list()
  [21:18:56.334]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.334]     ...future.result <- base::tryCatch({
  [21:18:56.334]         base::withCallingHandlers({
  [21:18:56.334]             ...future.value <- base::withVisible(base::local({
  [21:18:56.334]                 a + 1
  [21:18:56.334]             }))
  [21:18:56.334]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.334]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.334]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.334]                 version = "1.8")
  [21:18:56.334]         }, condition = base::local({
  [21:18:56.334]             c <- base::c
  [21:18:56.334]             inherits <- base::inherits
  [21:18:56.334]             invokeRestart <- base::invokeRestart
  [21:18:56.334]             length <- base::length
  [21:18:56.334]             list <- base::list
  [21:18:56.334]             seq.int <- base::seq.int
  [21:18:56.334]             signalCondition <- base::signalCondition
  [21:18:56.334]             sys.calls <- base::sys.calls
  [21:18:56.334]             Sys.time <- base::Sys.time
  [21:18:56.334]             `[[` <- base::`[[`
  [21:18:56.334]             `+` <- base::`+`
  [21:18:56.334]             `<<-` <- base::`<<-`
  [21:18:56.334]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.334]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.334]                   3L)]
  [21:18:56.334]             }
  [21:18:56.334]             function(cond) {
  [21:18:56.334]                 if (inherits(cond, "error")) {
  [21:18:56.334]                   sessionInformation <- function() {
  [21:18:56.334]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.334]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.334]                       search = base::search(), system = base::Sys.info())
  [21:18:56.334]                   }
  [21:18:56.334]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.334]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.334]                     cond$call), session = sessionInformation(), 
  [21:18:56.334]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.334]                   signalCondition(cond)
  [21:18:56.334]                 }
  [21:18:56.334]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:56.334]                 ))) {
  [21:18:56.334]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:56.334]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.334]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.334]                   if (!signal) {
  [21:18:56.334]                     muffleCondition <- function (cond) 
  [21:18:56.334]                     {
  [21:18:56.334]                       inherits <- base::inherits
  [21:18:56.334]                       invokeRestart <- base::invokeRestart
  [21:18:56.334]                       muffled <- FALSE
  [21:18:56.334]                       if (inherits(cond, "message")) {
  [21:18:56.334]                         invokeRestart("muffleMessage")
  [21:18:56.334]                         muffled <- TRUE
  [21:18:56.334]                       }
  [21:18:56.334]                       else if (inherits(cond, "warning")) {
  [21:18:56.334]                         invokeRestart("muffleWarning")
  [21:18:56.334]                         muffled <- TRUE
  [21:18:56.334]                       }
  [21:18:56.334]                       else if (inherits(cond, "condition")) {
  [21:18:56.334]                         computeRestarts <- base::computeRestarts
  [21:18:56.334]                         grepl <- base::grepl
  [21:18:56.334]                         is.null <- base::is.null
  [21:18:56.334]                         restarts <- computeRestarts(cond)
  [21:18:56.334]                         for (restart in restarts) {
  [21:18:56.334]                           name <- restart$name
  [21:18:56.334]                           if (is.null(name)) 
  [21:18:56.334]                             next
  [21:18:56.334]                           if (!grepl("^muffle", name)) 
  [21:18:56.334]                             next
  [21:18:56.334]                           invokeRestart(restart)
  [21:18:56.334]                           muffled <- TRUE
  [21:18:56.334]                           break
  [21:18:56.334]                         }
  [21:18:56.334]                       }
  [21:18:56.334]                       invisible(muffled)
  [21:18:56.334]                     }
  [21:18:56.334]                     muffleCondition(cond)
  [21:18:56.334]                   }
  [21:18:56.334]                 }
  [21:18:56.334]             }
  [21:18:56.334]         }))
  [21:18:56.334]     }, error = function(ex) {
  [21:18:56.334]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.334]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.334]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.334]     }, finally = {
  [21:18:56.334]         {
  [21:18:56.334]             NULL
  [21:18:56.334]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.334]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.334]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:56.334]                 label = NULL, ...) 
  [21:18:56.334]             {
  [21:18:56.334]                 if (substitute) 
  [21:18:56.334]                   expr <- substitute(expr)
  [21:18:56.334]                 local <- as.logical(local)
  [21:18:56.334]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:56.334]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.334]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:56.334]                   label = label, ...)
  [21:18:56.334]                 if (!future$lazy) 
  [21:18:56.334]                   future <- run(future)
  [21:18:56.334]                 invisible(future)
  [21:18:56.334]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.334]         }
  [21:18:56.334]         base::options(...future.oldOptions)
  [21:18:56.334]     })
  [21:18:56.334]     Sys.time
  [21:18:56.334]     if (base::is.na(TRUE)) {
  [21:18:56.334]     }
  [21:18:56.334]     else {
  [21:18:56.334]         base::sink(type = "output", split = FALSE)
  [21:18:56.334]         if (TRUE) {
  [21:18:56.334]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.334]         }
  [21:18:56.334]         else {
  [21:18:56.334]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.334]         }
  [21:18:56.334]         base::close(...future.stdout)
  [21:18:56.334]         ...future.stdout <- NULL
  [21:18:56.334]     }
  [21:18:56.334]     ...future.result$conditions <- ...future.conditions
  [21:18:56.334]     ...future.result
  [21:18:56.334] }
  [21:18:56.338] plan(): Setting new future strategy stack:
  [21:18:56.338] List of future strategies:
  [21:18:56.338] 1. sequential:
  [21:18:56.338]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.338]    - tweaked: FALSE
  [21:18:56.338]    - call: NULL
  [21:18:56.339] plan(): nbrOfWorkers() = 1
  [21:18:56.340] plan(): Setting new future strategy stack:
  [21:18:56.341] List of future strategies:
  [21:18:56.341] 1. sequential:
  [21:18:56.341]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.341]    - tweaked: FALSE
  [21:18:56.341]    - call: plan(strategy)
  [21:18:56.341] plan(): nbrOfWorkers() = 1
  [21:18:56.342] SequentialFuture started (and completed)
  b = 11
  *** %<-% with 'sequential' futures ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** %<-% with 'multicore' futures ...
  [21:18:56.356] plan(): Setting new future strategy stack:
  [21:18:56.356] List of future strategies:
  [21:18:56.356] 1. multicore:
  [21:18:56.356]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.356]    - tweaked: FALSE
  [21:18:56.356]    - call: plan(strategy)
  [21:18:56.358] plan(): nbrOfWorkers() = 2
  ** Future evaluation without globals
  [21:18:56.359] getGlobalsAndPackages() ...
  [21:18:56.360] Searching for globals...
  [21:18:56.361] - globals found: [2] '{', '<-'
  [21:18:56.361] Searching for globals ... DONE
  [21:18:56.362] Resolving globals: FALSE
  [21:18:56.362] 
  [21:18:56.363] 
  [21:18:56.363] getGlobalsAndPackages() ... DONE
  [21:18:56.365] Packages needed by the future expression (n = 0): <none>
  [21:18:56.366] Packages needed by future strategies (n = 0): <none>
  [21:18:56.370] {
  [21:18:56.370]     {
  [21:18:56.370]         ...future.startTime <- base::Sys.time()
  [21:18:56.370]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.370]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.370]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.370]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.370]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.370]         {
  [21:18:56.370]             {
  [21:18:56.370]                 {
  [21:18:56.370]                   base::local({
  [21:18:56.370]                     has_future <- base::requireNamespace("future", 
  [21:18:56.370]                       quietly = TRUE)
  [21:18:56.370]                     version <- if (has_future) 
  [21:18:56.370]                       utils::packageVersion("future")
  [21:18:56.370]                     else NULL
  [21:18:56.370]                     if (!has_future || version < "1.8.0") {
  [21:18:56.370]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.370]                         "", base::R.version$version.string), 
  [21:18:56.370]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.370]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.370]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.370]                           "release", "version")], collapse = " "), 
  [21:18:56.370]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.370]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.370]                         info)
  [21:18:56.370]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.370]                       if (!has_future) {
  [21:18:56.370]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.370]                           info)
  [21:18:56.370]                       }
  [21:18:56.370]                       else {
  [21:18:56.370]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.370]                           info, version)
  [21:18:56.370]                       }
  [21:18:56.370]                       base::stop(msg)
  [21:18:56.370]                     }
  [21:18:56.370]                   })
  [21:18:56.370]                 }
  [21:18:56.370]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.370]                 base::options(mc.cores = 1L)
  [21:18:56.370]             }
  [21:18:56.370]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.370]         }
  [21:18:56.370]     }
  [21:18:56.370]     if (base::is.na(TRUE)) {
  [21:18:56.370]     }
  [21:18:56.370]     else {
  [21:18:56.370]         if (TRUE) {
  [21:18:56.370]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.370]                 open = "w")
  [21:18:56.370]         }
  [21:18:56.370]         else {
  [21:18:56.370]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.370]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.370]         }
  [21:18:56.370]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.370]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.370]             base::sink(type = "output", split = FALSE)
  [21:18:56.370]             base::close(...future.stdout)
  [21:18:56.370]         }, add = TRUE)
  [21:18:56.370]     }
  [21:18:56.370]     ...future.frame <- base::sys.nframe()
  [21:18:56.370]     ...future.conditions <- base::list()
  [21:18:56.370]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.370]     ...future.result <- base::tryCatch({
  [21:18:56.370]         base::withCallingHandlers({
  [21:18:56.370]             ...future.value <- base::withVisible(base::local({
  [21:18:56.370]                 x <- 1
  [21:18:56.370]             }))
  [21:18:56.370]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.370]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.370]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.370]                 version = "1.8")
  [21:18:56.370]         }, condition = base::local({
  [21:18:56.370]             c <- base::c
  [21:18:56.370]             inherits <- base::inherits
  [21:18:56.370]             invokeRestart <- base::invokeRestart
  [21:18:56.370]             length <- base::length
  [21:18:56.370]             list <- base::list
  [21:18:56.370]             seq.int <- base::seq.int
  [21:18:56.370]             signalCondition <- base::signalCondition
  [21:18:56.370]             sys.calls <- base::sys.calls
  [21:18:56.370]             Sys.time <- base::Sys.time
  [21:18:56.370]             `[[` <- base::`[[`
  [21:18:56.370]             `+` <- base::`+`
  [21:18:56.370]             `<<-` <- base::`<<-`
  [21:18:56.370]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.370]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.370]                   3L)]
  [21:18:56.370]             }
  [21:18:56.370]             function(cond) {
  [21:18:56.370]                 if (inherits(cond, "error")) {
  [21:18:56.370]                   sessionInformation <- function() {
  [21:18:56.370]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.370]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.370]                       search = base::search(), system = base::Sys.info())
  [21:18:56.370]                   }
  [21:18:56.370]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.370]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.370]                     cond$call), session = sessionInformation(), 
  [21:18:56.370]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.370]                   signalCondition(cond)
  [21:18:56.370]                 }
  [21:18:56.370]                 else if (inherits(cond, "condition")) {
  [21:18:56.370]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.370]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.370]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.370]                   if (!signal) {
  [21:18:56.370]                     muffleCondition <- function (cond) 
  [21:18:56.370]                     {
  [21:18:56.370]                       inherits <- base::inherits
  [21:18:56.370]                       invokeRestart <- base::invokeRestart
  [21:18:56.370]                       muffled <- FALSE
  [21:18:56.370]                       if (inherits(cond, "message")) {
  [21:18:56.370]                         invokeRestart("muffleMessage")
  [21:18:56.370]                         muffled <- TRUE
  [21:18:56.370]                       }
  [21:18:56.370]                       else if (inherits(cond, "warning")) {
  [21:18:56.370]                         invokeRestart("muffleWarning")
  [21:18:56.370]                         muffled <- TRUE
  [21:18:56.370]                       }
  [21:18:56.370]                       else if (inherits(cond, "condition")) {
  [21:18:56.370]                         computeRestarts <- base::computeRestarts
  [21:18:56.370]                         grepl <- base::grepl
  [21:18:56.370]                         is.null <- base::is.null
  [21:18:56.370]                         restarts <- computeRestarts(cond)
  [21:18:56.370]                         for (restart in restarts) {
  [21:18:56.370]                           name <- restart$name
  [21:18:56.370]                           if (is.null(name)) 
  [21:18:56.370]                             next
  [21:18:56.370]                           if (!grepl("^muffle", name)) 
  [21:18:56.370]                             next
  [21:18:56.370]                           invokeRestart(restart)
  [21:18:56.370]                           muffled <- TRUE
  [21:18:56.370]                           break
  [21:18:56.370]                         }
  [21:18:56.370]                       }
  [21:18:56.370]                       invisible(muffled)
  [21:18:56.370]                     }
  [21:18:56.370]                     muffleCondition(cond)
  [21:18:56.370]                   }
  [21:18:56.370]                 }
  [21:18:56.370]             }
  [21:18:56.370]         }))
  [21:18:56.370]     }, error = function(ex) {
  [21:18:56.370]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.370]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.370]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.370]     }, finally = {
  [21:18:56.370]         {
  [21:18:56.370]             {
  [21:18:56.370]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.370]             }
  [21:18:56.370]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.370]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.370]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.370]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.370]             {
  [21:18:56.370]                 if (substitute) 
  [21:18:56.370]                   expr <- substitute(expr)
  [21:18:56.370]                 if (is.function(workers)) 
  [21:18:56.370]                   workers <- workers()
  [21:18:56.370]                 workers <- as.integer(workers)
  [21:18:56.370]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.370]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.370]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.370]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.370]                     local = TRUE, label = label, ...))
  [21:18:56.370]                 }
  [21:18:56.370]                 oopts <- options(mc.cores = workers)
  [21:18:56.370]                 on.exit(options(oopts))
  [21:18:56.370]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.370]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.370]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.370]                   label = label, ...)
  [21:18:56.370]                 if (!future$lazy) 
  [21:18:56.370]                   future <- run(future)
  [21:18:56.370]                 invisible(future)
  [21:18:56.370]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.370]         }
  [21:18:56.370]         base::options(...future.oldOptions)
  [21:18:56.370]     })
  [21:18:56.370]     Sys.time
  [21:18:56.370]     if (base::is.na(TRUE)) {
  [21:18:56.370]     }
  [21:18:56.370]     else {
  [21:18:56.370]         base::sink(type = "output", split = FALSE)
  [21:18:56.370]         if (TRUE) {
  [21:18:56.370]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.370]         }
  [21:18:56.370]         else {
  [21:18:56.370]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.370]         }
  [21:18:56.370]         base::close(...future.stdout)
  [21:18:56.370]         ...future.stdout <- NULL
  [21:18:56.370]     }
  [21:18:56.370]     ...future.result$conditions <- ...future.conditions
  [21:18:56.370]     ...future.result
  [21:18:56.370] }
  [21:18:56.374] requestCore(): workers = 2
  [21:18:56.378] MulticoreFuture started
  [21:18:56.393] plan(): Setting new future strategy stack:
  [21:18:56.394] List of future strategies:
  [21:18:56.394] 1. sequential:
  [21:18:56.394]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.394]    - tweaked: FALSE
  [21:18:56.394]    - call: NULL
  [21:18:56.395] plan(): nbrOfWorkers() = 1
  [21:18:56.397] plan(): Setting new future strategy stack:
  [21:18:56.398] List of future strategies:
  [21:18:56.398] 1. multicore:
  [21:18:56.398]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.398]    - tweaked: FALSE
  [21:18:56.398]    - call: plan(strategy)
  [21:18:56.400] plan(): nbrOfWorkers() = 2
  ** Future evaluation with globals
  [21:18:56.411] getGlobalsAndPackages() ...
  [21:18:56.411] Searching for globals...
  [21:18:56.413] - globals found: [3] '{', '<-', 'a'
  [21:18:56.430] Searching for globals ... DONE
  [21:18:56.430] Resolving globals: FALSE
  [21:18:56.431] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:56.432] - globals: [1] 'a'
  [21:18:56.432] 
  [21:18:56.432] getGlobalsAndPackages() ... DONE
  [21:18:56.434] Packages needed by the future expression (n = 0): <none>
  [21:18:56.435] Packages needed by future strategies (n = 0): <none>
  [21:18:56.440] {
  [21:18:56.440]     {
  [21:18:56.440]         ...future.startTime <- base::Sys.time()
  [21:18:56.440]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.440]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.440]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.440]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.440]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.440]         {
  [21:18:56.440]             {
  [21:18:56.440]                 {
  [21:18:56.440]                   base::local({
  [21:18:56.440]                     has_future <- base::requireNamespace("future", 
  [21:18:56.440]                       quietly = TRUE)
  [21:18:56.440]                     version <- if (has_future) 
  [21:18:56.440]                       utils::packageVersion("future")
  [21:18:56.440]                     else NULL
  [21:18:56.440]                     if (!has_future || version < "1.8.0") {
  [21:18:56.440]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.440]                         "", base::R.version$version.string), 
  [21:18:56.440]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.440]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.440]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.440]                           "release", "version")], collapse = " "), 
  [21:18:56.440]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.440]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.440]                         info)
  [21:18:56.440]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.440]                       if (!has_future) {
  [21:18:56.440]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.440]                           info)
  [21:18:56.440]                       }
  [21:18:56.440]                       else {
  [21:18:56.440]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.440]                           info, version)
  [21:18:56.440]                       }
  [21:18:56.440]                       base::stop(msg)
  [21:18:56.440]                     }
  [21:18:56.440]                   })
  [21:18:56.440]                 }
  [21:18:56.440]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.440]                 base::options(mc.cores = 1L)
  [21:18:56.440]             }
  [21:18:56.440]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.440]         }
  [21:18:56.440]     }
  [21:18:56.440]     if (base::is.na(TRUE)) {
  [21:18:56.440]     }
  [21:18:56.440]     else {
  [21:18:56.440]         if (TRUE) {
  [21:18:56.440]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.440]                 open = "w")
  [21:18:56.440]         }
  [21:18:56.440]         else {
  [21:18:56.440]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.440]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.440]         }
  [21:18:56.440]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.440]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.440]             base::sink(type = "output", split = FALSE)
  [21:18:56.440]             base::close(...future.stdout)
  [21:18:56.440]         }, add = TRUE)
  [21:18:56.440]     }
  [21:18:56.440]     ...future.frame <- base::sys.nframe()
  [21:18:56.440]     ...future.conditions <- base::list()
  [21:18:56.440]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.440]     ...future.result <- base::tryCatch({
  [21:18:56.440]         base::withCallingHandlers({
  [21:18:56.440]             ...future.value <- base::withVisible(base::local({
  [21:18:56.440]                 x <- a
  [21:18:56.440]             }))
  [21:18:56.440]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.440]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.440]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.440]                 version = "1.8")
  [21:18:56.440]         }, condition = base::local({
  [21:18:56.440]             c <- base::c
  [21:18:56.440]             inherits <- base::inherits
  [21:18:56.440]             invokeRestart <- base::invokeRestart
  [21:18:56.440]             length <- base::length
  [21:18:56.440]             list <- base::list
  [21:18:56.440]             seq.int <- base::seq.int
  [21:18:56.440]             signalCondition <- base::signalCondition
  [21:18:56.440]             sys.calls <- base::sys.calls
  [21:18:56.440]             Sys.time <- base::Sys.time
  [21:18:56.440]             `[[` <- base::`[[`
  [21:18:56.440]             `+` <- base::`+`
  [21:18:56.440]             `<<-` <- base::`<<-`
  [21:18:56.440]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.440]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.440]                   3L)]
  [21:18:56.440]             }
  [21:18:56.440]             function(cond) {
  [21:18:56.440]                 if (inherits(cond, "error")) {
  [21:18:56.440]                   sessionInformation <- function() {
  [21:18:56.440]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.440]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.440]                       search = base::search(), system = base::Sys.info())
  [21:18:56.440]                   }
  [21:18:56.440]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.440]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.440]                     cond$call), session = sessionInformation(), 
  [21:18:56.440]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.440]                   signalCondition(cond)
  [21:18:56.440]                 }
  [21:18:56.440]                 else if (inherits(cond, "condition")) {
  [21:18:56.440]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.440]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.440]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.440]                   if (!signal) {
  [21:18:56.440]                     muffleCondition <- function (cond) 
  [21:18:56.440]                     {
  [21:18:56.440]                       inherits <- base::inherits
  [21:18:56.440]                       invokeRestart <- base::invokeRestart
  [21:18:56.440]                       muffled <- FALSE
  [21:18:56.440]                       if (inherits(cond, "message")) {
  [21:18:56.440]                         invokeRestart("muffleMessage")
  [21:18:56.440]                         muffled <- TRUE
  [21:18:56.440]                       }
  [21:18:56.440]                       else if (inherits(cond, "warning")) {
  [21:18:56.440]                         invokeRestart("muffleWarning")
  [21:18:56.440]                         muffled <- TRUE
  [21:18:56.440]                       }
  [21:18:56.440]                       else if (inherits(cond, "condition")) {
  [21:18:56.440]                         computeRestarts <- base::computeRestarts
  [21:18:56.440]                         grepl <- base::grepl
  [21:18:56.440]                         is.null <- base::is.null
  [21:18:56.440]                         restarts <- computeRestarts(cond)
  [21:18:56.440]                         for (restart in restarts) {
  [21:18:56.440]                           name <- restart$name
  [21:18:56.440]                           if (is.null(name)) 
  [21:18:56.440]                             next
  [21:18:56.440]                           if (!grepl("^muffle", name)) 
  [21:18:56.440]                             next
  [21:18:56.440]                           invokeRestart(restart)
  [21:18:56.440]                           muffled <- TRUE
  [21:18:56.440]                           break
  [21:18:56.440]                         }
  [21:18:56.440]                       }
  [21:18:56.440]                       invisible(muffled)
  [21:18:56.440]                     }
  [21:18:56.440]                     muffleCondition(cond)
  [21:18:56.440]                   }
  [21:18:56.440]                 }
  [21:18:56.440]             }
  [21:18:56.440]         }))
  [21:18:56.440]     }, error = function(ex) {
  [21:18:56.440]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.440]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.440]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.440]     }, finally = {
  [21:18:56.440]         {
  [21:18:56.440]             {
  [21:18:56.440]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.440]             }
  [21:18:56.440]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.440]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.440]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.440]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.440]             {
  [21:18:56.440]                 if (substitute) 
  [21:18:56.440]                   expr <- substitute(expr)
  [21:18:56.440]                 if (is.function(workers)) 
  [21:18:56.440]                   workers <- workers()
  [21:18:56.440]                 workers <- as.integer(workers)
  [21:18:56.440]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.440]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.440]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.440]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.440]                     local = TRUE, label = label, ...))
  [21:18:56.440]                 }
  [21:18:56.440]                 oopts <- options(mc.cores = workers)
  [21:18:56.440]                 on.exit(options(oopts))
  [21:18:56.440]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.440]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.440]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.440]                   label = label, ...)
  [21:18:56.440]                 if (!future$lazy) 
  [21:18:56.440]                   future <- run(future)
  [21:18:56.440]                 invisible(future)
  [21:18:56.440]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.440]         }
  [21:18:56.440]         base::options(...future.oldOptions)
  [21:18:56.440]     })
  [21:18:56.440]     Sys.time
  [21:18:56.440]     if (base::is.na(TRUE)) {
  [21:18:56.440]     }
  [21:18:56.440]     else {
  [21:18:56.440]         base::sink(type = "output", split = FALSE)
  [21:18:56.440]         if (TRUE) {
  [21:18:56.440]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.440]         }
  [21:18:56.440]         else {
  [21:18:56.440]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.440]         }
  [21:18:56.440]         base::close(...future.stdout)
  [21:18:56.440]         ...future.stdout <- NULL
  [21:18:56.440]     }
  [21:18:56.440]     ...future.result$conditions <- ...future.conditions
  [21:18:56.440]     ...future.result
  [21:18:56.440] }
  [21:18:56.444] requestCore(): workers = 2
  [21:18:56.463] MulticoreFuture started
  [21:18:56.478] plan(): Setting new future strategy stack:
  [21:18:56.478] List of future strategies:
  [21:18:56.478] 1. sequential:
  [21:18:56.478]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.478]    - tweaked: FALSE
  [21:18:56.478]    - call: NULL
  [21:18:56.494] plan(): nbrOfWorkers() = 1
  [21:18:56.496] plan(): Setting new future strategy stack:
  [21:18:56.497] List of future strategies:
  [21:18:56.497] 1. multicore:
  [21:18:56.497]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.497]    - tweaked: FALSE
  [21:18:56.497]    - call: plan(strategy)
  [21:18:56.499] plan(): nbrOfWorkers() = 2
  ** Future evaluation with errors
  [21:18:56.502] getGlobalsAndPackages() ...
  [21:18:56.502] Searching for globals...
  [21:18:56.505] - globals found: [3] '{', '<-', 'stop'
  [21:18:56.505] Searching for globals ... DONE
  [21:18:56.506] Resolving globals: FALSE
  [21:18:56.506] 
  [21:18:56.507] 
  [21:18:56.507] getGlobalsAndPackages() ... DONE
  [21:18:56.509] Packages needed by the future expression (n = 0): <none>
  [21:18:56.510] Packages needed by future strategies (n = 0): <none>
  [21:18:56.521] {
  [21:18:56.521]     {
  [21:18:56.521]         ...future.startTime <- base::Sys.time()
  [21:18:56.521]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.521]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.521]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.521]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.521]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.521]         {
  [21:18:56.521]             {
  [21:18:56.521]                 {
  [21:18:56.521]                   base::local({
  [21:18:56.521]                     has_future <- base::requireNamespace("future", 
  [21:18:56.521]                       quietly = TRUE)
  [21:18:56.521]                     version <- if (has_future) 
  [21:18:56.521]                       utils::packageVersion("future")
  [21:18:56.521]                     else NULL
  [21:18:56.521]                     if (!has_future || version < "1.8.0") {
  [21:18:56.521]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.521]                         "", base::R.version$version.string), 
  [21:18:56.521]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.521]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.521]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.521]                           "release", "version")], collapse = " "), 
  [21:18:56.521]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.521]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.521]                         info)
  [21:18:56.521]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.521]                       if (!has_future) {
  [21:18:56.521]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.521]                           info)
  [21:18:56.521]                       }
  [21:18:56.521]                       else {
  [21:18:56.521]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.521]                           info, version)
  [21:18:56.521]                       }
  [21:18:56.521]                       base::stop(msg)
  [21:18:56.521]                     }
  [21:18:56.521]                   })
  [21:18:56.521]                 }
  [21:18:56.521]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.521]                 base::options(mc.cores = 1L)
  [21:18:56.521]             }
  [21:18:56.521]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.521]         }
  [21:18:56.521]     }
  [21:18:56.521]     if (base::is.na(TRUE)) {
  [21:18:56.521]     }
  [21:18:56.521]     else {
  [21:18:56.521]         if (TRUE) {
  [21:18:56.521]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.521]                 open = "w")
  [21:18:56.521]         }
  [21:18:56.521]         else {
  [21:18:56.521]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.521]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.521]         }
  [21:18:56.521]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.521]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.521]             base::sink(type = "output", split = FALSE)
  [21:18:56.521]             base::close(...future.stdout)
  [21:18:56.521]         }, add = TRUE)
  [21:18:56.521]     }
  [21:18:56.521]     ...future.frame <- base::sys.nframe()
  [21:18:56.521]     ...future.conditions <- base::list()
  [21:18:56.521]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.521]     ...future.result <- base::tryCatch({
  [21:18:56.521]         base::withCallingHandlers({
  [21:18:56.521]             ...future.value <- base::withVisible(base::local({
  [21:18:56.521]                 x <- 3
  [21:18:56.521]                 stop("Woops!")
  [21:18:56.521]                 x
  [21:18:56.521]             }))
  [21:18:56.521]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.521]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.521]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.521]                 version = "1.8")
  [21:18:56.521]         }, condition = base::local({
  [21:18:56.521]             c <- base::c
  [21:18:56.521]             inherits <- base::inherits
  [21:18:56.521]             invokeRestart <- base::invokeRestart
  [21:18:56.521]             length <- base::length
  [21:18:56.521]             list <- base::list
  [21:18:56.521]             seq.int <- base::seq.int
  [21:18:56.521]             signalCondition <- base::signalCondition
  [21:18:56.521]             sys.calls <- base::sys.calls
  [21:18:56.521]             Sys.time <- base::Sys.time
  [21:18:56.521]             `[[` <- base::`[[`
  [21:18:56.521]             `+` <- base::`+`
  [21:18:56.521]             `<<-` <- base::`<<-`
  [21:18:56.521]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.521]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.521]                   3L)]
  [21:18:56.521]             }
  [21:18:56.521]             function(cond) {
  [21:18:56.521]                 if (inherits(cond, "error")) {
  [21:18:56.521]                   sessionInformation <- function() {
  [21:18:56.521]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.521]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.521]                       search = base::search(), system = base::Sys.info())
  [21:18:56.521]                   }
  [21:18:56.521]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.521]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.521]                     cond$call), session = sessionInformation(), 
  [21:18:56.521]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.521]                   signalCondition(cond)
  [21:18:56.521]                 }
  [21:18:56.521]                 else if (inherits(cond, "condition")) {
  [21:18:56.521]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.521]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.521]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.521]                   if (!signal) {
  [21:18:56.521]                     muffleCondition <- function (cond) 
  [21:18:56.521]                     {
  [21:18:56.521]                       inherits <- base::inherits
  [21:18:56.521]                       invokeRestart <- base::invokeRestart
  [21:18:56.521]                       muffled <- FALSE
  [21:18:56.521]                       if (inherits(cond, "message")) {
  [21:18:56.521]                         invokeRestart("muffleMessage")
  [21:18:56.521]                         muffled <- TRUE
  [21:18:56.521]                       }
  [21:18:56.521]                       else if (inherits(cond, "warning")) {
  [21:18:56.521]                         invokeRestart("muffleWarning")
  [21:18:56.521]                         muffled <- TRUE
  [21:18:56.521]                       }
  [21:18:56.521]                       else if (inherits(cond, "condition")) {
  [21:18:56.521]                         computeRestarts <- base::computeRestarts
  [21:18:56.521]                         grepl <- base::grepl
  [21:18:56.521]                         is.null <- base::is.null
  [21:18:56.521]                         restarts <- computeRestarts(cond)
  [21:18:56.521]                         for (restart in restarts) {
  [21:18:56.521]                           name <- restart$name
  [21:18:56.521]                           if (is.null(name)) 
  [21:18:56.521]                             next
  [21:18:56.521]                           if (!grepl("^muffle", name)) 
  [21:18:56.521]                             next
  [21:18:56.521]                           invokeRestart(restart)
  [21:18:56.521]                           muffled <- TRUE
  [21:18:56.521]                           break
  [21:18:56.521]                         }
  [21:18:56.521]                       }
  [21:18:56.521]                       invisible(muffled)
  [21:18:56.521]                     }
  [21:18:56.521]                     muffleCondition(cond)
  [21:18:56.521]                   }
  [21:18:56.521]                 }
  [21:18:56.521]             }
  [21:18:56.521]         }))
  [21:18:56.521]     }, error = function(ex) {
  [21:18:56.521]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.521]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.521]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.521]     }, finally = {
  [21:18:56.521]         {
  [21:18:56.521]             {
  [21:18:56.521]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.521]             }
  [21:18:56.521]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.521]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.521]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.521]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.521]             {
  [21:18:56.521]                 if (substitute) 
  [21:18:56.521]                   expr <- substitute(expr)
  [21:18:56.521]                 if (is.function(workers)) 
  [21:18:56.521]                   workers <- workers()
  [21:18:56.521]                 workers <- as.integer(workers)
  [21:18:56.521]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.521]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.521]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.521]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.521]                     local = TRUE, label = label, ...))
  [21:18:56.521]                 }
  [21:18:56.521]                 oopts <- options(mc.cores = workers)
  [21:18:56.521]                 on.exit(options(oopts))
  [21:18:56.521]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.521]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.521]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.521]                   label = label, ...)
  [21:18:56.521]                 if (!future$lazy) 
  [21:18:56.521]                   future <- run(future)
  [21:18:56.521]                 invisible(future)
  [21:18:56.521]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.521]         }
  [21:18:56.521]         base::options(...future.oldOptions)
  [21:18:56.521]     })
  [21:18:56.521]     Sys.time
  [21:18:56.521]     if (base::is.na(TRUE)) {
  [21:18:56.521]     }
  [21:18:56.521]     else {
  [21:18:56.521]         base::sink(type = "output", split = FALSE)
  [21:18:56.521]         if (TRUE) {
  [21:18:56.521]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.521]         }
  [21:18:56.521]         else {
  [21:18:56.521]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.521]         }
  [21:18:56.521]         base::close(...future.stdout)
  [21:18:56.521]         ...future.stdout <- NULL
  [21:18:56.521]     }
  [21:18:56.521]     ...future.result$conditions <- ...future.conditions
  [21:18:56.521]     ...future.result
  [21:18:56.521] }
  [21:18:56.526] requestCore(): workers = 2
  [21:18:56.529] MulticoreFuture started
  [21:18:56.545] plan(): Setting new future strategy stack:
  [21:18:56.546] List of future strategies:
  [21:18:56.546] 1. sequential:
  [21:18:56.546]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.546]    - tweaked: FALSE
  [21:18:56.546]    - call: NULL
  [21:18:56.574] plan(): nbrOfWorkers() = 1
  [21:18:56.577] plan(): Setting new future strategy stack:
  [21:18:56.577] List of future strategies:
  [21:18:56.577] 1. multicore:
  [21:18:56.577]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.577]    - tweaked: FALSE
  [21:18:56.577]    - call: plan(strategy)
  [21:18:56.579] plan(): nbrOfWorkers() = 2
  [21:18:56.582] signalConditions() ...
  [21:18:56.583]  - include = 'immediateCondition'
  [21:18:56.588]  - exclude = 
  [21:18:56.589]  - resignal = FALSE
  [21:18:56.589]  - Number of conditions: 1
  [21:18:56.589] signalConditions() ... done
  [21:18:56.590] signalConditions() ...
  [21:18:56.590]  - include = 'immediateCondition'
  [21:18:56.590]  - exclude = 
  [21:18:56.591]  - resignal = FALSE
  [21:18:56.591]  - Number of conditions: 1
  [21:18:56.591] signalConditions() ... done
  [21:18:56.592] Future state: 'finished'
  [21:18:56.592] signalConditions() ...
  [21:18:56.592]  - include = 'condition'
  [21:18:56.593]  - exclude = 'immediateCondition'
  [21:18:56.593]  - resignal = TRUE
  [21:18:56.593]  - Number of conditions: 1
  [21:18:56.610]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.610] signalConditions() ... done
  [21:18:56.612] getGlobalsAndPackages() ...
  [21:18:56.613] Searching for globals...
  [21:18:56.616] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:56.617] Searching for globals ... DONE
  [21:18:56.617] Resolving globals: FALSE
  [21:18:56.618] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:56.618] - globals: [1] 'ii'
  [21:18:56.619] 
  [21:18:56.619] getGlobalsAndPackages() ... DONE
  [21:18:56.622] Packages needed by the future expression (n = 0): <none>
  [21:18:56.622] Packages needed by future strategies (n = 0): <none>
  [21:18:56.627] {
  [21:18:56.627]     {
  [21:18:56.627]         ...future.startTime <- base::Sys.time()
  [21:18:56.627]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.627]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.627]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.627]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.627]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.627]         {
  [21:18:56.627]             {
  [21:18:56.627]                 {
  [21:18:56.627]                   base::local({
  [21:18:56.627]                     has_future <- base::requireNamespace("future", 
  [21:18:56.627]                       quietly = TRUE)
  [21:18:56.627]                     version <- if (has_future) 
  [21:18:56.627]                       utils::packageVersion("future")
  [21:18:56.627]                     else NULL
  [21:18:56.627]                     if (!has_future || version < "1.8.0") {
  [21:18:56.627]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.627]                         "", base::R.version$version.string), 
  [21:18:56.627]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.627]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.627]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.627]                           "release", "version")], collapse = " "), 
  [21:18:56.627]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.627]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.627]                         info)
  [21:18:56.627]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.627]                       if (!has_future) {
  [21:18:56.627]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.627]                           info)
  [21:18:56.627]                       }
  [21:18:56.627]                       else {
  [21:18:56.627]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.627]                           info, version)
  [21:18:56.627]                       }
  [21:18:56.627]                       base::stop(msg)
  [21:18:56.627]                     }
  [21:18:56.627]                   })
  [21:18:56.627]                 }
  [21:18:56.627]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.627]                 base::options(mc.cores = 1L)
  [21:18:56.627]             }
  [21:18:56.627]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.627]         }
  [21:18:56.627]     }
  [21:18:56.627]     if (base::is.na(TRUE)) {
  [21:18:56.627]     }
  [21:18:56.627]     else {
  [21:18:56.627]         if (TRUE) {
  [21:18:56.627]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.627]                 open = "w")
  [21:18:56.627]         }
  [21:18:56.627]         else {
  [21:18:56.627]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.627]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.627]         }
  [21:18:56.627]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.627]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.627]             base::sink(type = "output", split = FALSE)
  [21:18:56.627]             base::close(...future.stdout)
  [21:18:56.627]         }, add = TRUE)
  [21:18:56.627]     }
  [21:18:56.627]     ...future.frame <- base::sys.nframe()
  [21:18:56.627]     ...future.conditions <- base::list()
  [21:18:56.627]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.627]     ...future.result <- base::tryCatch({
  [21:18:56.627]         base::withCallingHandlers({
  [21:18:56.627]             ...future.value <- base::withVisible(base::local({
  [21:18:56.627]                 if (ii%%2 == 0) 
  [21:18:56.627]                   stop("Woops!")
  [21:18:56.627]                 ii
  [21:18:56.627]             }))
  [21:18:56.627]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.627]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.627]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.627]                 version = "1.8")
  [21:18:56.627]         }, condition = base::local({
  [21:18:56.627]             c <- base::c
  [21:18:56.627]             inherits <- base::inherits
  [21:18:56.627]             invokeRestart <- base::invokeRestart
  [21:18:56.627]             length <- base::length
  [21:18:56.627]             list <- base::list
  [21:18:56.627]             seq.int <- base::seq.int
  [21:18:56.627]             signalCondition <- base::signalCondition
  [21:18:56.627]             sys.calls <- base::sys.calls
  [21:18:56.627]             Sys.time <- base::Sys.time
  [21:18:56.627]             `[[` <- base::`[[`
  [21:18:56.627]             `+` <- base::`+`
  [21:18:56.627]             `<<-` <- base::`<<-`
  [21:18:56.627]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.627]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.627]                   3L)]
  [21:18:56.627]             }
  [21:18:56.627]             function(cond) {
  [21:18:56.627]                 if (inherits(cond, "error")) {
  [21:18:56.627]                   sessionInformation <- function() {
  [21:18:56.627]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.627]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.627]                       search = base::search(), system = base::Sys.info())
  [21:18:56.627]                   }
  [21:18:56.627]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.627]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.627]                     cond$call), session = sessionInformation(), 
  [21:18:56.627]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.627]                   signalCondition(cond)
  [21:18:56.627]                 }
  [21:18:56.627]                 else if (inherits(cond, "condition")) {
  [21:18:56.627]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.627]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.627]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.627]                   if (!signal) {
  [21:18:56.627]                     muffleCondition <- function (cond) 
  [21:18:56.627]                     {
  [21:18:56.627]                       inherits <- base::inherits
  [21:18:56.627]                       invokeRestart <- base::invokeRestart
  [21:18:56.627]                       muffled <- FALSE
  [21:18:56.627]                       if (inherits(cond, "message")) {
  [21:18:56.627]                         invokeRestart("muffleMessage")
  [21:18:56.627]                         muffled <- TRUE
  [21:18:56.627]                       }
  [21:18:56.627]                       else if (inherits(cond, "warning")) {
  [21:18:56.627]                         invokeRestart("muffleWarning")
  [21:18:56.627]                         muffled <- TRUE
  [21:18:56.627]                       }
  [21:18:56.627]                       else if (inherits(cond, "condition")) {
  [21:18:56.627]                         computeRestarts <- base::computeRestarts
  [21:18:56.627]                         grepl <- base::grepl
  [21:18:56.627]                         is.null <- base::is.null
  [21:18:56.627]                         restarts <- computeRestarts(cond)
  [21:18:56.627]                         for (restart in restarts) {
  [21:18:56.627]                           name <- restart$name
  [21:18:56.627]                           if (is.null(name)) 
  [21:18:56.627]                             next
  [21:18:56.627]                           if (!grepl("^muffle", name)) 
  [21:18:56.627]                             next
  [21:18:56.627]                           invokeRestart(restart)
  [21:18:56.627]                           muffled <- TRUE
  [21:18:56.627]                           break
  [21:18:56.627]                         }
  [21:18:56.627]                       }
  [21:18:56.627]                       invisible(muffled)
  [21:18:56.627]                     }
  [21:18:56.627]                     muffleCondition(cond)
  [21:18:56.627]                   }
  [21:18:56.627]                 }
  [21:18:56.627]             }
  [21:18:56.627]         }))
  [21:18:56.627]     }, error = function(ex) {
  [21:18:56.627]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.627]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.627]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.627]     }, finally = {
  [21:18:56.627]         {
  [21:18:56.627]             {
  [21:18:56.627]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.627]             }
  [21:18:56.627]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.627]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.627]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.627]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.627]             {
  [21:18:56.627]                 if (substitute) 
  [21:18:56.627]                   expr <- substitute(expr)
  [21:18:56.627]                 if (is.function(workers)) 
  [21:18:56.627]                   workers <- workers()
  [21:18:56.627]                 workers <- as.integer(workers)
  [21:18:56.627]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.627]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.627]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.627]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.627]                     local = TRUE, label = label, ...))
  [21:18:56.627]                 }
  [21:18:56.627]                 oopts <- options(mc.cores = workers)
  [21:18:56.627]                 on.exit(options(oopts))
  [21:18:56.627]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.627]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.627]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.627]                   label = label, ...)
  [21:18:56.627]                 if (!future$lazy) 
  [21:18:56.627]                   future <- run(future)
  [21:18:56.627]                 invisible(future)
  [21:18:56.627]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.627]         }
  [21:18:56.627]         base::options(...future.oldOptions)
  [21:18:56.627]     })
  [21:18:56.627]     Sys.time
  [21:18:56.627]     if (base::is.na(TRUE)) {
  [21:18:56.627]     }
  [21:18:56.627]     else {
  [21:18:56.627]         base::sink(type = "output", split = FALSE)
  [21:18:56.627]         if (TRUE) {
  [21:18:56.627]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.627]         }
  [21:18:56.627]         else {
  [21:18:56.627]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.627]         }
  [21:18:56.627]         base::close(...future.stdout)
  [21:18:56.627]         ...future.stdout <- NULL
  [21:18:56.627]     }
  [21:18:56.627]     ...future.result$conditions <- ...future.conditions
  [21:18:56.627]     ...future.result
  [21:18:56.627] }
  [21:18:56.655] requestCore(): workers = 2
  [21:18:56.658] MulticoreFuture started
  [21:18:56.662] getGlobalsAndPackages() ...
  [21:18:56.662] Searching for globals...
  [21:18:56.668] plan(): Setting new future strategy stack:
  [21:18:56.668] List of future strategies:
  [21:18:56.668] 1. sequential:
  [21:18:56.668]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.668]    - tweaked: FALSE
  [21:18:56.668]    - call: NULL
  [21:18:56.670] plan(): nbrOfWorkers() = 1
  [21:18:56.672] plan(): Setting new future strategy stack:
  [21:18:56.672] List of future strategies:
  [21:18:56.672] 1. multicore:
  [21:18:56.672]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.672]    - tweaked: FALSE
  [21:18:56.672]    - call: plan(strategy)
  [21:18:56.674] plan(): nbrOfWorkers() = 2
  [21:18:56.674] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:56.675] Searching for globals ... DONE
  [21:18:56.675] Resolving globals: FALSE
  [21:18:56.677] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:56.677] - globals: [1] 'ii'
  [21:18:56.678] 
  [21:18:56.678] getGlobalsAndPackages() ... DONE
  [21:18:56.680] Packages needed by the future expression (n = 0): <none>
  [21:18:56.681] Packages needed by future strategies (n = 0): <none>
  [21:18:56.714] {
  [21:18:56.714]     {
  [21:18:56.714]         ...future.startTime <- base::Sys.time()
  [21:18:56.714]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.714]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.714]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.714]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.714]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.714]         {
  [21:18:56.714]             {
  [21:18:56.714]                 {
  [21:18:56.714]                   base::local({
  [21:18:56.714]                     has_future <- base::requireNamespace("future", 
  [21:18:56.714]                       quietly = TRUE)
  [21:18:56.714]                     version <- if (has_future) 
  [21:18:56.714]                       utils::packageVersion("future")
  [21:18:56.714]                     else NULL
  [21:18:56.714]                     if (!has_future || version < "1.8.0") {
  [21:18:56.714]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.714]                         "", base::R.version$version.string), 
  [21:18:56.714]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.714]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.714]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.714]                           "release", "version")], collapse = " "), 
  [21:18:56.714]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.714]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.714]                         info)
  [21:18:56.714]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.714]                       if (!has_future) {
  [21:18:56.714]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.714]                           info)
  [21:18:56.714]                       }
  [21:18:56.714]                       else {
  [21:18:56.714]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.714]                           info, version)
  [21:18:56.714]                       }
  [21:18:56.714]                       base::stop(msg)
  [21:18:56.714]                     }
  [21:18:56.714]                   })
  [21:18:56.714]                 }
  [21:18:56.714]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.714]                 base::options(mc.cores = 1L)
  [21:18:56.714]             }
  [21:18:56.714]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.714]         }
  [21:18:56.714]     }
  [21:18:56.714]     if (base::is.na(TRUE)) {
  [21:18:56.714]     }
  [21:18:56.714]     else {
  [21:18:56.714]         if (TRUE) {
  [21:18:56.714]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.714]                 open = "w")
  [21:18:56.714]         }
  [21:18:56.714]         else {
  [21:18:56.714]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.714]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.714]         }
  [21:18:56.714]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.714]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.714]             base::sink(type = "output", split = FALSE)
  [21:18:56.714]             base::close(...future.stdout)
  [21:18:56.714]         }, add = TRUE)
  [21:18:56.714]     }
  [21:18:56.714]     ...future.frame <- base::sys.nframe()
  [21:18:56.714]     ...future.conditions <- base::list()
  [21:18:56.714]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.714]     ...future.result <- base::tryCatch({
  [21:18:56.714]         base::withCallingHandlers({
  [21:18:56.714]             ...future.value <- base::withVisible(base::local({
  [21:18:56.714]                 if (ii%%2 == 0) 
  [21:18:56.714]                   stop("Woops!")
  [21:18:56.714]                 ii
  [21:18:56.714]             }))
  [21:18:56.714]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.714]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.714]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.714]                 version = "1.8")
  [21:18:56.714]         }, condition = base::local({
  [21:18:56.714]             c <- base::c
  [21:18:56.714]             inherits <- base::inherits
  [21:18:56.714]             invokeRestart <- base::invokeRestart
  [21:18:56.714]             length <- base::length
  [21:18:56.714]             list <- base::list
  [21:18:56.714]             seq.int <- base::seq.int
  [21:18:56.714]             signalCondition <- base::signalCondition
  [21:18:56.714]             sys.calls <- base::sys.calls
  [21:18:56.714]             Sys.time <- base::Sys.time
  [21:18:56.714]             `[[` <- base::`[[`
  [21:18:56.714]             `+` <- base::`+`
  [21:18:56.714]             `<<-` <- base::`<<-`
  [21:18:56.714]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.714]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.714]                   3L)]
  [21:18:56.714]             }
  [21:18:56.714]             function(cond) {
  [21:18:56.714]                 if (inherits(cond, "error")) {
  [21:18:56.714]                   sessionInformation <- function() {
  [21:18:56.714]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.714]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.714]                       search = base::search(), system = base::Sys.info())
  [21:18:56.714]                   }
  [21:18:56.714]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.714]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.714]                     cond$call), session = sessionInformation(), 
  [21:18:56.714]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.714]                   signalCondition(cond)
  [21:18:56.714]                 }
  [21:18:56.714]                 else if (inherits(cond, "condition")) {
  [21:18:56.714]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.714]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.714]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.714]                   if (!signal) {
  [21:18:56.714]                     muffleCondition <- function (cond) 
  [21:18:56.714]                     {
  [21:18:56.714]                       inherits <- base::inherits
  [21:18:56.714]                       invokeRestart <- base::invokeRestart
  [21:18:56.714]                       muffled <- FALSE
  [21:18:56.714]                       if (inherits(cond, "message")) {
  [21:18:56.714]                         invokeRestart("muffleMessage")
  [21:18:56.714]                         muffled <- TRUE
  [21:18:56.714]                       }
  [21:18:56.714]                       else if (inherits(cond, "warning")) {
  [21:18:56.714]                         invokeRestart("muffleWarning")
  [21:18:56.714]                         muffled <- TRUE
  [21:18:56.714]                       }
  [21:18:56.714]                       else if (inherits(cond, "condition")) {
  [21:18:56.714]                         computeRestarts <- base::computeRestarts
  [21:18:56.714]                         grepl <- base::grepl
  [21:18:56.714]                         is.null <- base::is.null
  [21:18:56.714]                         restarts <- computeRestarts(cond)
  [21:18:56.714]                         for (restart in restarts) {
  [21:18:56.714]                           name <- restart$name
  [21:18:56.714]                           if (is.null(name)) 
  [21:18:56.714]                             next
  [21:18:56.714]                           if (!grepl("^muffle", name)) 
  [21:18:56.714]                             next
  [21:18:56.714]                           invokeRestart(restart)
  [21:18:56.714]                           muffled <- TRUE
  [21:18:56.714]                           break
  [21:18:56.714]                         }
  [21:18:56.714]                       }
  [21:18:56.714]                       invisible(muffled)
  [21:18:56.714]                     }
  [21:18:56.714]                     muffleCondition(cond)
  [21:18:56.714]                   }
  [21:18:56.714]                 }
  [21:18:56.714]             }
  [21:18:56.714]         }))
  [21:18:56.714]     }, error = function(ex) {
  [21:18:56.714]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.714]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.714]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.714]     }, finally = {
  [21:18:56.714]         {
  [21:18:56.714]             {
  [21:18:56.714]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.714]             }
  [21:18:56.714]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.714]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.714]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.714]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.714]             {
  [21:18:56.714]                 if (substitute) 
  [21:18:56.714]                   expr <- substitute(expr)
  [21:18:56.714]                 if (is.function(workers)) 
  [21:18:56.714]                   workers <- workers()
  [21:18:56.714]                 workers <- as.integer(workers)
  [21:18:56.714]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.714]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.714]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.714]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.714]                     local = TRUE, label = label, ...))
  [21:18:56.714]                 }
  [21:18:56.714]                 oopts <- options(mc.cores = workers)
  [21:18:56.714]                 on.exit(options(oopts))
  [21:18:56.714]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.714]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.714]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.714]                   label = label, ...)
  [21:18:56.714]                 if (!future$lazy) 
  [21:18:56.714]                   future <- run(future)
  [21:18:56.714]                 invisible(future)
  [21:18:56.714]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.714]         }
  [21:18:56.714]         base::options(...future.oldOptions)
  [21:18:56.714]     })
  [21:18:56.714]     Sys.time
  [21:18:56.714]     if (base::is.na(TRUE)) {
  [21:18:56.714]     }
  [21:18:56.714]     else {
  [21:18:56.714]         base::sink(type = "output", split = FALSE)
  [21:18:56.714]         if (TRUE) {
  [21:18:56.714]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.714]         }
  [21:18:56.714]         else {
  [21:18:56.714]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.714]         }
  [21:18:56.714]         base::close(...future.stdout)
  [21:18:56.714]         ...future.stdout <- NULL
  [21:18:56.714]     }
  [21:18:56.714]     ...future.result$conditions <- ...future.conditions
  [21:18:56.714]     ...future.result
  [21:18:56.714] }
  [21:18:56.720] requestCore(): workers = 2
  [21:18:56.723] MulticoreFuture started
  [21:18:56.736] plan(): Setting new future strategy stack:
  [21:18:56.736] List of future strategies:
  [21:18:56.736] 1. sequential:
  [21:18:56.736]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.736]    - tweaked: FALSE
  [21:18:56.736]    - call: NULL
  [21:18:56.738] plan(): nbrOfWorkers() = 1
  [21:18:56.740] plan(): Setting new future strategy stack:
  [21:18:56.746] getGlobalsAndPackages() ...
  [21:18:56.747] Searching for globals...
  [21:18:56.750] - globals found: [6] '{', 'if', '==', '%%', 'ii', 'stop'
  [21:18:56.751] Searching for globals ... DONE
  [21:18:56.751] Resolving globals: FALSE
  [21:18:56.753] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:56.754] - globals: [1] 'ii'
  [21:18:56.754] 
  [21:18:56.754] getGlobalsAndPackages() ... DONE
  [21:18:56.757] Packages needed by the future expression (n = 0): <none>
  [21:18:56.757] Packages needed by future strategies (n = 0): <none>
  [21:18:56.741] List of future strategies:
  [21:18:56.741] 1. multicore:
  [21:18:56.741]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.741]    - tweaked: FALSE
  [21:18:56.741]    - call: plan(strategy)
  [21:18:56.759] plan(): nbrOfWorkers() = 2
  [21:18:56.778] {
  [21:18:56.778]     {
  [21:18:56.778]         ...future.startTime <- base::Sys.time()
  [21:18:56.778]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.778]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.778]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.778]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.778]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.778]         {
  [21:18:56.778]             {
  [21:18:56.778]                 {
  [21:18:56.778]                   base::local({
  [21:18:56.778]                     has_future <- base::requireNamespace("future", 
  [21:18:56.778]                       quietly = TRUE)
  [21:18:56.778]                     version <- if (has_future) 
  [21:18:56.778]                       utils::packageVersion("future")
  [21:18:56.778]                     else NULL
  [21:18:56.778]                     if (!has_future || version < "1.8.0") {
  [21:18:56.778]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.778]                         "", base::R.version$version.string), 
  [21:18:56.778]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.778]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.778]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.778]                           "release", "version")], collapse = " "), 
  [21:18:56.778]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.778]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.778]                         info)
  [21:18:56.778]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.778]                       if (!has_future) {
  [21:18:56.778]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.778]                           info)
  [21:18:56.778]                       }
  [21:18:56.778]                       else {
  [21:18:56.778]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.778]                           info, version)
  [21:18:56.778]                       }
  [21:18:56.778]                       base::stop(msg)
  [21:18:56.778]                     }
  [21:18:56.778]                   })
  [21:18:56.778]                 }
  [21:18:56.778]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.778]                 base::options(mc.cores = 1L)
  [21:18:56.778]             }
  [21:18:56.778]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.778]         }
  [21:18:56.778]     }
  [21:18:56.778]     if (base::is.na(TRUE)) {
  [21:18:56.778]     }
  [21:18:56.778]     else {
  [21:18:56.778]         if (TRUE) {
  [21:18:56.778]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.778]                 open = "w")
  [21:18:56.778]         }
  [21:18:56.778]         else {
  [21:18:56.778]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.778]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.778]         }
  [21:18:56.778]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.778]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.778]             base::sink(type = "output", split = FALSE)
  [21:18:56.778]             base::close(...future.stdout)
  [21:18:56.778]         }, add = TRUE)
  [21:18:56.778]     }
  [21:18:56.778]     ...future.frame <- base::sys.nframe()
  [21:18:56.778]     ...future.conditions <- base::list()
  [21:18:56.778]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.778]     ...future.result <- base::tryCatch({
  [21:18:56.778]         base::withCallingHandlers({
  [21:18:56.778]             ...future.value <- base::withVisible(base::local({
  [21:18:56.778]                 if (ii%%2 == 0) 
  [21:18:56.778]                   stop("Woops!")
  [21:18:56.778]                 ii
  [21:18:56.778]             }))
  [21:18:56.778]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.778]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.778]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.778]                 version = "1.8")
  [21:18:56.778]         }, condition = base::local({
  [21:18:56.778]             c <- base::c
  [21:18:56.778]             inherits <- base::inherits
  [21:18:56.778]             invokeRestart <- base::invokeRestart
  [21:18:56.778]             length <- base::length
  [21:18:56.778]             list <- base::list
  [21:18:56.778]             seq.int <- base::seq.int
  [21:18:56.778]             signalCondition <- base::signalCondition
  [21:18:56.778]             sys.calls <- base::sys.calls
  [21:18:56.778]             Sys.time <- base::Sys.time
  [21:18:56.778]             `[[` <- base::`[[`
  [21:18:56.778]             `+` <- base::`+`
  [21:18:56.778]             `<<-` <- base::`<<-`
  [21:18:56.778]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.778]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.778]                   3L)]
  [21:18:56.778]             }
  [21:18:56.778]             function(cond) {
  [21:18:56.778]                 if (inherits(cond, "error")) {
  [21:18:56.778]                   sessionInformation <- function() {
  [21:18:56.778]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.778]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.778]                       search = base::search(), system = base::Sys.info())
  [21:18:56.778]                   }
  [21:18:56.778]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.778]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.778]                     cond$call), session = sessionInformation(), 
  [21:18:56.778]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.778]                   signalCondition(cond)
  [21:18:56.778]                 }
  [21:18:56.778]                 else if (inherits(cond, "condition")) {
  [21:18:56.778]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.778]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.778]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.778]                   if (!signal) {
  [21:18:56.778]                     muffleCondition <- function (cond) 
  [21:18:56.778]                     {
  [21:18:56.778]                       inherits <- base::inherits
  [21:18:56.778]                       invokeRestart <- base::invokeRestart
  [21:18:56.778]                       muffled <- FALSE
  [21:18:56.778]                       if (inherits(cond, "message")) {
  [21:18:56.778]                         invokeRestart("muffleMessage")
  [21:18:56.778]                         muffled <- TRUE
  [21:18:56.778]                       }
  [21:18:56.778]                       else if (inherits(cond, "warning")) {
  [21:18:56.778]                         invokeRestart("muffleWarning")
  [21:18:56.778]                         muffled <- TRUE
  [21:18:56.778]                       }
  [21:18:56.778]                       else if (inherits(cond, "condition")) {
  [21:18:56.778]                         computeRestarts <- base::computeRestarts
  [21:18:56.778]                         grepl <- base::grepl
  [21:18:56.778]                         is.null <- base::is.null
  [21:18:56.778]                         restarts <- computeRestarts(cond)
  [21:18:56.778]                         for (restart in restarts) {
  [21:18:56.778]                           name <- restart$name
  [21:18:56.778]                           if (is.null(name)) 
  [21:18:56.778]                             next
  [21:18:56.778]                           if (!grepl("^muffle", name)) 
  [21:18:56.778]                             next
  [21:18:56.778]                           invokeRestart(restart)
  [21:18:56.778]                           muffled <- TRUE
  [21:18:56.778]                           break
  [21:18:56.778]                         }
  [21:18:56.778]                       }
  [21:18:56.778]                       invisible(muffled)
  [21:18:56.778]                     }
  [21:18:56.778]                     muffleCondition(cond)
  [21:18:56.778]                   }
  [21:18:56.778]                 }
  [21:18:56.778]             }
  [21:18:56.778]         }))
  [21:18:56.778]     }, error = function(ex) {
  [21:18:56.778]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.778]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.778]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.778]     }, finally = {
  [21:18:56.778]         {
  [21:18:56.778]             {
  [21:18:56.778]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.778]             }
  [21:18:56.778]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.778]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.778]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.778]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.778]             {
  [21:18:56.778]                 if (substitute) 
  [21:18:56.778]                   expr <- substitute(expr)
  [21:18:56.778]                 if (is.function(workers)) 
  [21:18:56.778]                   workers <- workers()
  [21:18:56.778]                 workers <- as.integer(workers)
  [21:18:56.778]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.778]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.778]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.778]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.778]                     local = TRUE, label = label, ...))
  [21:18:56.778]                 }
  [21:18:56.778]                 oopts <- options(mc.cores = workers)
  [21:18:56.778]                 on.exit(options(oopts))
  [21:18:56.778]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.778]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.778]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.778]                   label = label, ...)
  [21:18:56.778]                 if (!future$lazy) 
  [21:18:56.778]                   future <- run(future)
  [21:18:56.778]                 invisible(future)
  [21:18:56.778]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.778]         }
  [21:18:56.778]         base::options(...future.oldOptions)
  [21:18:56.778]     })
  [21:18:56.778]     Sys.time
  [21:18:56.778]     if (base::is.na(TRUE)) {
  [21:18:56.778]     }
  [21:18:56.778]     else {
  [21:18:56.778]         base::sink(type = "output", split = FALSE)
  [21:18:56.778]         if (TRUE) {
  [21:18:56.778]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.778]         }
  [21:18:56.778]         else {
  [21:18:56.778]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.778]         }
  [21:18:56.778]         base::close(...future.stdout)
  [21:18:56.778]         ...future.stdout <- NULL
  [21:18:56.778]     }
  [21:18:56.778]     ...future.result$conditions <- ...future.conditions
  [21:18:56.778]     ...future.result
  [21:18:56.778] }
  [21:18:56.783] requestCore(): workers = 2
  [21:18:56.784] Poll #1 (0): usedCores() = 2, workers = 2
  [21:18:56.803] MulticoreFuture started
  [21:18:56.822] signalConditions() ...
  [21:18:56.823]  - include = 'immediateCondition'
  [21:18:56.823]  - exclude = 
  [21:18:56.823]  - resignal = FALSE
  [21:18:56.824]  - Number of conditions: 1
  [21:18:56.824] signalConditions() ... done
  [21:18:56.825] signalConditions() ...
  [21:18:56.825] plan(): Setting new future strategy stack:
  [21:18:56.825]  - include = 'immediateCondition'
  [21:18:56.825]  - exclude = 
  [21:18:56.826]  - resignal = FALSE
  [21:18:56.826]  - Number of conditions: 1
  [21:18:56.826] signalConditions() ... done
  [21:18:56.827] Future state: 'finished'
  [21:18:56.827] signalConditions() ...
  [21:18:56.828]  - include = 'condition'
  [21:18:56.828]  - exclude = 'immediateCondition'
  [21:18:56.828]  - resignal = TRUE
  [21:18:56.829]  - Number of conditions: 1
  [21:18:56.829]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.825] List of future strategies:
  [21:18:56.825] 1. sequential:
  [21:18:56.825]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.825]    - tweaked: FALSE
  [21:18:56.825]    - call: NULL
  [21:18:56.833] plan(): nbrOfWorkers() = 1
  [21:18:56.835] plan(): Setting new future strategy stack:
  [21:18:56.835] List of future strategies:
  [21:18:56.835] 1. multicore:
  [21:18:56.835]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.835]    - tweaked: FALSE
  [21:18:56.835]    - call: plan(strategy)
  [21:18:56.829] signalConditions() ... done
  [21:18:56.837] plan(): nbrOfWorkers() = 2
  Warning in get(var, envir = x, inherits = FALSE) :
    restarting interrupted promise evaluation
  [21:18:56.855] signalConditions() ...
  [21:18:56.856]  - include = 'immediateCondition'
  [21:18:56.856]  - exclude = 
  [21:18:56.856]  - resignal = FALSE
  [21:18:56.857]  - Number of conditions: 1
  [21:18:56.857] signalConditions() ... done
  [21:18:56.857] Future state: 'finished'
  [21:18:56.858] signalConditions() ...
  [21:18:56.858]  - include = 'condition'
  [21:18:56.858]  - exclude = 'immediateCondition'
  [21:18:56.859]  - resignal = TRUE
  [21:18:56.859]  - Number of conditions: 1
  [21:18:56.859]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.860] signalConditions() ... done
  Warning in get(var, envir = x, inherits = FALSE) :
    restarting interrupted promise evaluation
  [21:18:56.861] signalConditions() ...
  [21:18:56.861]  - include = 'immediateCondition'
  [21:18:56.861]  - exclude = 
  [21:18:56.862]  - resignal = FALSE
  [21:18:56.862]  - Number of conditions: 1
  [21:18:56.862] signalConditions() ... done
  [21:18:56.863] Future state: 'finished'
  [21:18:56.863] signalConditions() ...
  [21:18:56.863]  - include = 'condition'
  [21:18:56.864]  - exclude = 'immediateCondition'
  [21:18:56.864]  - resignal = TRUE
  [21:18:56.864]  - Number of conditions: 1
  [21:18:56.864]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.865] signalConditions() ... done
  ** Future evaluation with a poor-man's "progress bar"
  [21:18:56.866] getGlobalsAndPackages() ...
  [21:18:56.867] Searching for globals...
  [21:18:56.878] - globals found: [4] '{', 'cat', 'for', ':'
  [21:18:56.879] Searching for globals ... DONE
  [21:18:56.879] Resolving globals: FALSE
  [21:18:56.880] 
  [21:18:56.881] 
  [21:18:56.881] getGlobalsAndPackages() ... DONE
  [21:18:56.883] Packages needed by the future expression (n = 0): <none>
  [21:18:56.883] Packages needed by future strategies (n = 0): <none>
  [21:18:56.892] {
  [21:18:56.892]     {
  [21:18:56.892]         ...future.startTime <- base::Sys.time()
  [21:18:56.892]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.892]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.892]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.892]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.892]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.892]         {
  [21:18:56.892]             {
  [21:18:56.892]                 {
  [21:18:56.892]                   base::local({
  [21:18:56.892]                     has_future <- base::requireNamespace("future", 
  [21:18:56.892]                       quietly = TRUE)
  [21:18:56.892]                     version <- if (has_future) 
  [21:18:56.892]                       utils::packageVersion("future")
  [21:18:56.892]                     else NULL
  [21:18:56.892]                     if (!has_future || version < "1.8.0") {
  [21:18:56.892]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.892]                         "", base::R.version$version.string), 
  [21:18:56.892]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.892]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.892]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.892]                           "release", "version")], collapse = " "), 
  [21:18:56.892]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.892]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.892]                         info)
  [21:18:56.892]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.892]                       if (!has_future) {
  [21:18:56.892]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.892]                           info)
  [21:18:56.892]                       }
  [21:18:56.892]                       else {
  [21:18:56.892]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.892]                           info, version)
  [21:18:56.892]                       }
  [21:18:56.892]                       base::stop(msg)
  [21:18:56.892]                     }
  [21:18:56.892]                   })
  [21:18:56.892]                 }
  [21:18:56.892]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.892]                 base::options(mc.cores = 1L)
  [21:18:56.892]             }
  [21:18:56.892]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.892]         }
  [21:18:56.892]     }
  [21:18:56.892]     if (base::is.na(TRUE)) {
  [21:18:56.892]     }
  [21:18:56.892]     else {
  [21:18:56.892]         if (TRUE) {
  [21:18:56.892]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.892]                 open = "w")
  [21:18:56.892]         }
  [21:18:56.892]         else {
  [21:18:56.892]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.892]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.892]         }
  [21:18:56.892]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.892]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.892]             base::sink(type = "output", split = FALSE)
  [21:18:56.892]             base::close(...future.stdout)
  [21:18:56.892]         }, add = TRUE)
  [21:18:56.892]     }
  [21:18:56.892]     ...future.frame <- base::sys.nframe()
  [21:18:56.892]     ...future.conditions <- base::list()
  [21:18:56.892]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.892]     ...future.result <- base::tryCatch({
  [21:18:56.892]         base::withCallingHandlers({
  [21:18:56.892]             ...future.value <- base::withVisible(base::local({
  [21:18:56.892]                 cat("Processing: ")
  [21:18:56.892]                 for (ii in 1:10) {
  [21:18:56.892]                   cat(".")
  [21:18:56.892]                 }
  [21:18:56.892]                 cat(" [100%]\n")
  [21:18:56.892]                 4
  [21:18:56.892]             }))
  [21:18:56.892]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.892]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.892]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.892]                 version = "1.8")
  [21:18:56.892]         }, condition = base::local({
  [21:18:56.892]             c <- base::c
  [21:18:56.892]             inherits <- base::inherits
  [21:18:56.892]             invokeRestart <- base::invokeRestart
  [21:18:56.892]             length <- base::length
  [21:18:56.892]             list <- base::list
  [21:18:56.892]             seq.int <- base::seq.int
  [21:18:56.892]             signalCondition <- base::signalCondition
  [21:18:56.892]             sys.calls <- base::sys.calls
  [21:18:56.892]             Sys.time <- base::Sys.time
  [21:18:56.892]             `[[` <- base::`[[`
  [21:18:56.892]             `+` <- base::`+`
  [21:18:56.892]             `<<-` <- base::`<<-`
  [21:18:56.892]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.892]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.892]                   3L)]
  [21:18:56.892]             }
  [21:18:56.892]             function(cond) {
  [21:18:56.892]                 if (inherits(cond, "error")) {
  [21:18:56.892]                   sessionInformation <- function() {
  [21:18:56.892]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.892]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.892]                       search = base::search(), system = base::Sys.info())
  [21:18:56.892]                   }
  [21:18:56.892]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.892]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.892]                     cond$call), session = sessionInformation(), 
  [21:18:56.892]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.892]                   signalCondition(cond)
  [21:18:56.892]                 }
  [21:18:56.892]                 else if (inherits(cond, "condition")) {
  [21:18:56.892]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.892]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.892]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.892]                   if (!signal) {
  [21:18:56.892]                     muffleCondition <- function (cond) 
  [21:18:56.892]                     {
  [21:18:56.892]                       inherits <- base::inherits
  [21:18:56.892]                       invokeRestart <- base::invokeRestart
  [21:18:56.892]                       muffled <- FALSE
  [21:18:56.892]                       if (inherits(cond, "message")) {
  [21:18:56.892]                         invokeRestart("muffleMessage")
  [21:18:56.892]                         muffled <- TRUE
  [21:18:56.892]                       }
  [21:18:56.892]                       else if (inherits(cond, "warning")) {
  [21:18:56.892]                         invokeRestart("muffleWarning")
  [21:18:56.892]                         muffled <- TRUE
  [21:18:56.892]                       }
  [21:18:56.892]                       else if (inherits(cond, "condition")) {
  [21:18:56.892]                         computeRestarts <- base::computeRestarts
  [21:18:56.892]                         grepl <- base::grepl
  [21:18:56.892]                         is.null <- base::is.null
  [21:18:56.892]                         restarts <- computeRestarts(cond)
  [21:18:56.892]                         for (restart in restarts) {
  [21:18:56.892]                           name <- restart$name
  [21:18:56.892]                           if (is.null(name)) 
  [21:18:56.892]                             next
  [21:18:56.892]                           if (!grepl("^muffle", name)) 
  [21:18:56.892]                             next
  [21:18:56.892]                           invokeRestart(restart)
  [21:18:56.892]                           muffled <- TRUE
  [21:18:56.892]                           break
  [21:18:56.892]                         }
  [21:18:56.892]                       }
  [21:18:56.892]                       invisible(muffled)
  [21:18:56.892]                     }
  [21:18:56.892]                     muffleCondition(cond)
  [21:18:56.892]                   }
  [21:18:56.892]                 }
  [21:18:56.892]             }
  [21:18:56.892]         }))
  [21:18:56.892]     }, error = function(ex) {
  [21:18:56.892]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.892]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.892]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.892]     }, finally = {
  [21:18:56.892]         {
  [21:18:56.892]             {
  [21:18:56.892]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.892]             }
  [21:18:56.892]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.892]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.892]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.892]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.892]             {
  [21:18:56.892]                 if (substitute) 
  [21:18:56.892]                   expr <- substitute(expr)
  [21:18:56.892]                 if (is.function(workers)) 
  [21:18:56.892]                   workers <- workers()
  [21:18:56.892]                 workers <- as.integer(workers)
  [21:18:56.892]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.892]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.892]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.892]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.892]                     local = TRUE, label = label, ...))
  [21:18:56.892]                 }
  [21:18:56.892]                 oopts <- options(mc.cores = workers)
  [21:18:56.892]                 on.exit(options(oopts))
  [21:18:56.892]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.892]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.892]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.892]                   label = label, ...)
  [21:18:56.892]                 if (!future$lazy) 
  [21:18:56.892]                   future <- run(future)
  [21:18:56.892]                 invisible(future)
  [21:18:56.892]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.892]         }
  [21:18:56.892]         base::options(...future.oldOptions)
  [21:18:56.892]     })
  [21:18:56.892]     Sys.time
  [21:18:56.892]     if (base::is.na(TRUE)) {
  [21:18:56.892]     }
  [21:18:56.892]     else {
  [21:18:56.892]         base::sink(type = "output", split = FALSE)
  [21:18:56.892]         if (TRUE) {
  [21:18:56.892]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.892]         }
  [21:18:56.892]         else {
  [21:18:56.892]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.892]         }
  [21:18:56.892]         base::close(...future.stdout)
  [21:18:56.892]         ...future.stdout <- NULL
  [21:18:56.892]     }
  [21:18:56.892]     ...future.result$conditions <- ...future.conditions
  [21:18:56.892]     ...future.result
  [21:18:56.892] }
  [21:18:56.905] requestCore(): workers = 2
  [21:18:56.908] MulticoreFuture started
  ** Collecting results
  v1 = 1
  v2 = 2
  Warning in sprintf(...) : restarting interrupted promise evaluation
  [21:18:56.918] signalConditions() ...
  [21:18:56.919]  - include = 'immediateCondition'
  [21:18:56.919]  - exclude = 
  [21:18:56.920]  - resignal = FALSE
  [21:18:56.920]  - Number of conditions: 1
  [21:18:56.920] signalConditions() ... done
  [21:18:56.921] Future state: 'finished'
  [21:18:56.921] signalConditions() ...
  [21:18:56.921]  - include = 'condition'
  [21:18:56.922]  - exclude = 'immediateCondition'
  [21:18:56.922]  - resignal = TRUE
  [21:18:56.922]  - Number of conditions: 1
  [21:18:56.923]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:18:56.923] signalConditions() ... done
  v3: <simpleError> (as expect)
  [21:18:56.929] plan(): Setting new future strategy stack:
  [21:18:56.930] List of future strategies:
  [21:18:56.930] 1. sequential:
  [21:18:56.930]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.930]    - tweaked: FALSE
  [21:18:56.930]    - call: NULL
  [21:18:56.931] plan(): nbrOfWorkers() = 1
  [21:18:56.933] plan(): Setting new future strategy stack:
  [21:18:56.933] List of future strategies:
  [21:18:56.933] 1. multicore:
  [21:18:56.933]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.933]    - tweaked: FALSE
  [21:18:56.933]    - call: plan(strategy)
  [21:18:56.935] plan(): nbrOfWorkers() = 2
  Processing: .......... [100%]
  v4 = 4
  ** Left-to-right and right-to-left future assignments
  [21:18:56.938] getGlobalsAndPackages() ...
  [21:18:56.939] Searching for globals...
  [21:18:56.940] 
  [21:18:56.940] Searching for globals ... DONE
  [21:18:56.940] - globals: [0] <none>
  [21:18:56.941] getGlobalsAndPackages() ... DONE
  [21:18:56.943] Packages needed by the future expression (n = 0): <none>
  [21:18:56.944] Packages needed by future strategies (n = 0): <none>
  [21:18:56.949] {
  [21:18:56.949]     {
  [21:18:56.949]         ...future.startTime <- base::Sys.time()
  [21:18:56.949]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:56.949]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:56.949]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:56.949]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:56.949]             future.resolve.recursive = NULL, width = 80L)
  [21:18:56.949]         {
  [21:18:56.949]             {
  [21:18:56.949]                 {
  [21:18:56.949]                   base::local({
  [21:18:56.949]                     has_future <- base::requireNamespace("future", 
  [21:18:56.949]                       quietly = TRUE)
  [21:18:56.949]                     version <- if (has_future) 
  [21:18:56.949]                       utils::packageVersion("future")
  [21:18:56.949]                     else NULL
  [21:18:56.949]                     if (!has_future || version < "1.8.0") {
  [21:18:56.949]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:56.949]                         "", base::R.version$version.string), 
  [21:18:56.949]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:56.949]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:56.949]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:56.949]                           "release", "version")], collapse = " "), 
  [21:18:56.949]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:56.949]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:56.949]                         info)
  [21:18:56.949]                       info <- base::paste(info, collapse = "; ")
  [21:18:56.949]                       if (!has_future) {
  [21:18:56.949]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:56.949]                           info)
  [21:18:56.949]                       }
  [21:18:56.949]                       else {
  [21:18:56.949]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:56.949]                           info, version)
  [21:18:56.949]                       }
  [21:18:56.949]                       base::stop(msg)
  [21:18:56.949]                     }
  [21:18:56.949]                   })
  [21:18:56.949]                 }
  [21:18:56.949]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:56.949]                 base::options(mc.cores = 1L)
  [21:18:56.949]             }
  [21:18:56.949]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:56.949]         }
  [21:18:56.949]     }
  [21:18:56.949]     if (base::is.na(TRUE)) {
  [21:18:56.949]     }
  [21:18:56.949]     else {
  [21:18:56.949]         if (TRUE) {
  [21:18:56.949]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:56.949]                 open = "w")
  [21:18:56.949]         }
  [21:18:56.949]         else {
  [21:18:56.949]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:56.949]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:56.949]         }
  [21:18:56.949]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:56.949]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:56.949]             base::sink(type = "output", split = FALSE)
  [21:18:56.949]             base::close(...future.stdout)
  [21:18:56.949]         }, add = TRUE)
  [21:18:56.949]     }
  [21:18:56.949]     ...future.frame <- base::sys.nframe()
  [21:18:56.949]     ...future.conditions <- base::list()
  [21:18:56.949]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:56.949]     ...future.result <- base::tryCatch({
  [21:18:56.949]         base::withCallingHandlers({
  [21:18:56.949]             ...future.value <- base::withVisible(base::local(1))
  [21:18:56.949]             future::FutureResult(value = ...future.value$value, 
  [21:18:56.949]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.949]                   ...future.rng), started = ...future.startTime, 
  [21:18:56.949]                 version = "1.8")
  [21:18:56.949]         }, condition = base::local({
  [21:18:56.949]             c <- base::c
  [21:18:56.949]             inherits <- base::inherits
  [21:18:56.949]             invokeRestart <- base::invokeRestart
  [21:18:56.949]             length <- base::length
  [21:18:56.949]             list <- base::list
  [21:18:56.949]             seq.int <- base::seq.int
  [21:18:56.949]             signalCondition <- base::signalCondition
  [21:18:56.949]             sys.calls <- base::sys.calls
  [21:18:56.949]             Sys.time <- base::Sys.time
  [21:18:56.949]             `[[` <- base::`[[`
  [21:18:56.949]             `+` <- base::`+`
  [21:18:56.949]             `<<-` <- base::`<<-`
  [21:18:56.949]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:56.949]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:56.949]                   3L)]
  [21:18:56.949]             }
  [21:18:56.949]             function(cond) {
  [21:18:56.949]                 if (inherits(cond, "error")) {
  [21:18:56.949]                   sessionInformation <- function() {
  [21:18:56.949]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:56.949]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:56.949]                       search = base::search(), system = base::Sys.info())
  [21:18:56.949]                   }
  [21:18:56.949]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.949]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:56.949]                     cond$call), session = sessionInformation(), 
  [21:18:56.949]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:56.949]                   signalCondition(cond)
  [21:18:56.949]                 }
  [21:18:56.949]                 else if (inherits(cond, "condition")) {
  [21:18:56.949]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:56.949]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:56.949]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:56.949]                   if (!signal) {
  [21:18:56.949]                     muffleCondition <- function (cond) 
  [21:18:56.949]                     {
  [21:18:56.949]                       inherits <- base::inherits
  [21:18:56.949]                       invokeRestart <- base::invokeRestart
  [21:18:56.949]                       muffled <- FALSE
  [21:18:56.949]                       if (inherits(cond, "message")) {
  [21:18:56.949]                         invokeRestart("muffleMessage")
  [21:18:56.949]                         muffled <- TRUE
  [21:18:56.949]                       }
  [21:18:56.949]                       else if (inherits(cond, "warning")) {
  [21:18:56.949]                         invokeRestart("muffleWarning")
  [21:18:56.949]                         muffled <- TRUE
  [21:18:56.949]                       }
  [21:18:56.949]                       else if (inherits(cond, "condition")) {
  [21:18:56.949]                         computeRestarts <- base::computeRestarts
  [21:18:56.949]                         grepl <- base::grepl
  [21:18:56.949]                         is.null <- base::is.null
  [21:18:56.949]                         restarts <- computeRestarts(cond)
  [21:18:56.949]                         for (restart in restarts) {
  [21:18:56.949]                           name <- restart$name
  [21:18:56.949]                           if (is.null(name)) 
  [21:18:56.949]                             next
  [21:18:56.949]                           if (!grepl("^muffle", name)) 
  [21:18:56.949]                             next
  [21:18:56.949]                           invokeRestart(restart)
  [21:18:56.949]                           muffled <- TRUE
  [21:18:56.949]                           break
  [21:18:56.949]                         }
  [21:18:56.949]                       }
  [21:18:56.949]                       invisible(muffled)
  [21:18:56.949]                     }
  [21:18:56.949]                     muffleCondition(cond)
  [21:18:56.949]                   }
  [21:18:56.949]                 }
  [21:18:56.949]             }
  [21:18:56.949]         }))
  [21:18:56.949]     }, error = function(ex) {
  [21:18:56.949]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:56.949]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:56.949]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:56.949]     }, finally = {
  [21:18:56.949]         {
  [21:18:56.949]             {
  [21:18:56.949]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:56.949]             }
  [21:18:56.949]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:56.949]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:56.949]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:56.949]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:56.949]             {
  [21:18:56.949]                 if (substitute) 
  [21:18:56.949]                   expr <- substitute(expr)
  [21:18:56.949]                 if (is.function(workers)) 
  [21:18:56.949]                   workers <- workers()
  [21:18:56.949]                 workers <- as.integer(workers)
  [21:18:56.949]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:56.949]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:56.949]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:56.949]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:56.949]                     local = TRUE, label = label, ...))
  [21:18:56.949]                 }
  [21:18:56.949]                 oopts <- options(mc.cores = workers)
  [21:18:56.949]                 on.exit(options(oopts))
  [21:18:56.949]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:56.949]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:56.949]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:56.949]                   label = label, ...)
  [21:18:56.949]                 if (!future$lazy) 
  [21:18:56.949]                   future <- run(future)
  [21:18:56.949]                 invisible(future)
  [21:18:56.949]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:56.949]         }
  [21:18:56.949]         base::options(...future.oldOptions)
  [21:18:56.949]     })
  [21:18:56.949]     Sys.time
  [21:18:56.949]     if (base::is.na(TRUE)) {
  [21:18:56.949]     }
  [21:18:56.949]     else {
  [21:18:56.949]         base::sink(type = "output", split = FALSE)
  [21:18:56.949]         if (TRUE) {
  [21:18:56.949]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:56.949]         }
  [21:18:56.949]         else {
  [21:18:56.949]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:56.949]         }
  [21:18:56.949]         base::close(...future.stdout)
  [21:18:56.949]         ...future.stdout <- NULL
  [21:18:56.949]     }
  [21:18:56.949]     ...future.result$conditions <- ...future.conditions
  [21:18:56.949]     ...future.result
  [21:18:56.949] }
  [21:18:56.961] requestCore(): workers = 2
  [21:18:56.964] MulticoreFuture started
  [21:18:56.977] plan(): Setting new future strategy stack:
  [21:18:56.978] List of future strategies:
  [21:18:56.978] 1. sequential:
  [21:18:56.978]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:56.978]    - tweaked: FALSE
  [21:18:56.978]    - call: NULL
  [21:18:56.979] plan(): nbrOfWorkers() = 1
  [21:18:56.981] plan(): Setting new future strategy stack:
  [21:18:56.981] List of future strategies:
  [21:18:56.981] 1. multicore:
  [21:18:56.981]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:56.981]    - tweaked: FALSE
  [21:18:56.981]    - call: plan(strategy)
  [21:18:56.983] plan(): nbrOfWorkers() = 2
  c = 1
  [21:18:56.987] getGlobalsAndPackages() ...
  [21:18:56.987] Searching for globals...
  [21:18:56.988] 
  [21:18:56.989] Searching for globals ... DONE
  [21:18:56.989] - globals: [0] <none>
  [21:18:56.989] getGlobalsAndPackages() ... DONE
  [21:18:56.991] Packages needed by the future expression (n = 0): <none>
  [21:18:56.992] Packages needed by future strategies (n = 0): <none>
  [21:18:57.001] {
  [21:18:57.001]     {
  [21:18:57.001]         ...future.startTime <- base::Sys.time()
  [21:18:57.001]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:57.001]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:57.001]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:57.001]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:57.001]             future.resolve.recursive = NULL, width = 80L)
  [21:18:57.001]         {
  [21:18:57.001]             {
  [21:18:57.001]                 {
  [21:18:57.001]                   base::local({
  [21:18:57.001]                     has_future <- base::requireNamespace("future", 
  [21:18:57.001]                       quietly = TRUE)
  [21:18:57.001]                     version <- if (has_future) 
  [21:18:57.001]                       utils::packageVersion("future")
  [21:18:57.001]                     else NULL
  [21:18:57.001]                     if (!has_future || version < "1.8.0") {
  [21:18:57.001]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:57.001]                         "", base::R.version$version.string), 
  [21:18:57.001]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:57.001]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:57.001]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:57.001]                           "release", "version")], collapse = " "), 
  [21:18:57.001]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:57.001]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:57.001]                         info)
  [21:18:57.001]                       info <- base::paste(info, collapse = "; ")
  [21:18:57.001]                       if (!has_future) {
  [21:18:57.001]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:57.001]                           info)
  [21:18:57.001]                       }
  [21:18:57.001]                       else {
  [21:18:57.001]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:57.001]                           info, version)
  [21:18:57.001]                       }
  [21:18:57.001]                       base::stop(msg)
  [21:18:57.001]                     }
  [21:18:57.001]                   })
  [21:18:57.001]                 }
  [21:18:57.001]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:57.001]                 base::options(mc.cores = 1L)
  [21:18:57.001]             }
  [21:18:57.001]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:57.001]         }
  [21:18:57.001]     }
  [21:18:57.001]     if (base::is.na(TRUE)) {
  [21:18:57.001]     }
  [21:18:57.001]     else {
  [21:18:57.001]         if (TRUE) {
  [21:18:57.001]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:57.001]                 open = "w")
  [21:18:57.001]         }
  [21:18:57.001]         else {
  [21:18:57.001]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:57.001]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:57.001]         }
  [21:18:57.001]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:57.001]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:57.001]             base::sink(type = "output", split = FALSE)
  [21:18:57.001]             base::close(...future.stdout)
  [21:18:57.001]         }, add = TRUE)
  [21:18:57.001]     }
  [21:18:57.001]     ...future.frame <- base::sys.nframe()
  [21:18:57.001]     ...future.conditions <- base::list()
  [21:18:57.001]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:57.001]     ...future.result <- base::tryCatch({
  [21:18:57.001]         base::withCallingHandlers({
  [21:18:57.001]             ...future.value <- base::withVisible(base::local(1))
  [21:18:57.001]             future::FutureResult(value = ...future.value$value, 
  [21:18:57.001]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.001]                   ...future.rng), started = ...future.startTime, 
  [21:18:57.001]                 version = "1.8")
  [21:18:57.001]         }, condition = base::local({
  [21:18:57.001]             c <- base::c
  [21:18:57.001]             inherits <- base::inherits
  [21:18:57.001]             invokeRestart <- base::invokeRestart
  [21:18:57.001]             length <- base::length
  [21:18:57.001]             list <- base::list
  [21:18:57.001]             seq.int <- base::seq.int
  [21:18:57.001]             signalCondition <- base::signalCondition
  [21:18:57.001]             sys.calls <- base::sys.calls
  [21:18:57.001]             Sys.time <- base::Sys.time
  [21:18:57.001]             `[[` <- base::`[[`
  [21:18:57.001]             `+` <- base::`+`
  [21:18:57.001]             `<<-` <- base::`<<-`
  [21:18:57.001]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:57.001]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:57.001]                   3L)]
  [21:18:57.001]             }
  [21:18:57.001]             function(cond) {
  [21:18:57.001]                 if (inherits(cond, "error")) {
  [21:18:57.001]                   sessionInformation <- function() {
  [21:18:57.001]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:57.001]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:57.001]                       search = base::search(), system = base::Sys.info())
  [21:18:57.001]                   }
  [21:18:57.001]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.001]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:57.001]                     cond$call), session = sessionInformation(), 
  [21:18:57.001]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:57.001]                   signalCondition(cond)
  [21:18:57.001]                 }
  [21:18:57.001]                 else if (inherits(cond, "condition")) {
  [21:18:57.001]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:57.001]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.001]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:57.001]                   if (!signal) {
  [21:18:57.001]                     muffleCondition <- function (cond) 
  [21:18:57.001]                     {
  [21:18:57.001]                       inherits <- base::inherits
  [21:18:57.001]                       invokeRestart <- base::invokeRestart
  [21:18:57.001]                       muffled <- FALSE
  [21:18:57.001]                       if (inherits(cond, "message")) {
  [21:18:57.001]                         invokeRestart("muffleMessage")
  [21:18:57.001]                         muffled <- TRUE
  [21:18:57.001]                       }
  [21:18:57.001]                       else if (inherits(cond, "warning")) {
  [21:18:57.001]                         invokeRestart("muffleWarning")
  [21:18:57.001]                         muffled <- TRUE
  [21:18:57.001]                       }
  [21:18:57.001]                       else if (inherits(cond, "condition")) {
  [21:18:57.001]                         computeRestarts <- base::computeRestarts
  [21:18:57.001]                         grepl <- base::grepl
  [21:18:57.001]                         is.null <- base::is.null
  [21:18:57.001]                         restarts <- computeRestarts(cond)
  [21:18:57.001]                         for (restart in restarts) {
  [21:18:57.001]                           name <- restart$name
  [21:18:57.001]                           if (is.null(name)) 
  [21:18:57.001]                             next
  [21:18:57.001]                           if (!grepl("^muffle", name)) 
  [21:18:57.001]                             next
  [21:18:57.001]                           invokeRestart(restart)
  [21:18:57.001]                           muffled <- TRUE
  [21:18:57.001]                           break
  [21:18:57.001]                         }
  [21:18:57.001]                       }
  [21:18:57.001]                       invisible(muffled)
  [21:18:57.001]                     }
  [21:18:57.001]                     muffleCondition(cond)
  [21:18:57.001]                   }
  [21:18:57.001]                 }
  [21:18:57.001]             }
  [21:18:57.001]         }))
  [21:18:57.001]     }, error = function(ex) {
  [21:18:57.001]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:57.001]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.001]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:57.001]     }, finally = {
  [21:18:57.001]         {
  [21:18:57.001]             {
  [21:18:57.001]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:57.001]             }
  [21:18:57.001]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:57.001]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:57.001]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:57.001]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:57.001]             {
  [21:18:57.001]                 if (substitute) 
  [21:18:57.001]                   expr <- substitute(expr)
  [21:18:57.001]                 if (is.function(workers)) 
  [21:18:57.001]                   workers <- workers()
  [21:18:57.001]                 workers <- as.integer(workers)
  [21:18:57.001]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:57.001]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:57.001]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:57.001]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:57.001]                     local = TRUE, label = label, ...))
  [21:18:57.001]                 }
  [21:18:57.001]                 oopts <- options(mc.cores = workers)
  [21:18:57.001]                 on.exit(options(oopts))
  [21:18:57.001]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:57.001]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:57.001]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:57.001]                   label = label, ...)
  [21:18:57.001]                 if (!future$lazy) 
  [21:18:57.001]                   future <- run(future)
  [21:18:57.001]                 invisible(future)
  [21:18:57.001]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:57.001]         }
  [21:18:57.001]         base::options(...future.oldOptions)
  [21:18:57.001]     })
  [21:18:57.001]     Sys.time
  [21:18:57.001]     if (base::is.na(TRUE)) {
  [21:18:57.001]     }
  [21:18:57.001]     else {
  [21:18:57.001]         base::sink(type = "output", split = FALSE)
  [21:18:57.001]         if (TRUE) {
  [21:18:57.001]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:57.001]         }
  [21:18:57.001]         else {
  [21:18:57.001]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:57.001]         }
  [21:18:57.001]         base::close(...future.stdout)
  [21:18:57.001]         ...future.stdout <- NULL
  [21:18:57.001]     }
  [21:18:57.001]     ...future.result$conditions <- ...future.conditions
  [21:18:57.001]     ...future.result
  [21:18:57.001] }
  [21:18:57.022] requestCore(): workers = 2
  [21:18:57.025] MulticoreFuture started
  [21:18:57.049] plan(): Setting new future strategy stack:
  [21:18:57.050] List of future strategies:
  [21:18:57.050] 1. sequential:
  [21:18:57.050]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.050]    - tweaked: FALSE
  [21:18:57.050]    - call: NULL
  [21:18:57.051] plan(): nbrOfWorkers() = 1
  [21:18:57.053] plan(): Setting new future strategy stack:
  [21:18:57.054] List of future strategies:
  [21:18:57.054] 1. multicore:
  [21:18:57.054]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:57.054]    - tweaked: FALSE
  [21:18:57.054]    - call: plan(strategy)
  [21:18:57.056] plan(): nbrOfWorkers() = 2
  d = 1
  ** Nested future assignments
  [21:18:57.059] getGlobalsAndPackages() ...
  [21:18:57.060] Searching for globals...
  [21:18:57.066] - globals found: [5] '{', '<-', '%<-%', '%->%', '+'
  [21:18:57.066] Searching for globals ... DONE
  [21:18:57.066] Resolving globals: FALSE
  [21:18:57.068] 
  [21:18:57.068] - packages: [1] 'future'
  [21:18:57.069] getGlobalsAndPackages() ... DONE
  [21:18:57.087] Packages needed by the future expression (n = 0): <none>
  [21:18:57.088] Packages needed by future strategies (n = 0): <none>
  [21:18:57.093] {
  [21:18:57.093]     {
  [21:18:57.093]         ...future.startTime <- base::Sys.time()
  [21:18:57.093]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:57.093]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:57.093]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:57.093]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:57.093]             future.resolve.recursive = NULL, width = 80L)
  [21:18:57.093]         {
  [21:18:57.093]             {
  [21:18:57.093]                 {
  [21:18:57.093]                   base::local({
  [21:18:57.093]                     has_future <- base::requireNamespace("future", 
  [21:18:57.093]                       quietly = TRUE)
  [21:18:57.093]                     version <- if (has_future) 
  [21:18:57.093]                       utils::packageVersion("future")
  [21:18:57.093]                     else NULL
  [21:18:57.093]                     if (!has_future || version < "1.8.0") {
  [21:18:57.093]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:57.093]                         "", base::R.version$version.string), 
  [21:18:57.093]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:57.093]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:57.093]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:57.093]                           "release", "version")], collapse = " "), 
  [21:18:57.093]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:57.093]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:57.093]                         info)
  [21:18:57.093]                       info <- base::paste(info, collapse = "; ")
  [21:18:57.093]                       if (!has_future) {
  [21:18:57.093]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:57.093]                           info)
  [21:18:57.093]                       }
  [21:18:57.093]                       else {
  [21:18:57.093]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:57.093]                           info, version)
  [21:18:57.093]                       }
  [21:18:57.093]                       base::stop(msg)
  [21:18:57.093]                     }
  [21:18:57.093]                   })
  [21:18:57.093]                 }
  [21:18:57.093]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:57.093]                 base::options(mc.cores = 1L)
  [21:18:57.093]             }
  [21:18:57.093]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:57.093]         }
  [21:18:57.093]     }
  [21:18:57.093]     if (base::is.na(TRUE)) {
  [21:18:57.093]     }
  [21:18:57.093]     else {
  [21:18:57.093]         if (TRUE) {
  [21:18:57.093]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:57.093]                 open = "w")
  [21:18:57.093]         }
  [21:18:57.093]         else {
  [21:18:57.093]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:57.093]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:57.093]         }
  [21:18:57.093]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:57.093]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:57.093]             base::sink(type = "output", split = FALSE)
  [21:18:57.093]             base::close(...future.stdout)
  [21:18:57.093]         }, add = TRUE)
  [21:18:57.093]     }
  [21:18:57.093]     ...future.frame <- base::sys.nframe()
  [21:18:57.093]     ...future.conditions <- base::list()
  [21:18:57.093]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:57.093]     ...future.result <- base::tryCatch({
  [21:18:57.093]         base::withCallingHandlers({
  [21:18:57.093]             ...future.value <- base::withVisible(base::local({
  [21:18:57.093]                 b <- 1
  [21:18:57.093]                 c %<-% 2
  [21:18:57.093]                 d <- 3
  [21:18:57.093]                 4 %->% e
  [21:18:57.093]                 b + c + d + e
  [21:18:57.093]             }))
  [21:18:57.093]             future::FutureResult(value = ...future.value$value, 
  [21:18:57.093]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.093]                   ...future.rng), started = ...future.startTime, 
  [21:18:57.093]                 version = "1.8")
  [21:18:57.093]         }, condition = base::local({
  [21:18:57.093]             c <- base::c
  [21:18:57.093]             inherits <- base::inherits
  [21:18:57.093]             invokeRestart <- base::invokeRestart
  [21:18:57.093]             length <- base::length
  [21:18:57.093]             list <- base::list
  [21:18:57.093]             seq.int <- base::seq.int
  [21:18:57.093]             signalCondition <- base::signalCondition
  [21:18:57.093]             sys.calls <- base::sys.calls
  [21:18:57.093]             Sys.time <- base::Sys.time
  [21:18:57.093]             `[[` <- base::`[[`
  [21:18:57.093]             `+` <- base::`+`
  [21:18:57.093]             `<<-` <- base::`<<-`
  [21:18:57.093]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:57.093]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:57.093]                   3L)]
  [21:18:57.093]             }
  [21:18:57.093]             function(cond) {
  [21:18:57.093]                 if (inherits(cond, "error")) {
  [21:18:57.093]                   sessionInformation <- function() {
  [21:18:57.093]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:57.093]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:57.093]                       search = base::search(), system = base::Sys.info())
  [21:18:57.093]                   }
  [21:18:57.093]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.093]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:57.093]                     cond$call), session = sessionInformation(), 
  [21:18:57.093]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:57.093]                   signalCondition(cond)
  [21:18:57.093]                 }
  [21:18:57.093]                 else if (inherits(cond, "condition")) {
  [21:18:57.093]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:57.093]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.093]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:57.093]                   if (!signal) {
  [21:18:57.093]                     muffleCondition <- function (cond) 
  [21:18:57.093]                     {
  [21:18:57.093]                       inherits <- base::inherits
  [21:18:57.093]                       invokeRestart <- base::invokeRestart
  [21:18:57.093]                       muffled <- FALSE
  [21:18:57.093]                       if (inherits(cond, "message")) {
  [21:18:57.093]                         invokeRestart("muffleMessage")
  [21:18:57.093]                         muffled <- TRUE
  [21:18:57.093]                       }
  [21:18:57.093]                       else if (inherits(cond, "warning")) {
  [21:18:57.093]                         invokeRestart("muffleWarning")
  [21:18:57.093]                         muffled <- TRUE
  [21:18:57.093]                       }
  [21:18:57.093]                       else if (inherits(cond, "condition")) {
  [21:18:57.093]                         computeRestarts <- base::computeRestarts
  [21:18:57.093]                         grepl <- base::grepl
  [21:18:57.093]                         is.null <- base::is.null
  [21:18:57.093]                         restarts <- computeRestarts(cond)
  [21:18:57.093]                         for (restart in restarts) {
  [21:18:57.093]                           name <- restart$name
  [21:18:57.093]                           if (is.null(name)) 
  [21:18:57.093]                             next
  [21:18:57.093]                           if (!grepl("^muffle", name)) 
  [21:18:57.093]                             next
  [21:18:57.093]                           invokeRestart(restart)
  [21:18:57.093]                           muffled <- TRUE
  [21:18:57.093]                           break
  [21:18:57.093]                         }
  [21:18:57.093]                       }
  [21:18:57.093]                       invisible(muffled)
  [21:18:57.093]                     }
  [21:18:57.093]                     muffleCondition(cond)
  [21:18:57.093]                   }
  [21:18:57.093]                 }
  [21:18:57.093]             }
  [21:18:57.093]         }))
  [21:18:57.093]     }, error = function(ex) {
  [21:18:57.093]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:57.093]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.093]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:57.093]     }, finally = {
  [21:18:57.093]         {
  [21:18:57.093]             {
  [21:18:57.093]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:57.093]             }
  [21:18:57.093]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:57.093]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:57.093]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:57.093]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:57.093]             {
  [21:18:57.093]                 if (substitute) 
  [21:18:57.093]                   expr <- substitute(expr)
  [21:18:57.093]                 if (is.function(workers)) 
  [21:18:57.093]                   workers <- workers()
  [21:18:57.093]                 workers <- as.integer(workers)
  [21:18:57.093]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:57.093]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:57.093]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:57.093]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:57.093]                     local = TRUE, label = label, ...))
  [21:18:57.093]                 }
  [21:18:57.093]                 oopts <- options(mc.cores = workers)
  [21:18:57.093]                 on.exit(options(oopts))
  [21:18:57.093]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:57.093]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:57.093]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:57.093]                   label = label, ...)
  [21:18:57.093]                 if (!future$lazy) 
  [21:18:57.093]                   future <- run(future)
  [21:18:57.093]                 invisible(future)
  [21:18:57.093]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:57.093]         }
  [21:18:57.093]         base::options(...future.oldOptions)
  [21:18:57.093]     })
  [21:18:57.093]     Sys.time
  [21:18:57.093]     if (base::is.na(TRUE)) {
  [21:18:57.093]     }
  [21:18:57.093]     else {
  [21:18:57.093]         base::sink(type = "output", split = FALSE)
  [21:18:57.093]         if (TRUE) {
  [21:18:57.093]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:57.093]         }
  [21:18:57.093]         else {
  [21:18:57.093]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:57.093]         }
  [21:18:57.093]         base::close(...future.stdout)
  [21:18:57.093]         ...future.stdout <- NULL
  [21:18:57.093]     }
  [21:18:57.093]     ...future.result$conditions <- ...future.conditions
  [21:18:57.093]     ...future.result
  [21:18:57.093] }
  [21:18:57.097] requestCore(): workers = 2
  [21:18:57.101] MulticoreFuture started
  [21:18:57.118] plan(): Setting new future strategy stack:
  [21:18:57.118] List of future strategies:
  [21:18:57.118] 1. sequential:
  [21:18:57.118]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.118]    - tweaked: FALSE
  [21:18:57.118]    - call: NULL
  [21:18:57.130] plan(): nbrOfWorkers() = 1
  [21:18:57.255] plan(): Setting new future strategy stack:
  [21:18:57.256] List of future strategies:
  [21:18:57.256] 1. multicore:
  [21:18:57.256]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:57.256]    - tweaked: FALSE
  [21:18:57.256]    - call: plan(strategy)
  [21:18:57.258] plan(): nbrOfWorkers() = 2
  [21:18:57.259] signalConditions() ...
  [21:18:57.260]  - include = 'immediateCondition'
  [21:18:57.260]  - exclude = 
  [21:18:57.260]  - resignal = FALSE
  [21:18:57.261]  - Number of conditions: 32
  [21:18:57.261] signalConditions() ... done
  [21:18:57.262] signalConditions() ...
  [21:18:57.262]  - include = 'immediateCondition'
  [21:18:57.262]  - exclude = 
  [21:18:57.263]  - resignal = FALSE
  [21:18:57.263]  - Number of conditions: 32
  [21:18:57.263] signalConditions() ... done
  [21:18:57.264] Future state: 'finished'
  [21:18:57.264] signalConditions() ...
  [21:18:57.264]  - include = 'condition'
  [21:18:57.264]  - exclude = 'immediateCondition'
  [21:18:57.265]  - resignal = TRUE
  [21:18:57.265]  - Number of conditions: 32
  [21:18:57.265]  - Condition #1: 'simpleMessage', 'message', 'condition'
  [21:18:57.132] getGlobalsAndPackages() ...
  [21:18:57.266]  - Condition #2: 'simpleMessage', 'message', 'condition'
  [21:18:57.133] Searching for globals...
  [21:18:57.266]  - Condition #3: 'simpleMessage', 'message', 'condition'
  [21:18:57.134] 
  [21:18:57.266]  - Condition #4: 'simpleMessage', 'message', 'condition'
  [21:18:57.135] Searching for globals ... DONE
  [21:18:57.267]  - Condition #5: 'simpleMessage', 'message', 'condition'
  [21:18:57.136] - globals: [0] <none>
  [21:18:57.267]  - Condition #6: 'simpleMessage', 'message', 'condition'
  [21:18:57.136] getGlobalsAndPackages() ... DONE
  [21:18:57.268]  - Condition #7: 'simpleMessage', 'message', 'condition'
  [21:18:57.148] Packages needed by the future expression (n = 0): <none>
  [21:18:57.268]  - Condition #8: 'simpleMessage', 'message', 'condition'
  [21:18:57.149] Packages needed by future strategies (n = 0): <none>
  [21:18:57.268]  - Condition #9: 'simpleMessage', 'message', 'condition'
  [21:18:57.153] {
  [21:18:57.153]     {
  [21:18:57.153]         ...future.startTime <- base::Sys.time()
  [21:18:57.153]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:57.153]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:57.153]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:57.153]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:57.153]             future.resolve.recursive = NULL, width = 80L)
  [21:18:57.153]         {
  [21:18:57.153]             {
  [21:18:57.153]                 base::local({
  [21:18:57.153]                   has_future <- base::requireNamespace("future", 
  [21:18:57.153]                     quietly = TRUE)
  [21:18:57.153]                   version <- if (has_future) 
  [21:18:57.153]                     utils::packageVersion("future")
  [21:18:57.153]                   else NULL
  [21:18:57.153]                   if (!has_future || version < "1.8.0") {
  [21:18:57.153]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:57.153]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:57.153]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:57.153]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:57.153]                         "release", "version")], collapse = " "), 
  [21:18:57.153]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:57.153]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:57.153]                       info)
  [21:18:57.153]                     info <- base::paste(info, collapse = "; ")
  [21:18:57.153]                     if (!has_future) {
  [21:18:57.153]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:57.153]                         info)
  [21:18:57.153]                     }
  [21:18:57.153]                     else {
  [21:18:57.153]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:57.153]                         info, version)
  [21:18:57.153]                     }
  [21:18:57.153]                     base::stop(msg)
  [21:18:57.153]                   }
  [21:18:57.153]                 })
  [21:18:57.153]             }
  [21:18:57.153]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:57.153]         }
  [21:18:57.153]     }
  [21:18:57.153]     if (base::is.na(TRUE)) {
  [21:18:57.153]     }
  [21:18:57.153]     else {
  [21:18:57.153]         if (TRUE) {
  [21:18:57.153]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:57.153]                 open = "w")
  [21:18:57.153]         }
  [21:18:57.153]         else {
  [21:18:57.153]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:57.153]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:57.153]         }
  [21:18:57.153]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:57.153]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:57.153]             base::sink(type = "output", split = FALSE)
  [21:18:57.153]             base::close(...future.stdout)
  [21:18:57.153]         }, add = TRUE)
  [21:18:57.153]     }
  [21:18:57.153]     ...future.frame <- base::sys.nframe()
  [21:18:57.153]     ...future.conditions <- base::list()
  [21:18:57.153]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:57.153]     ...future.result <- base::tryCatch({
  [21:18:57.153]         base::withCallingHandlers({
  [21:18:57.153]             ...future.value <- base::withVisible(base::local(2))
  [21:18:57.153]             future::FutureResult(value = ...future.value$value, 
  [21:18:57.153]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.153]                   ...future.rng), started = ...future.startTime, 
  [21:18:57.153]                 version = "1.8")
  [21:18:57.153]         }, condition = base::local({
  [21:18:57.153]             c <- base::c
  [21:18:57.153]             inherits <- base::inherits
  [21:18:57.153]             invokeRestart <- base::invokeRestart
  [21:18:57.153]             length <- base::length
  [21:18:57.153]             list <- base::list
  [21:18:57.153]             seq.int <- base::seq.int
  [21:18:57.153]             signalCondition <- base::signalCondition
  [21:18:57.153]             sys.calls <- base::sys.calls
  [21:18:57.153]             Sys.time <- base::Sys.time
  [21:18:57.153]             `[[` <- base::`[[`
  [21:18:57.153]             `+` <- base::`+`
  [21:18:57.153]             `<<-` <- base::`<<-`
  [21:18:57.153]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:57.153]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:57.153]                   3L)]
  [21:18:57.153]             }
  [21:18:57.153]             function(cond) {
  [21:18:57.153]                 if (inherits(cond, "error")) {
  [21:18:57.153]                   sessionInformation <- function() {
  [21:18:57.153]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:57.153]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:57.153]                       search = base::search(), system = base::Sys.info())
  [21:18:57.153]                   }
  [21:18:57.153]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.153]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:57.153]                     cond$call), session = sessionInformation(), 
  [21:18:57.153]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:57.153]                   signalCondition(cond)
  [21:18:57.153]                 }
  [21:18:57.153]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:57.153]                 ))) {
  [21:18:57.153]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:57.153]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.153]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:57.153]                   if (!signal) {
  [21:18:57.153]                     muffleCondition <- function (cond) 
  [21:18:57.153]                     {
  [21:18:57.153]                       inherits <- base::inherits
  [21:18:57.153]                       invokeRestart <- base::invokeRestart
  [21:18:57.153]                       muffled <- FALSE
  [21:18:57.153]                       if (inherits(cond, "message")) {
  [21:18:57.153]                         invokeRestart("muffleMessage")
  [21:18:57.153]                         muffled <- TRUE
  [21:18:57.153]                       }
  [21:18:57.153]                       else if (inherits(cond, "warning")) {
  [21:18:57.153]                         invokeRestart("muffleWarning")
  [21:18:57.153]                         muffled <- TRUE
  [21:18:57.153]                       }
  [21:18:57.153]                       else if (inherits(cond, "condition")) {
  [21:18:57.153]                         computeRestarts <- base::computeRestarts
  [21:18:57.153]                         grepl <- base::grepl
  [21:18:57.153]                         is.null <- base::is.null
  [21:18:57.153]                         restarts <- computeRestarts(cond)
  [21:18:57.153]                         for (restart in restarts) {
  [21:18:57.153]                           name <- restart$name
  [21:18:57.153]                           if (is.null(name)) 
  [21:18:57.153]                             next
  [21:18:57.153]                           if (!grepl("^muffle", name)) 
  [21:18:57.153]                             next
  [21:18:57.153]                           invokeRestart(restart)
  [21:18:57.153]                           muffled <- TRUE
  [21:18:57.153]                           break
  [21:18:57.153]                         }
  [21:18:57.153]                       }
  [21:18:57.153]                       invisible(muffled)
  [21:18:57.153]                     }
  [21:18:57.153]                     muffleCondition(cond)
  [21:18:57.153]                   }
  [21:18:57.153]                 }
  [21:18:57.153]             }
  [21:18:57.153]         }))
  [21:18:57.153]     }, error = function(ex) {
  [21:18:57.153]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:57.153]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.153]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:57.153]     }, finally = {
  [21:18:57.153]         {
  [21:18:57.153]             NULL
  [21:18:57.153]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:57.153]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:57.153]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:57.153]                 label = NULL, ...) 
  [21:18:57.153]             {
  [21:18:57.153]                 if (substitute) 
  [21:18:57.153]                   expr <- substitute(expr)
  [21:18:57.153]                 local <- as.logical(local)
  [21:18:57.153]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:57.153]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:57.153]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:57.153]                   label = label, ...)
  [21:18:57.153]                 if (!future$lazy) 
  [21:18:57.153]                   future <- run(future)
  [21:18:57.153]                 invisible(future)
  [21:18:57.153]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:57.153]         }
  [21:18:57.153]         base::options(...future.oldOptions)
  [21:18:57.153]     })
  [21:18:57.153]     Sys.time
  [21:18:57.153]     if (base::is.na(TRUE)) {
  [21:18:57.153]     }
  [21:18:57.153]     else {
  [21:18:57.153]         base::sink(type = "output", split = FALSE)
  [21:18:57.153]         if (TRUE) {
  [21:18:57.153]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:57.153]         }
  [21:18:57.153]         else {
  [21:18:57.153]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:57.153]         }
  [21:18:57.153]         base::close(...future.stdout)
  [21:18:57.153]         ...future.stdout <- NULL
  [21:18:57.153]     }
  [21:18:57.153]     ...future.result$conditions <- ...future.conditions
  [21:18:57.153]     ...future.result
  [21:18:57.153] }
  [21:18:57.269]  - Condition #10: 'simpleMessage', 'message', 'condition'
  [21:18:57.167] plan(): Setting new future strategy stack:
  [21:18:57.269]  - Condition #11: 'simpleMessage', 'message', 'condition'
  [21:18:57.168] List of future strategies:
  [21:18:57.168] 1. sequential:
  [21:18:57.168]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.168]    - tweaked: FALSE
  [21:18:57.168]    - call: NULL
  [21:18:57.270]  - Condition #12: 'simpleMessage', 'message', 'condition'
  [21:18:57.169] plan(): nbrOfWorkers() = 1
  [21:18:57.270]  - Condition #13: 'simpleMessage', 'message', 'condition'
  [21:18:57.179] plan(): Setting new future strategy stack:
  [21:18:57.271]  - Condition #14: 'simpleMessage', 'message', 'condition'
  [21:18:57.180] List of future strategies:
  [21:18:57.180] 1. sequential:
  [21:18:57.180]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.180]    - tweaked: FALSE
  [21:18:57.180]    - call: NULL
  [21:18:57.271]  - Condition #15: 'simpleMessage', 'message', 'condition'
  [21:18:57.181] plan(): nbrOfWorkers() = 1
  [21:18:57.271]  - Condition #16: 'simpleMessage', 'message', 'condition'
  [21:18:57.182] SequentialFuture started (and completed)
  [21:18:57.272]  - Condition #17: 'simpleMessage', 'message', 'condition'
  [21:18:57.183] getGlobalsAndPackages() ...
  [21:18:57.272]  - Condition #18: 'simpleMessage', 'message', 'condition'
  [21:18:57.184] Searching for globals...
  [21:18:57.272]  - Condition #19: 'simpleMessage', 'message', 'condition'
  [21:18:57.185] 
  [21:18:57.273]  - Condition #20: 'simpleMessage', 'message', 'condition'
  [21:18:57.186] Searching for globals ... DONE
  [21:18:57.273]  - Condition #21: 'simpleMessage', 'message', 'condition'
  [21:18:57.194] - globals: [0] <none>
  [21:18:57.274]  - Condition #22: 'simpleMessage', 'message', 'condition'
  [21:18:57.195] getGlobalsAndPackages() ... DONE
  [21:18:57.290]  - Condition #23: 'simpleMessage', 'message', 'condition'
  [21:18:57.197] Packages needed by the future expression (n = 0): <none>
  [21:18:57.290]  - Condition #24: 'simpleMessage', 'message', 'condition'
  [21:18:57.198] Packages needed by future strategies (n = 0): <none>
  [21:18:57.291]  - Condition #25: 'simpleMessage', 'message', 'condition'
  [21:18:57.219] {
  [21:18:57.219]     {
  [21:18:57.219]         ...future.startTime <- base::Sys.time()
  [21:18:57.219]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:57.219]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:57.219]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:57.219]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:57.219]             future.resolve.recursive = NULL, width = 80L)
  [21:18:57.219]         {
  [21:18:57.219]             {
  [21:18:57.219]                 base::local({
  [21:18:57.219]                   has_future <- base::requireNamespace("future", 
  [21:18:57.219]                     quietly = TRUE)
  [21:18:57.219]                   version <- if (has_future) 
  [21:18:57.219]                     utils::packageVersion("future")
  [21:18:57.219]                   else NULL
  [21:18:57.219]                   if (!has_future || version < "1.8.0") {
  [21:18:57.219]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:18:57.219]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:18:57.219]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:57.219]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:57.219]                         "release", "version")], collapse = " "), 
  [21:18:57.219]                       hostname = base::Sys.info()[["nodename"]])
  [21:18:57.219]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:57.219]                       info)
  [21:18:57.219]                     info <- base::paste(info, collapse = "; ")
  [21:18:57.219]                     if (!has_future) {
  [21:18:57.219]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:57.219]                         info)
  [21:18:57.219]                     }
  [21:18:57.219]                     else {
  [21:18:57.219]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:57.219]                         info, version)
  [21:18:57.219]                     }
  [21:18:57.219]                     base::stop(msg)
  [21:18:57.219]                   }
  [21:18:57.219]                 })
  [21:18:57.219]             }
  [21:18:57.219]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:57.219]         }
  [21:18:57.219]     }
  [21:18:57.219]     if (base::is.na(TRUE)) {
  [21:18:57.219]     }
  [21:18:57.219]     else {
  [21:18:57.219]         if (TRUE) {
  [21:18:57.219]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:57.219]                 open = "w")
  [21:18:57.219]         }
  [21:18:57.219]         else {
  [21:18:57.219]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:57.219]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:57.219]         }
  [21:18:57.219]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:57.219]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:57.219]             base::sink(type = "output", split = FALSE)
  [21:18:57.219]             base::close(...future.stdout)
  [21:18:57.219]         }, add = TRUE)
  [21:18:57.219]     }
  [21:18:57.219]     ...future.frame <- base::sys.nframe()
  [21:18:57.219]     ...future.conditions <- base::list()
  [21:18:57.219]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:57.219]     ...future.result <- base::tryCatch({
  [21:18:57.219]         base::withCallingHandlers({
  [21:18:57.219]             ...future.value <- base::withVisible(base::local(4))
  [21:18:57.219]             future::FutureResult(value = ...future.value$value, 
  [21:18:57.219]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.219]                   ...future.rng), started = ...future.startTime, 
  [21:18:57.219]                 version = "1.8")
  [21:18:57.219]         }, condition = base::local({
  [21:18:57.219]             c <- base::c
  [21:18:57.219]             inherits <- base::inherits
  [21:18:57.219]             invokeRestart <- base::invokeRestart
  [21:18:57.219]             length <- base::length
  [21:18:57.219]             list <- base::list
  [21:18:57.219]             seq.int <- base::seq.int
  [21:18:57.219]             signalCondition <- base::signalCondition
  [21:18:57.219]             sys.calls <- base::sys.calls
  [21:18:57.219]             Sys.time <- base::Sys.time
  [21:18:57.219]             `[[` <- base::`[[`
  [21:18:57.219]             `+` <- base::`+`
  [21:18:57.219]             `<<-` <- base::`<<-`
  [21:18:57.219]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:57.219]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:57.219]                   3L)]
  [21:18:57.219]             }
  [21:18:57.219]             function(cond) {
  [21:18:57.219]                 if (inherits(cond, "error")) {
  [21:18:57.219]                   sessionInformation <- function() {
  [21:18:57.219]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:57.219]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:57.219]                       search = base::search(), system = base::Sys.info())
  [21:18:57.219]                   }
  [21:18:57.219]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.219]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:57.219]                     cond$call), session = sessionInformation(), 
  [21:18:57.219]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:57.219]                   signalCondition(cond)
  [21:18:57.219]                 }
  [21:18:57.219]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:18:57.219]                 ))) {
  [21:18:57.219]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:18:57.219]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.219]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:57.219]                   if (!signal) {
  [21:18:57.219]                     muffleCondition <- function (cond) 
  [21:18:57.219]                     {
  [21:18:57.219]                       inherits <- base::inherits
  [21:18:57.219]                       invokeRestart <- base::invokeRestart
  [21:18:57.219]                       muffled <- FALSE
  [21:18:57.219]                       if (inherits(cond, "message")) {
  [21:18:57.219]                         invokeRestart("muffleMessage")
  [21:18:57.219]                         muffled <- TRUE
  [21:18:57.219]                       }
  [21:18:57.219]                       else if (inherits(cond, "warning")) {
  [21:18:57.219]                         invokeRestart("muffleWarning")
  [21:18:57.219]                         muffled <- TRUE
  [21:18:57.219]                       }
  [21:18:57.219]                       else if (inherits(cond, "condition")) {
  [21:18:57.219]                         computeRestarts <- base::computeRestarts
  [21:18:57.219]                         grepl <- base::grepl
  [21:18:57.219]                         is.null <- base::is.null
  [21:18:57.219]                         restarts <- computeRestarts(cond)
  [21:18:57.219]                         for (restart in restarts) {
  [21:18:57.219]                           name <- restart$name
  [21:18:57.219]                           if (is.null(name)) 
  [21:18:57.219]                             next
  [21:18:57.219]                           if (!grepl("^muffle", name)) 
  [21:18:57.219]                             next
  [21:18:57.219]                           invokeRestart(restart)
  [21:18:57.219]                           muffled <- TRUE
  [21:18:57.219]                           break
  [21:18:57.219]                         }
  [21:18:57.219]                       }
  [21:18:57.219]                       invisible(muffled)
  [21:18:57.219]                     }
  [21:18:57.219]                     muffleCondition(cond)
  [21:18:57.219]                   }
  [21:18:57.219]                 }
  [21:18:57.219]             }
  [21:18:57.219]         }))
  [21:18:57.219]     }, error = function(ex) {
  [21:18:57.219]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:57.219]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.219]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:57.219]     }, finally = {
  [21:18:57.219]         {
  [21:18:57.219]             NULL
  [21:18:57.219]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:57.219]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:57.219]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:18:57.219]                 label = NULL, ...) 
  [21:18:57.219]             {
  [21:18:57.219]                 if (substitute) 
  [21:18:57.219]                   expr <- substitute(expr)
  [21:18:57.219]                 local <- as.logical(local)
  [21:18:57.219]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:18:57.219]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:57.219]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:18:57.219]                   label = label, ...)
  [21:18:57.219]                 if (!future$lazy) 
  [21:18:57.219]                   future <- run(future)
  [21:18:57.219]                 invisible(future)
  [21:18:57.219]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:57.219]         }
  [21:18:57.219]         base::options(...future.oldOptions)
  [21:18:57.219]     })
  [21:18:57.219]     Sys.time
  [21:18:57.219]     if (base::is.na(TRUE)) {
  [21:18:57.219]     }
  [21:18:57.219]     else {
  [21:18:57.219]         base::sink(type = "output", split = FALSE)
  [21:18:57.219]         if (TRUE) {
  [21:18:57.219]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:57.219]         }
  [21:18:57.219]         else {
  [21:18:57.219]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:57.219]         }
  [21:18:57.219]         base::close(...future.stdout)
  [21:18:57.219]         ...future.stdout <- NULL
  [21:18:57.219]     }
  [21:18:57.219]     ...future.result$conditions <- ...future.conditions
  [21:18:57.219]     ...future.result
  [21:18:57.219] }
  [21:18:57.291]  - Condition #26: 'simpleMessage', 'message', 'condition'
  [21:18:57.224] plan(): Setting new future strategy stack:
  [21:18:57.292]  - Condition #27: 'simpleMessage', 'message', 'condition'
  [21:18:57.225] List of future strategies:
  [21:18:57.225] 1. sequential:
  [21:18:57.225]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.225]    - tweaked: FALSE
  [21:18:57.225]    - call: NULL
  [21:18:57.292]  - Condition #28: 'simpleMessage', 'message', 'condition'
  [21:18:57.226] plan(): nbrOfWorkers() = 1
  [21:18:57.292]  - Condition #29: 'simpleMessage', 'message', 'condition'
  [21:18:57.250] plan(): Setting new future strategy stack:
  [21:18:57.293]  - Condition #30: 'simpleMessage', 'message', 'condition'
  [21:18:57.251] List of future strategies:
  [21:18:57.251] 1. sequential:
  [21:18:57.251]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.251]    - tweaked: FALSE
  [21:18:57.251]    - call: NULL
  [21:18:57.293]  - Condition #31: 'simpleMessage', 'message', 'condition'
  [21:18:57.252] plan(): nbrOfWorkers() = 1
  [21:18:57.293]  - Condition #32: 'simpleMessage', 'message', 'condition'
  [21:18:57.253] SequentialFuture started (and completed)
  [21:18:57.294] signalConditions() ... done
  a = 10
  [21:18:57.295] getGlobalsAndPackages() ...
  [21:18:57.296] Searching for globals...
  [21:18:57.297] - globals found: [3] '{', '+', 'a'
  [21:18:57.298] Searching for globals ... DONE
  [21:18:57.298] Resolving globals: FALSE
  [21:18:57.299] The total size of the 1 globals is 56 bytes (56 bytes)
  [21:18:57.299] - globals: [1] 'a'
  [21:18:57.300] 
  [21:18:57.300] getGlobalsAndPackages() ... DONE
  [21:18:57.302] Packages needed by the future expression (n = 0): <none>
  [21:18:57.302] Packages needed by future strategies (n = 0): <none>
  [21:18:57.320] {
  [21:18:57.320]     {
  [21:18:57.320]         ...future.startTime <- base::Sys.time()
  [21:18:57.320]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:18:57.320]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:18:57.320]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:18:57.320]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:18:57.320]             future.resolve.recursive = NULL, width = 80L)
  [21:18:57.320]         {
  [21:18:57.320]             {
  [21:18:57.320]                 {
  [21:18:57.320]                   base::local({
  [21:18:57.320]                     has_future <- base::requireNamespace("future", 
  [21:18:57.320]                       quietly = TRUE)
  [21:18:57.320]                     version <- if (has_future) 
  [21:18:57.320]                       utils::packageVersion("future")
  [21:18:57.320]                     else NULL
  [21:18:57.320]                     if (!has_future || version < "1.8.0") {
  [21:18:57.320]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:18:57.320]                         "", base::R.version$version.string), 
  [21:18:57.320]                         platform = base::sprintf("%s (%s-bit)", 
  [21:18:57.320]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:18:57.320]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:18:57.320]                           "release", "version")], collapse = " "), 
  [21:18:57.320]                         hostname = base::Sys.info()[["nodename"]])
  [21:18:57.320]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:18:57.320]                         info)
  [21:18:57.320]                       info <- base::paste(info, collapse = "; ")
  [21:18:57.320]                       if (!has_future) {
  [21:18:57.320]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:18:57.320]                           info)
  [21:18:57.320]                       }
  [21:18:57.320]                       else {
  [21:18:57.320]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:18:57.320]                           info, version)
  [21:18:57.320]                       }
  [21:18:57.320]                       base::stop(msg)
  [21:18:57.320]                     }
  [21:18:57.320]                   })
  [21:18:57.320]                 }
  [21:18:57.320]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:18:57.320]                 base::options(mc.cores = 1L)
  [21:18:57.320]             }
  [21:18:57.320]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:18:57.320]         }
  [21:18:57.320]     }
  [21:18:57.320]     if (base::is.na(TRUE)) {
  [21:18:57.320]     }
  [21:18:57.320]     else {
  [21:18:57.320]         if (TRUE) {
  [21:18:57.320]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:18:57.320]                 open = "w")
  [21:18:57.320]         }
  [21:18:57.320]         else {
  [21:18:57.320]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:18:57.320]                 windows = "NUL", "/dev/null"), open = "w")
  [21:18:57.320]         }
  [21:18:57.320]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:18:57.320]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:18:57.320]             base::sink(type = "output", split = FALSE)
  [21:18:57.320]             base::close(...future.stdout)
  [21:18:57.320]         }, add = TRUE)
  [21:18:57.320]     }
  [21:18:57.320]     ...future.frame <- base::sys.nframe()
  [21:18:57.320]     ...future.conditions <- base::list()
  [21:18:57.320]     ...future.rng <- base::globalenv()$.Random.seed
  [21:18:57.320]     ...future.result <- base::tryCatch({
  [21:18:57.320]         base::withCallingHandlers({
  [21:18:57.320]             ...future.value <- base::withVisible(base::local({
  [21:18:57.320]                 a + 1
  [21:18:57.320]             }))
  [21:18:57.320]             future::FutureResult(value = ...future.value$value, 
  [21:18:57.320]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.320]                   ...future.rng), started = ...future.startTime, 
  [21:18:57.320]                 version = "1.8")
  [21:18:57.320]         }, condition = base::local({
  [21:18:57.320]             c <- base::c
  [21:18:57.320]             inherits <- base::inherits
  [21:18:57.320]             invokeRestart <- base::invokeRestart
  [21:18:57.320]             length <- base::length
  [21:18:57.320]             list <- base::list
  [21:18:57.320]             seq.int <- base::seq.int
  [21:18:57.320]             signalCondition <- base::signalCondition
  [21:18:57.320]             sys.calls <- base::sys.calls
  [21:18:57.320]             Sys.time <- base::Sys.time
  [21:18:57.320]             `[[` <- base::`[[`
  [21:18:57.320]             `+` <- base::`+`
  [21:18:57.320]             `<<-` <- base::`<<-`
  [21:18:57.320]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:18:57.320]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:18:57.320]                   3L)]
  [21:18:57.320]             }
  [21:18:57.320]             function(cond) {
  [21:18:57.320]                 if (inherits(cond, "error")) {
  [21:18:57.320]                   sessionInformation <- function() {
  [21:18:57.320]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:18:57.320]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:18:57.320]                       search = base::search(), system = base::Sys.info())
  [21:18:57.320]                   }
  [21:18:57.320]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.320]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:18:57.320]                     cond$call), session = sessionInformation(), 
  [21:18:57.320]                     timestamp = Sys.time(), signaled = 0L)
  [21:18:57.320]                   signalCondition(cond)
  [21:18:57.320]                 }
  [21:18:57.320]                 else if (inherits(cond, "condition")) {
  [21:18:57.320]                   signal <- FALSE && inherits(cond, character(0))
  [21:18:57.320]                   ...future.conditions[[length(...future.conditions) + 
  [21:18:57.320]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:18:57.320]                   if (!signal) {
  [21:18:57.320]                     muffleCondition <- function (cond) 
  [21:18:57.320]                     {
  [21:18:57.320]                       inherits <- base::inherits
  [21:18:57.320]                       invokeRestart <- base::invokeRestart
  [21:18:57.320]                       muffled <- FALSE
  [21:18:57.320]                       if (inherits(cond, "message")) {
  [21:18:57.320]                         invokeRestart("muffleMessage")
  [21:18:57.320]                         muffled <- TRUE
  [21:18:57.320]                       }
  [21:18:57.320]                       else if (inherits(cond, "warning")) {
  [21:18:57.320]                         invokeRestart("muffleWarning")
  [21:18:57.320]                         muffled <- TRUE
  [21:18:57.320]                       }
  [21:18:57.320]                       else if (inherits(cond, "condition")) {
  [21:18:57.320]                         computeRestarts <- base::computeRestarts
  [21:18:57.320]                         grepl <- base::grepl
  [21:18:57.320]                         is.null <- base::is.null
  [21:18:57.320]                         restarts <- computeRestarts(cond)
  [21:18:57.320]                         for (restart in restarts) {
  [21:18:57.320]                           name <- restart$name
  [21:18:57.320]                           if (is.null(name)) 
  [21:18:57.320]                             next
  [21:18:57.320]                           if (!grepl("^muffle", name)) 
  [21:18:57.320]                             next
  [21:18:57.320]                           invokeRestart(restart)
  [21:18:57.320]                           muffled <- TRUE
  [21:18:57.320]                           break
  [21:18:57.320]                         }
  [21:18:57.320]                       }
  [21:18:57.320]                       invisible(muffled)
  [21:18:57.320]                     }
  [21:18:57.320]                     muffleCondition(cond)
  [21:18:57.320]                   }
  [21:18:57.320]                 }
  [21:18:57.320]             }
  [21:18:57.320]         }))
  [21:18:57.320]     }, error = function(ex) {
  [21:18:57.320]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:18:57.320]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:18:57.320]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:18:57.320]     }, finally = {
  [21:18:57.320]         {
  [21:18:57.320]             {
  [21:18:57.320]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:18:57.320]             }
  [21:18:57.320]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:18:57.320]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:18:57.320]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:18:57.320]                 earlySignal = FALSE, label = NULL, ...) 
  [21:18:57.320]             {
  [21:18:57.320]                 if (substitute) 
  [21:18:57.320]                   expr <- substitute(expr)
  [21:18:57.320]                 if (is.function(workers)) 
  [21:18:57.320]                   workers <- workers()
  [21:18:57.320]                 workers <- as.integer(workers)
  [21:18:57.320]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:18:57.320]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:18:57.320]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:18:57.320]                     lazy = lazy, seed = seed, globals = globals, 
  [21:18:57.320]                     local = TRUE, label = label, ...))
  [21:18:57.320]                 }
  [21:18:57.320]                 oopts <- options(mc.cores = workers)
  [21:18:57.320]                 on.exit(options(oopts))
  [21:18:57.320]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:18:57.320]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:18:57.320]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:18:57.320]                   label = label, ...)
  [21:18:57.320]                 if (!future$lazy) 
  [21:18:57.320]                   future <- run(future)
  [21:18:57.320]                 invisible(future)
  [21:18:57.320]             }), .cleanup = FALSE, .init = FALSE)
  [21:18:57.320]         }
  [21:18:57.320]         base::options(...future.oldOptions)
  [21:18:57.320]     })
  [21:18:57.320]     Sys.time
  [21:18:57.320]     if (base::is.na(TRUE)) {
  [21:18:57.320]     }
  [21:18:57.320]     else {
  [21:18:57.320]         base::sink(type = "output", split = FALSE)
  [21:18:57.320]         if (TRUE) {
  [21:18:57.320]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:18:57.320]         }
  [21:18:57.320]         else {
  [21:18:57.320]             ...future.result["stdout"] <- base::list(NULL)
  [21:18:57.320]         }
  [21:18:57.320]         base::close(...future.stdout)
  [21:18:57.320]         ...future.stdout <- NULL
  [21:18:57.320]     }
  [21:18:57.320]     ...future.result$conditions <- ...future.conditions
  [21:18:57.320]     ...future.result
  [21:18:57.320] }
  [21:18:57.324] requestCore(): workers = 2
  [21:18:57.327] MulticoreFuture started
  [21:18:57.337] plan(): Setting new future strategy stack:
  [21:18:57.338] List of future strategies:
  [21:18:57.338] 1. sequential:
  [21:18:57.338]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.338]    - tweaked: FALSE
  [21:18:57.338]    - call: NULL
  [21:18:57.340] plan(): nbrOfWorkers() = 1
  [21:18:57.341] plan(): Setting new future strategy stack:
  [21:18:57.342] List of future strategies:
  [21:18:57.342] 1. multicore:
  [21:18:57.342]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:18:57.342]    - tweaked: FALSE
  [21:18:57.342]    - call: plan(strategy)
  [21:18:57.368] plan(): nbrOfWorkers() = 2
  b = 11
  *** %<-% with 'multicore' futures ... DONE
  *** %<-% with 'multisession' futures ...
  [21:18:57.370] plan(): Setting new future strategy stack:
  [21:18:57.371] List of future strategies:
  [21:18:57.371] 1. multisession:
  [21:18:57.371]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.371]    - tweaked: FALSE
  [21:18:57.371]    - call: plan(strategy)
  [21:18:57.372] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [21:18:57.372] multisession:
  [21:18:57.372] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [21:18:57.372] - tweaked: FALSE
  [21:18:57.372] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 35894
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpBFEBdS/future.parent=27503.6b6f20898179.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpBFEBdS/future.parent=27503.6b6f20898179.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureAssign_OP.R:gimli2:hornik:27503' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpBFEBdS/future.parent=27503.6b6f20898179.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35894 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] Detected a warning from socketConnection(): 'port 35894 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 35894 cannot be opened
  Killing worker process (PID 28885) if still alive
  [21:18:59.655] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(27503, signal = 0L)
  [1] TRUE
  Call: tools::pskill(27503, signal = 0L)
  [1] TRUE
  [21:18:59.656] - success
  [21:18:59.656] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 28885) was successfully killed: TRUE
  Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gimli2'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 35894 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
   * The localhost socket connection that failed to connect to the R worker used port 35894 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureAssign_OP.R:gimli2:hornik:27503' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpBFEBdS/future.parent=27503.6b6f20898179.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35894 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 28885) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted