Running ‘DEPRECATED.R’ [1s/1s]
  Running ‘cluster-missing-doFuture-pkg.R’ [1s/4s]
  Running ‘doRNG,dopar.R’ [2s/41s]
  Running ‘doRNG,dorng.R’ [6s/46s]
  Running ‘foreach,errors.R’ [6s/122s]
  Running ‘foreach,globals.R’ [7s/126s]
  Running ‘foreach,nested.R’ [4s/70s]
  Running ‘foreach,nested_dopar.R’ [15s/271s]
  Running ‘foreach.R’ [11s/62s]
  Running ‘future.BatchJobs.R’ [26s/41s]
  Running ‘future.batchtools.R’ [36s/51s]
  Running ‘options.R’ [3s/24s]
  Running ‘registerDoFuture.R’ [2s/39s]
  Running ‘times.R’ [2s/39s]
  Running ‘zzz_opt-in,NMF.R’ [0s/1s]
  Running ‘zzz_opt-in,TSP.R’ [0s/1s]
  Running ‘zzz_opt-in,caret.R’ [0s/1s]
  Running ‘zzz_opt-in,foreach.R’ [0s/1s]
  Running ‘zzz_opt-in,glmnet.R’ [0s/1s]
  Running ‘zzz_opt-in,plyr.R’ [0s/1s]
Running the tests in ‘tests/foreach,nested.R’ failed.
Complete output:
  > source("incl/start.R")
  Loading required package: globals
  Loading required package: future
  Loading required package: foreach
  Loading required package: iterators
  Loading required package: parallel
  [20:24:29.958] plan(): Setting new future strategy stack:
  [20:24:29.959] List of future strategies:
  [20:24:29.959] 1. sequential:
  [20:24:29.959]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:29.959]    - tweaked: FALSE
  [20:24:29.959]    - call: future::plan(future::sequential)
  [20:24:29.961] plan(): nbrOfWorkers() = 1
  > 
  > strategies <- future:::supportedStrategies()
  > strategies <- setdiff(strategies, "multiprocess")
  > 
  > message("*** doFuture - nested w/ %:% ...")
  *** doFuture - nested w/ %:% ...
  > 
  > registerDoFuture()
  > 
  > for (strategy1 in strategies) {
  +   for (strategy2 in strategies) {
  +     message(sprintf("- plan(list('%s', '%s')) ...", strategy1, strategy2))
  +     plan(list(a = strategy1, b = strategy2))
  +     nested <- plan("list")
  + 
  +     as <- 1:2
  +     bs <- 3:1
  +     x <- foreach(a = as) %:% foreach(b = bs) %dopar% {
  +       list(a = a, b = b, plan_b = future::plan("list"), plan = future::plan("next"))
  +     }
  + 
  +     stopifnot(length(x) == length(as))
  +     for (aa in seq_along(as)) {
  +       x_aa <- x[[aa]]
  +       stopifnot(length(x_aa) == length(bs))
  +       a <- as[aa]
  +       for (bb in seq_along(bs)) {
  +         x_aa_bb <- x_aa[[bb]]
  +         b <- bs[bb]
  +         stopifnot(
  +           length(x_aa_bb) == 4L,
  +           all(names(x_aa_bb) == c("a", "b", "plan_b", "plan")),
  +           x_aa_bb$a == a,
  +           x_aa_bb$b == b,
  +           length(x_aa_bb$plan_b) == length(nested[-1]),
  +           inherits(x_aa_bb$plan_b[[1]], strategy2),
  +           inherits(x_aa_bb$plan, strategy2)
  +         )
  +       }
  +     }
  + 
  +     message(sprintf("- plan(list('%s', '%s')) ... DONE", strategy1, strategy2))
  +   }
  + }
  - plan(list('sequential', 'sequential')) ...
  [20:24:30.021] plan(): Setting new future strategy stack:
  [20:24:30.021] List of future strategies:
  [20:24:30.021] 1. sequential:
  [20:24:30.021]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.021]    - tweaked: FALSE
  [20:24:30.021]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.021] 2. sequential:
  [20:24:30.021]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.021]    - tweaked: FALSE
  [20:24:30.021]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.047] plan(): nbrOfWorkers() = 1
  [20:24:30.048] doFuture() ...
  [20:24:30.057] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:30.058] - R expression:
  [20:24:30.058] {
  [20:24:30.058]     doFuture::registerDoFuture()
  [20:24:30.058]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.058]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.058]         {
  [20:24:30.058]             a <- NULL
  [20:24:30.058]             b <- NULL
  [20:24:30.058]         }
  [20:24:30.058]         ...future.env <- environment()
  [20:24:30.058]         local({
  [20:24:30.058]             for (name in names(...future.x_jj)) {
  [20:24:30.058]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.058]                   inherits = FALSE)
  [20:24:30.058]             }
  [20:24:30.058]         })
  [20:24:30.058]         tryCatch({
  [20:24:30.058]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.058]                 plan = future::plan("next"))
  [20:24:30.058]         }, error = identity)
  [20:24:30.058]     })
  [20:24:30.058] }
  [20:24:30.059] - identifying globals and packages ...
  [20:24:30.061] getGlobalsAndPackages() ...
  [20:24:30.061] Searching for globals...
  [20:24:30.085] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:30.086] Searching for globals ... DONE
  [20:24:30.086] Resolving globals: FALSE
  [20:24:30.088] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:30.089] - globals: [1] '...future.x_ii'
  [20:24:30.089] 
  [20:24:30.089] getGlobalsAndPackages() ... DONE
  [20:24:30.090] List of 1
  [20:24:30.090]  $ ...future.x_ii: NULL
  [20:24:30.090]  - attr(*, "where")=List of 1
  [20:24:30.090]   ..$ ...future.x_ii:<environment: 0x55bc21ec5648> 
  [20:24:30.090]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.090]  - attr(*, "resolved")= logi FALSE
  [20:24:30.090]  - attr(*, "total_size")= num 0
  [20:24:30.100]   - R expression:
  [20:24:30.100] {
  [20:24:30.100]     doFuture::registerDoFuture()
  [20:24:30.100]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.100]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.100]         {
  [20:24:30.100]             a <- NULL
  [20:24:30.100]             b <- NULL
  [20:24:30.100]         }
  [20:24:30.100]         ...future.env <- environment()
  [20:24:30.100]         local({
  [20:24:30.100]             for (name in names(...future.x_jj)) {
  [20:24:30.100]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.100]                   inherits = FALSE)
  [20:24:30.100]             }
  [20:24:30.100]         })
  [20:24:30.100]         tryCatch({
  [20:24:30.100]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.100]                 plan = future::plan("next"))
  [20:24:30.100]         }, error = identity)
  [20:24:30.100]     })
  [20:24:30.100] }
  [20:24:30.101]   - globals: [1] '...future.x_ii'
  [20:24:30.101] List of 1
  [20:24:30.101]  $ ...future.x_ii: NULL
  [20:24:30.101]  - attr(*, "where")=List of 1
  [20:24:30.101]   ..$ ...future.x_ii:<environment: 0x55bc21ec5648> 
  [20:24:30.101]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.101]  - attr(*, "resolved")= logi FALSE
  [20:24:30.101]  - attr(*, "total_size")= num 0
  [20:24:30.108]   - packages: [1] 'doFuture'
  [20:24:30.108] - identifying globals and packages ... DONE
  [20:24:30.109] Number of chunks: 1
  [20:24:30.109] Number of futures (= number of chunks): 1
  [20:24:30.110] Launching 1 futures (chunks) ...
  [20:24:30.111] Chunk #1 of 1 ...
  [20:24:30.111]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:30.111] getGlobalsAndPackages() ...
  [20:24:30.111] Searching for globals...
  [20:24:30.112] 
  [20:24:30.113] Searching for globals ... DONE
  [20:24:30.113] - globals: [0] <none>
  [20:24:30.113] getGlobalsAndPackages() ... DONE
  [20:24:30.113] 
  [20:24:30.114] 
  [20:24:30.114]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:30.115] getGlobalsAndPackages() ...
  [20:24:30.115] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.115] Resolving globals: FALSE
  [20:24:30.116] The total size of the 1 globals is 672 bytes (672 bytes)
  [20:24:30.117] - globals: [1] '...future.x_ii'
  [20:24:30.117] 
  [20:24:30.117] getGlobalsAndPackages() ... DONE
  [20:24:30.120] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.120] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.130] {
  [20:24:30.130]     {
  [20:24:30.130]         ...future.startTime <- base::Sys.time()
  [20:24:30.130]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.130]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.130]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [20:24:30.130]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.130]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.130]         {
  [20:24:30.130]             {
  [20:24:30.130]                 {
  [20:24:30.130]                   has_future <- base::requireNamespace("future", 
  [20:24:30.130]                     quietly = TRUE)
  [20:24:30.130]                   version <- if (has_future) 
  [20:24:30.130]                     utils::packageVersion("future")
  [20:24:30.130]                   else NULL
  [20:24:30.130]                   if (!has_future || version < "1.8.0") {
  [20:24:30.130]                     info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.130]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.130]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.130]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.130]                         "release", "version")], collapse = " "), 
  [20:24:30.130]                       hostname = base::Sys.info()[["nodename"]])
  [20:24:30.130]                     info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.130]                       info)
  [20:24:30.130]                     info <- base::paste(info, collapse = "; ")
  [20:24:30.130]                     if (!has_future) {
  [20:24:30.130]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.130]                         info)
  [20:24:30.130]                     }
  [20:24:30.130]                     else {
  [20:24:30.130]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.130]                         info, version)
  [20:24:30.130]                     }
  [20:24:30.130]                     base::stop(msg)
  [20:24:30.130]                   }
  [20:24:30.130]                 }
  [20:24:30.130]                 base::local({
  [20:24:30.130]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.130]                     base::loadNamespace(pkg)
  [20:24:30.130]                     base::library(pkg, character.only = TRUE)
  [20:24:30.130]                   }
  [20:24:30.130]                 })
  [20:24:30.130]             }
  [20:24:30.130]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.130]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.130]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.130]                 label = NULL, ...) 
  [20:24:30.130]             {
  [20:24:30.130]                 if (substitute) 
  [20:24:30.130]                   expr <- substitute(expr)
  [20:24:30.130]                 local <- as.logical(local)
  [20:24:30.130]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.130]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.130]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.130]                   label = label, ...)
  [20:24:30.130]                 if (!future$lazy) 
  [20:24:30.130]                   future <- run(future)
  [20:24:30.130]                 invisible(future)
  [20:24:30.130]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.130]         }
  [20:24:30.130]     }
  [20:24:30.130]     if (base::is.na(TRUE)) {
  [20:24:30.130]     }
  [20:24:30.130]     else {
  [20:24:30.130]         if (TRUE) {
  [20:24:30.130]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.130]                 open = "w")
  [20:24:30.130]         }
  [20:24:30.130]         else {
  [20:24:30.130]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.130]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.130]         }
  [20:24:30.130]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.130]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.130]             base::sink(type = "output", split = FALSE)
  [20:24:30.130]             base::close(...future.stdout)
  [20:24:30.130]         }, add = TRUE)
  [20:24:30.130]     }
  [20:24:30.130]     ...future.frame <- base::sys.nframe()
  [20:24:30.130]     ...future.conditions <- base::list()
  [20:24:30.130]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.130]     ...future.result <- base::tryCatch({
  [20:24:30.130]         base::withCallingHandlers({
  [20:24:30.130]             ...future.value <- base::withVisible(base::local({
  [20:24:30.130]                 doFuture::registerDoFuture()
  [20:24:30.130]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.130]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.130]                   {
  [20:24:30.130]                     a <- NULL
  [20:24:30.130]                     b <- NULL
  [20:24:30.130]                   }
  [20:24:30.130]                   ...future.env <- environment()
  [20:24:30.130]                   local({
  [20:24:30.130]                     for (name in names(...future.x_jj)) {
  [20:24:30.130]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.130]                         inherits = FALSE)
  [20:24:30.130]                     }
  [20:24:30.130]                   })
  [20:24:30.130]                   tryCatch({
  [20:24:30.130]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.130]                       plan = future::plan("next"))
  [20:24:30.130]                   }, error = identity)
  [20:24:30.130]                 })
  [20:24:30.130]             }))
  [20:24:30.130]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.130]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.130]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.130]                 version = "1.8")
  [20:24:30.130]         }, condition = base::local({
  [20:24:30.130]             c <- base::c
  [20:24:30.130]             inherits <- base::inherits
  [20:24:30.130]             invokeRestart <- base::invokeRestart
  [20:24:30.130]             length <- base::length
  [20:24:30.130]             list <- base::list
  [20:24:30.130]             seq.int <- base::seq.int
  [20:24:30.130]             signalCondition <- base::signalCondition
  [20:24:30.130]             sys.calls <- base::sys.calls
  [20:24:30.130]             Sys.time <- base::Sys.time
  [20:24:30.130]             `[[` <- base::`[[`
  [20:24:30.130]             `+` <- base::`+`
  [20:24:30.130]             `<<-` <- base::`<<-`
  [20:24:30.130]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.130]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.130]                   3L)]
  [20:24:30.130]             }
  [20:24:30.130]             function(cond) {
  [20:24:30.130]                 if (inherits(cond, "error")) {
  [20:24:30.130]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.130]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.130]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.130]                   signalCondition(cond)
  [20:24:30.130]                 }
  [20:24:30.130]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:30.130]                 ))) {
  [20:24:30.130]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:30.130]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.130]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.130]                   if (!signal) {
  [20:24:30.130]                     muffleCondition <- function (cond) 
  [20:24:30.130]                     {
  [20:24:30.130]                       inherits <- base::inherits
  [20:24:30.130]                       invokeRestart <- base::invokeRestart
  [20:24:30.130]                       muffled <- FALSE
  [20:24:30.130]                       if (inherits(cond, "message")) {
  [20:24:30.130]                         invokeRestart("muffleMessage")
  [20:24:30.130]                         muffled <- TRUE
  [20:24:30.130]                       }
  [20:24:30.130]                       else if (inherits(cond, "warning")) {
  [20:24:30.130]                         invokeRestart("muffleWarning")
  [20:24:30.130]                         muffled <- TRUE
  [20:24:30.130]                       }
  [20:24:30.130]                       else if (inherits(cond, "condition")) {
  [20:24:30.130]                         computeRestarts <- base::computeRestarts
  [20:24:30.130]                         grepl <- base::grepl
  [20:24:30.130]                         is.null <- base::is.null
  [20:24:30.130]                         restarts <- computeRestarts(cond)
  [20:24:30.130]                         for (restart in restarts) {
  [20:24:30.130]                           name <- restart$name
  [20:24:30.130]                           if (is.null(name)) 
  [20:24:30.130]                             next
  [20:24:30.130]                           if (!grepl("^muffle", name)) 
  [20:24:30.130]                             next
  [20:24:30.130]                           invokeRestart(restart)
  [20:24:30.130]                           muffled <- TRUE
  [20:24:30.130]                           break
  [20:24:30.130]                         }
  [20:24:30.130]                       }
  [20:24:30.130]                       invisible(muffled)
  [20:24:30.130]                     }
  [20:24:30.130]                     muffleCondition(cond)
  [20:24:30.130]                   }
  [20:24:30.130]                 }
  [20:24:30.130]             }
  [20:24:30.130]         }))
  [20:24:30.130]     }, error = function(ex) {
  [20:24:30.130]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.130]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.130]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.130]     }, finally = {
  [20:24:30.130]         {
  [20:24:30.130]             NULL
  [20:24:30.130]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.130]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.130]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.130]                 label = NULL, ...) 
  [20:24:30.130]             {
  [20:24:30.130]                 if (substitute) 
  [20:24:30.130]                   expr <- substitute(expr)
  [20:24:30.130]                 local <- as.logical(local)
  [20:24:30.130]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.130]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.130]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.130]                   label = label, ...)
  [20:24:30.130]                 if (!future$lazy) 
  [20:24:30.130]                   future <- run(future)
  [20:24:30.130]                 invisible(future)
  [20:24:30.130]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.130]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:30.130]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.130]             {
  [20:24:30.130]                 if (substitute) 
  [20:24:30.130]                   expr <- substitute(expr)
  [20:24:30.130]                 local <- as.logical(local)
  [20:24:30.130]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.130]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.130]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.130]                   label = label, ...)
  [20:24:30.130]                 if (!future$lazy) 
  [20:24:30.130]                   future <- run(future)
  [20:24:30.130]                 invisible(future)
  [20:24:30.130]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.130]         }
  [20:24:30.130]         base::options(...future.oldOptions)
  [20:24:30.130]     })
  [20:24:30.130]     Sys.time
  [20:24:30.130]     if (base::is.na(TRUE)) {
  [20:24:30.130]     }
  [20:24:30.130]     else {
  [20:24:30.130]         base::sink(type = "output", split = FALSE)
  [20:24:30.130]         if (TRUE) {
  [20:24:30.130]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.130]         }
  [20:24:30.130]         else {
  [20:24:30.130]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.130]         }
  [20:24:30.130]         base::close(...future.stdout)
  [20:24:30.130]         ...future.stdout <- NULL
  [20:24:30.130]     }
  [20:24:30.130]     ...future.result$conditions <- ...future.conditions
  [20:24:30.130]     ...future.result
  [20:24:30.130] }
  [20:24:30.136] plan(): Setting new future strategy stack:
  [20:24:30.137] List of future strategies:
  [20:24:30.137] 1. sequential:
  [20:24:30.137]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.137]    - tweaked: FALSE
  [20:24:30.137]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.138] plan(): nbrOfWorkers() = 1
  [20:24:30.153] plan(): Setting new future strategy stack:
  [20:24:30.174] List of future strategies:
  [20:24:30.174] 1. sequential:
  [20:24:30.174]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.174]    - tweaked: FALSE
  [20:24:30.174]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.174] 2. sequential:
  [20:24:30.174]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.174]    - tweaked: FALSE
  [20:24:30.174]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.175] plan(): nbrOfWorkers() = 1
  [20:24:30.176] SequentialFuture started (and completed)
  [20:24:30.177] Chunk #1 of 1 ... DONE
  [20:24:30.177] Launching 1 futures (chunks) ... DONE
  [20:24:30.177] - resolving futures
  [20:24:30.177]   - gathering results & relaying conditions (except errors)
  [20:24:30.178] resolve() on list ...
  [20:24:30.178]  recursive: 0
  [20:24:30.179]  length: 1
  [20:24:30.179] 
  [20:24:30.180] Future #1
  [20:24:30.180] signalConditionsASAP(SequentialFuture, pos=1) ...
  [20:24:30.181] - nx: 1
  [20:24:30.181] - relay: TRUE
  [20:24:30.181] - stdout: TRUE
  [20:24:30.181] - signal: TRUE
  [20:24:30.182] - resignal: FALSE
  [20:24:30.182] - force: FALSE
  [20:24:30.182] - relayed: [n=1] FALSE
  [20:24:30.182] - queued futures: [n=1] FALSE
  [20:24:30.183]  - until=1
  [20:24:30.183]  - relaying element #1
  [20:24:30.183] - relayed: [n=1] TRUE
  [20:24:30.184] - queued futures: [n=1] TRUE
  [20:24:30.184] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [20:24:30.184]  length: 0 (resolved future 1)
  [20:24:30.185] Relaying remaining futures
  [20:24:30.185] signalConditionsASAP(NULL, pos=0) ...
  [20:24:30.185] - nx: 1
  [20:24:30.185] - relay: TRUE
  [20:24:30.186] - stdout: TRUE
  [20:24:30.186] - signal: TRUE
  [20:24:30.186] - resignal: FALSE
  [20:24:30.186] - force: FALSE
  [20:24:30.187] - relayed: [n=1] TRUE
  [20:24:30.187] - queued futures: [n=1] TRUE
   - flush all
  [20:24:30.187] - relayed: [n=1] TRUE
  [20:24:30.187] - queued futures: [n=1] TRUE
  [20:24:30.188] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:30.188] resolve() on list ... DONE
  [20:24:30.188] - collecting values of futures
  [20:24:30.189] - accumulating results
  [20:24:30.208] - processing errors (handler = 'stop')
  [20:24:30.209] - extracting results
  [20:24:30.209] doFuture() ... DONE
  - plan(list('sequential', 'sequential')) ... DONE
  - plan(list('sequential', 'multicore')) ...
  [20:24:30.210] plan(): Setting new future strategy stack:
  [20:24:30.211] List of future strategies:
  [20:24:30.211] 1. sequential:
  [20:24:30.211]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.211]    - tweaked: FALSE
  [20:24:30.211]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.211] 2. multicore:
  [20:24:30.211]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.211]    - tweaked: FALSE
  [20:24:30.211]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.212] plan(): nbrOfWorkers() = 1
  [20:24:30.212] doFuture() ...
  [20:24:30.216] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:30.217] - R expression:
  [20:24:30.217] {
  [20:24:30.217]     doFuture::registerDoFuture()
  [20:24:30.217]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.217]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.217]         {
  [20:24:30.217]             a <- NULL
  [20:24:30.217]             b <- NULL
  [20:24:30.217]         }
  [20:24:30.217]         ...future.env <- environment()
  [20:24:30.217]         local({
  [20:24:30.217]             for (name in names(...future.x_jj)) {
  [20:24:30.217]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.217]                   inherits = FALSE)
  [20:24:30.217]             }
  [20:24:30.217]         })
  [20:24:30.217]         tryCatch({
  [20:24:30.217]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.217]                 plan = future::plan("next"))
  [20:24:30.217]         }, error = identity)
  [20:24:30.217]     })
  [20:24:30.217] }
  [20:24:30.218] - identifying globals and packages ...
  [20:24:30.218] getGlobalsAndPackages() ...
  [20:24:30.219] Searching for globals...
  [20:24:30.250] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:30.251] Searching for globals ... DONE
  [20:24:30.251] Resolving globals: FALSE
  [20:24:30.252] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:30.253] - globals: [1] '...future.x_ii'
  [20:24:30.253] 
  [20:24:30.253] getGlobalsAndPackages() ... DONE
  [20:24:30.253] List of 1
  [20:24:30.253]  $ ...future.x_ii: NULL
  [20:24:30.253]  - attr(*, "where")=List of 1
  [20:24:30.253]   ..$ ...future.x_ii:<environment: 0x55bc236e1040> 
  [20:24:30.253]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.253]  - attr(*, "resolved")= logi FALSE
  [20:24:30.253]  - attr(*, "total_size")= num 0
  [20:24:30.275]   - R expression:
  [20:24:30.275] {
  [20:24:30.275]     doFuture::registerDoFuture()
  [20:24:30.275]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.275]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.275]         {
  [20:24:30.275]             a <- NULL
  [20:24:30.275]             b <- NULL
  [20:24:30.275]         }
  [20:24:30.275]         ...future.env <- environment()
  [20:24:30.275]         local({
  [20:24:30.275]             for (name in names(...future.x_jj)) {
  [20:24:30.275]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.275]                   inherits = FALSE)
  [20:24:30.275]             }
  [20:24:30.275]         })
  [20:24:30.275]         tryCatch({
  [20:24:30.275]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.275]                 plan = future::plan("next"))
  [20:24:30.275]         }, error = identity)
  [20:24:30.275]     })
  [20:24:30.275] }
  [20:24:30.276]   - globals: [1] '...future.x_ii'
  [20:24:30.276] List of 1
  [20:24:30.276]  $ ...future.x_ii: NULL
  [20:24:30.276]  - attr(*, "where")=List of 1
  [20:24:30.276]   ..$ ...future.x_ii:<environment: 0x55bc236e1040> 
  [20:24:30.276]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.276]  - attr(*, "resolved")= logi FALSE
  [20:24:30.276]  - attr(*, "total_size")= num 0
  [20:24:30.282]   - packages: [1] 'doFuture'
  [20:24:30.282] - identifying globals and packages ... DONE
  [20:24:30.282] Number of chunks: 1
  [20:24:30.283] Number of futures (= number of chunks): 1
  [20:24:30.283] Launching 1 futures (chunks) ...
  [20:24:30.283] Chunk #1 of 1 ...
  [20:24:30.284]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:30.284] getGlobalsAndPackages() ...
  [20:24:30.284] Searching for globals...
  [20:24:30.285] 
  [20:24:30.285] Searching for globals ... DONE
  [20:24:30.302] - globals: [0] <none>
  [20:24:30.302] getGlobalsAndPackages() ... DONE
  [20:24:30.302] 
  [20:24:30.303] 
  [20:24:30.303]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:30.303] getGlobalsAndPackages() ...
  [20:24:30.304] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.304] Resolving globals: FALSE
  [20:24:30.305] The total size of the 1 globals is 672 bytes (672 bytes)
  [20:24:30.305] - globals: [1] '...future.x_ii'
  [20:24:30.305] 
  [20:24:30.306] getGlobalsAndPackages() ... DONE
  [20:24:30.307] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.308] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.312] {
  [20:24:30.312]     {
  [20:24:30.312]         ...future.startTime <- base::Sys.time()
  [20:24:30.312]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.312]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.312]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:30.312]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.312]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.312]         {
  [20:24:30.312]             {
  [20:24:30.312]                 {
  [20:24:30.312]                   has_future <- base::requireNamespace("future", 
  [20:24:30.312]                     quietly = TRUE)
  [20:24:30.312]                   version <- if (has_future) 
  [20:24:30.312]                     utils::packageVersion("future")
  [20:24:30.312]                   else NULL
  [20:24:30.312]                   if (!has_future || version < "1.8.0") {
  [20:24:30.312]                     info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.312]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.312]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.312]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.312]                         "release", "version")], collapse = " "), 
  [20:24:30.312]                       hostname = base::Sys.info()[["nodename"]])
  [20:24:30.312]                     info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.312]                       info)
  [20:24:30.312]                     info <- base::paste(info, collapse = "; ")
  [20:24:30.312]                     if (!has_future) {
  [20:24:30.312]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.312]                         info)
  [20:24:30.312]                     }
  [20:24:30.312]                     else {
  [20:24:30.312]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.312]                         info, version)
  [20:24:30.312]                     }
  [20:24:30.312]                     base::stop(msg)
  [20:24:30.312]                   }
  [20:24:30.312]                 }
  [20:24:30.312]                 base::local({
  [20:24:30.312]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.312]                     base::loadNamespace(pkg)
  [20:24:30.312]                     base::library(pkg, character.only = TRUE)
  [20:24:30.312]                   }
  [20:24:30.312]                 })
  [20:24:30.312]             }
  [20:24:30.312]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.312]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.312]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:30.312]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.312]             {
  [20:24:30.312]                 if (substitute) 
  [20:24:30.312]                   expr <- substitute(expr)
  [20:24:30.312]                 if (is.function(workers)) 
  [20:24:30.312]                   workers <- workers()
  [20:24:30.312]                 workers <- as.integer(workers)
  [20:24:30.312]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:30.312]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:30.312]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.312]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:30.312]                     local = TRUE, label = label, ...))
  [20:24:30.312]                 }
  [20:24:30.312]                 oopts <- options(mc.cores = workers)
  [20:24:30.312]                 on.exit(options(oopts))
  [20:24:30.312]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:30.312]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.312]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:30.312]                   label = label, ...)
  [20:24:30.312]                 if (!future$lazy) 
  [20:24:30.312]                   future <- run(future)
  [20:24:30.312]                 invisible(future)
  [20:24:30.312]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.312]         }
  [20:24:30.312]     }
  [20:24:30.312]     if (base::is.na(TRUE)) {
  [20:24:30.312]     }
  [20:24:30.312]     else {
  [20:24:30.312]         if (TRUE) {
  [20:24:30.312]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.312]                 open = "w")
  [20:24:30.312]         }
  [20:24:30.312]         else {
  [20:24:30.312]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.312]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.312]         }
  [20:24:30.312]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.312]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.312]             base::sink(type = "output", split = FALSE)
  [20:24:30.312]             base::close(...future.stdout)
  [20:24:30.312]         }, add = TRUE)
  [20:24:30.312]     }
  [20:24:30.312]     ...future.frame <- base::sys.nframe()
  [20:24:30.312]     ...future.conditions <- base::list()
  [20:24:30.312]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.312]     ...future.result <- base::tryCatch({
  [20:24:30.312]         base::withCallingHandlers({
  [20:24:30.312]             ...future.value <- base::withVisible(base::local({
  [20:24:30.312]                 doFuture::registerDoFuture()
  [20:24:30.312]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.312]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.312]                   {
  [20:24:30.312]                     a <- NULL
  [20:24:30.312]                     b <- NULL
  [20:24:30.312]                   }
  [20:24:30.312]                   ...future.env <- environment()
  [20:24:30.312]                   local({
  [20:24:30.312]                     for (name in names(...future.x_jj)) {
  [20:24:30.312]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.312]                         inherits = FALSE)
  [20:24:30.312]                     }
  [20:24:30.312]                   })
  [20:24:30.312]                   tryCatch({
  [20:24:30.312]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.312]                       plan = future::plan("next"))
  [20:24:30.312]                   }, error = identity)
  [20:24:30.312]                 })
  [20:24:30.312]             }))
  [20:24:30.312]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.312]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.312]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.312]                 version = "1.8")
  [20:24:30.312]         }, condition = base::local({
  [20:24:30.312]             c <- base::c
  [20:24:30.312]             inherits <- base::inherits
  [20:24:30.312]             invokeRestart <- base::invokeRestart
  [20:24:30.312]             length <- base::length
  [20:24:30.312]             list <- base::list
  [20:24:30.312]             seq.int <- base::seq.int
  [20:24:30.312]             signalCondition <- base::signalCondition
  [20:24:30.312]             sys.calls <- base::sys.calls
  [20:24:30.312]             Sys.time <- base::Sys.time
  [20:24:30.312]             `[[` <- base::`[[`
  [20:24:30.312]             `+` <- base::`+`
  [20:24:30.312]             `<<-` <- base::`<<-`
  [20:24:30.312]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.312]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.312]                   3L)]
  [20:24:30.312]             }
  [20:24:30.312]             function(cond) {
  [20:24:30.312]                 if (inherits(cond, "error")) {
  [20:24:30.312]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.312]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.312]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.312]                   signalCondition(cond)
  [20:24:30.312]                 }
  [20:24:30.312]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:30.312]                 ))) {
  [20:24:30.312]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:30.312]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.312]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.312]                   if (!signal) {
  [20:24:30.312]                     muffleCondition <- function (cond) 
  [20:24:30.312]                     {
  [20:24:30.312]                       inherits <- base::inherits
  [20:24:30.312]                       invokeRestart <- base::invokeRestart
  [20:24:30.312]                       muffled <- FALSE
  [20:24:30.312]                       if (inherits(cond, "message")) {
  [20:24:30.312]                         invokeRestart("muffleMessage")
  [20:24:30.312]                         muffled <- TRUE
  [20:24:30.312]                       }
  [20:24:30.312]                       else if (inherits(cond, "warning")) {
  [20:24:30.312]                         invokeRestart("muffleWarning")
  [20:24:30.312]                         muffled <- TRUE
  [20:24:30.312]                       }
  [20:24:30.312]                       else if (inherits(cond, "condition")) {
  [20:24:30.312]                         computeRestarts <- base::computeRestarts
  [20:24:30.312]                         grepl <- base::grepl
  [20:24:30.312]                         is.null <- base::is.null
  [20:24:30.312]                         restarts <- computeRestarts(cond)
  [20:24:30.312]                         for (restart in restarts) {
  [20:24:30.312]                           name <- restart$name
  [20:24:30.312]                           if (is.null(name)) 
  [20:24:30.312]                             next
  [20:24:30.312]                           if (!grepl("^muffle", name)) 
  [20:24:30.312]                             next
  [20:24:30.312]                           invokeRestart(restart)
  [20:24:30.312]                           muffled <- TRUE
  [20:24:30.312]                           break
  [20:24:30.312]                         }
  [20:24:30.312]                       }
  [20:24:30.312]                       invisible(muffled)
  [20:24:30.312]                     }
  [20:24:30.312]                     muffleCondition(cond)
  [20:24:30.312]                   }
  [20:24:30.312]                 }
  [20:24:30.312]             }
  [20:24:30.312]         }))
  [20:24:30.312]     }, error = function(ex) {
  [20:24:30.312]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.312]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.312]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.312]     }, finally = {
  [20:24:30.312]         {
  [20:24:30.312]             NULL
  [20:24:30.312]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.312]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.312]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.312]                 label = NULL, ...) 
  [20:24:30.312]             {
  [20:24:30.312]                 if (substitute) 
  [20:24:30.312]                   expr <- substitute(expr)
  [20:24:30.312]                 local <- as.logical(local)
  [20:24:30.312]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.312]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.312]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.312]                   label = label, ...)
  [20:24:30.312]                 if (!future$lazy) 
  [20:24:30.312]                   future <- run(future)
  [20:24:30.312]                 invisible(future)
  [20:24:30.312]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.312]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:30.312]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.312]             {
  [20:24:30.312]                 if (substitute) 
  [20:24:30.312]                   expr <- substitute(expr)
  [20:24:30.312]                 if (is.function(workers)) 
  [20:24:30.312]                   workers <- workers()
  [20:24:30.312]                 workers <- as.integer(workers)
  [20:24:30.312]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:30.312]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:30.312]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.312]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:30.312]                     local = TRUE, label = label, ...))
  [20:24:30.312]                 }
  [20:24:30.312]                 oopts <- options(mc.cores = workers)
  [20:24:30.312]                 on.exit(options(oopts))
  [20:24:30.312]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:30.312]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.312]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:30.312]                   label = label, ...)
  [20:24:30.312]                 if (!future$lazy) 
  [20:24:30.312]                   future <- run(future)
  [20:24:30.312]                 invisible(future)
  [20:24:30.312]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.312]         }
  [20:24:30.312]         base::options(...future.oldOptions)
  [20:24:30.312]     })
  [20:24:30.312]     Sys.time
  [20:24:30.312]     if (base::is.na(TRUE)) {
  [20:24:30.312]     }
  [20:24:30.312]     else {
  [20:24:30.312]         base::sink(type = "output", split = FALSE)
  [20:24:30.312]         if (TRUE) {
  [20:24:30.312]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.312]         }
  [20:24:30.312]         else {
  [20:24:30.312]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.312]         }
  [20:24:30.312]         base::close(...future.stdout)
  [20:24:30.312]         ...future.stdout <- NULL
  [20:24:30.312]     }
  [20:24:30.312]     ...future.result$conditions <- ...future.conditions
  [20:24:30.312]     ...future.result
  [20:24:30.312] }
  [20:24:30.334] plan(): Setting new future strategy stack:
  [20:24:30.335] List of future strategies:
  [20:24:30.335] 1. multicore:
  [20:24:30.335]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.335]    - tweaked: FALSE
  [20:24:30.335]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.371] plan(): nbrOfWorkers() = 2
  [20:24:30.373] plan(): Setting new future strategy stack:
  [20:24:30.373] List of future strategies:
  [20:24:30.373] 1. sequential:
  [20:24:30.373]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.373]    - tweaked: FALSE
  [20:24:30.373]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.373] 2. multicore:
  [20:24:30.373]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.373]    - tweaked: FALSE
  [20:24:30.373]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.374] plan(): nbrOfWorkers() = 1
  [20:24:30.375] SequentialFuture started (and completed)
  [20:24:30.375] Chunk #1 of 1 ... DONE
  [20:24:30.375] Launching 1 futures (chunks) ... DONE
  [20:24:30.376] - resolving futures
  [20:24:30.376]   - gathering results & relaying conditions (except errors)
  [20:24:30.376] resolve() on list ...
  [20:24:30.376]  recursive: 0
  [20:24:30.376]  length: 1
  [20:24:30.377] 
  [20:24:30.377] Future #1
  [20:24:30.377] signalConditionsASAP(SequentialFuture, pos=1) ...
  [20:24:30.377] - nx: 1
  [20:24:30.378] - relay: TRUE
  [20:24:30.378] - stdout: TRUE
  [20:24:30.378] - signal: TRUE
  [20:24:30.378] - resignal: FALSE
  [20:24:30.379] - force: FALSE
  [20:24:30.379] - relayed: [n=1] FALSE
  [20:24:30.379] - queued futures: [n=1] FALSE
  [20:24:30.379]  - until=1
  [20:24:30.380]  - relaying element #1
  [20:24:30.380] - relayed: [n=1] TRUE
  [20:24:30.380] - queued futures: [n=1] TRUE
  [20:24:30.381] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [20:24:30.381]  length: 0 (resolved future 1)
  [20:24:30.381] Relaying remaining futures
  [20:24:30.381] signalConditionsASAP(NULL, pos=0) ...
  [20:24:30.382] - nx: 1
  [20:24:30.382] - relay: TRUE
  [20:24:30.382] - stdout: TRUE
  [20:24:30.382] - signal: TRUE
  [20:24:30.385] - resignal: FALSE
  [20:24:30.402] - force: FALSE
  [20:24:30.402] - relayed: [n=1] TRUE
  [20:24:30.402] - queued futures: [n=1] TRUE
   - flush all
  [20:24:30.403] - relayed: [n=1] TRUE
  [20:24:30.403] - queued futures: [n=1] TRUE
  [20:24:30.403] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:30.403] resolve() on list ... DONE
  [20:24:30.404] - collecting values of futures
  [20:24:30.404] - accumulating results
  [20:24:30.406] - processing errors (handler = 'stop')
  [20:24:30.406] - extracting results
  [20:24:30.407] doFuture() ... DONE
  - plan(list('sequential', 'multicore')) ... DONE
  - plan(list('sequential', 'multisession')) ...
  [20:24:30.408] plan(): Setting new future strategy stack:
  [20:24:30.408] List of future strategies:
  [20:24:30.408] 1. sequential:
  [20:24:30.408]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.408]    - tweaked: FALSE
  [20:24:30.408]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.408] 2. multisession:
  [20:24:30.408]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.408]    - tweaked: FALSE
  [20:24:30.408]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.409] plan(): nbrOfWorkers() = 1
  [20:24:30.410] doFuture() ...
  [20:24:30.413] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:30.415] - R expression:
  [20:24:30.416] {
  [20:24:30.416]     doFuture::registerDoFuture()
  [20:24:30.416]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.416]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.416]         {
  [20:24:30.416]             a <- NULL
  [20:24:30.416]             b <- NULL
  [20:24:30.416]         }
  [20:24:30.416]         ...future.env <- environment()
  [20:24:30.416]         local({
  [20:24:30.416]             for (name in names(...future.x_jj)) {
  [20:24:30.416]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.416]                   inherits = FALSE)
  [20:24:30.416]             }
  [20:24:30.416]         })
  [20:24:30.416]         tryCatch({
  [20:24:30.416]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.416]                 plan = future::plan("next"))
  [20:24:30.416]         }, error = identity)
  [20:24:30.416]     })
  [20:24:30.416] }
  [20:24:30.416] - identifying globals and packages ...
  [20:24:30.417] getGlobalsAndPackages() ...
  [20:24:30.417] Searching for globals...
  [20:24:30.429] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:30.446] Searching for globals ... DONE
  [20:24:30.446] Resolving globals: FALSE
  [20:24:30.447] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:30.448] - globals: [1] '...future.x_ii'
  [20:24:30.448] 
  [20:24:30.448] getGlobalsAndPackages() ... DONE
  [20:24:30.449] List of 1
  [20:24:30.449]  $ ...future.x_ii: NULL
  [20:24:30.449]  - attr(*, "where")=List of 1
  [20:24:30.449]   ..$ ...future.x_ii:<environment: 0x55bc21361668> 
  [20:24:30.449]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.449]  - attr(*, "resolved")= logi FALSE
  [20:24:30.449]  - attr(*, "total_size")= num 0
  [20:24:30.454]   - R expression:
  [20:24:30.454] {
  [20:24:30.454]     doFuture::registerDoFuture()
  [20:24:30.454]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.454]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.454]         {
  [20:24:30.454]             a <- NULL
  [20:24:30.454]             b <- NULL
  [20:24:30.454]         }
  [20:24:30.454]         ...future.env <- environment()
  [20:24:30.454]         local({
  [20:24:30.454]             for (name in names(...future.x_jj)) {
  [20:24:30.454]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.454]                   inherits = FALSE)
  [20:24:30.454]             }
  [20:24:30.454]         })
  [20:24:30.454]         tryCatch({
  [20:24:30.454]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.454]                 plan = future::plan("next"))
  [20:24:30.454]         }, error = identity)
  [20:24:30.454]     })
  [20:24:30.454] }
  [20:24:30.455]   - globals: [1] '...future.x_ii'
  [20:24:30.455] List of 1
  [20:24:30.455]  $ ...future.x_ii: NULL
  [20:24:30.455]  - attr(*, "where")=List of 1
  [20:24:30.455]   ..$ ...future.x_ii:<environment: 0x55bc21361668> 
  [20:24:30.455]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.455]  - attr(*, "resolved")= logi FALSE
  [20:24:30.455]  - attr(*, "total_size")= num 0
  [20:24:30.460]   - packages: [1] 'doFuture'
  [20:24:30.460] - identifying globals and packages ... DONE
  [20:24:30.460] Number of chunks: 1
  [20:24:30.461] Number of futures (= number of chunks): 1
  [20:24:30.461] Launching 1 futures (chunks) ...
  [20:24:30.461] Chunk #1 of 1 ...
  [20:24:30.478]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:30.478] getGlobalsAndPackages() ...
  [20:24:30.478] Searching for globals...
  [20:24:30.479] 
  [20:24:30.480] Searching for globals ... DONE
  [20:24:30.480] - globals: [0] <none>
  [20:24:30.480] getGlobalsAndPackages() ... DONE
  [20:24:30.480] 
  [20:24:30.481] 
  [20:24:30.481]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:30.481] getGlobalsAndPackages() ...
  [20:24:30.481] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.482] Resolving globals: FALSE
  [20:24:30.483] The total size of the 1 globals is 672 bytes (672 bytes)
  [20:24:30.483] - globals: [1] '...future.x_ii'
  [20:24:30.483] 
  [20:24:30.483] getGlobalsAndPackages() ... DONE
  [20:24:30.489] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.490] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.511] {
  [20:24:30.511]     {
  [20:24:30.511]         ...future.startTime <- base::Sys.time()
  [20:24:30.511]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.511]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.511]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:30.511]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.511]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.511]         {
  [20:24:30.511]             {
  [20:24:30.511]                 {
  [20:24:30.511]                   has_future <- base::requireNamespace("future", 
  [20:24:30.511]                     quietly = TRUE)
  [20:24:30.511]                   version <- if (has_future) 
  [20:24:30.511]                     utils::packageVersion("future")
  [20:24:30.511]                   else NULL
  [20:24:30.511]                   if (!has_future || version < "1.8.0") {
  [20:24:30.511]                     info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.511]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.511]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.511]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.511]                         "release", "version")], collapse = " "), 
  [20:24:30.511]                       hostname = base::Sys.info()[["nodename"]])
  [20:24:30.511]                     info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.511]                       info)
  [20:24:30.511]                     info <- base::paste(info, collapse = "; ")
  [20:24:30.511]                     if (!has_future) {
  [20:24:30.511]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.511]                         info)
  [20:24:30.511]                     }
  [20:24:30.511]                     else {
  [20:24:30.511]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.511]                         info, version)
  [20:24:30.511]                     }
  [20:24:30.511]                     base::stop(msg)
  [20:24:30.511]                   }
  [20:24:30.511]                 }
  [20:24:30.511]                 base::local({
  [20:24:30.511]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.511]                     base::loadNamespace(pkg)
  [20:24:30.511]                     base::library(pkg, character.only = TRUE)
  [20:24:30.511]                   }
  [20:24:30.511]                 })
  [20:24:30.511]             }
  [20:24:30.511]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.511]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.511]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:30.511]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:30.511]                 ...) 
  [20:24:30.511]             {
  [20:24:30.511]                 if (substitute) 
  [20:24:30.511]                   expr <- substitute(expr)
  [20:24:30.511]                 if (is.function(workers)) 
  [20:24:30.511]                   workers <- workers()
  [20:24:30.511]                 workers <- as.integer(workers)
  [20:24:30.511]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:30.511]                   workers >= 1)
  [20:24:30.511]                 if (workers == 1L) {
  [20:24:30.511]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.511]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:30.511]                     local = TRUE, label = label, ...))
  [20:24:30.511]                 }
  [20:24:30.511]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:30.511]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:30.511]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.511]                   globals = globals, persistent = persistent, 
  [20:24:30.511]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:30.511]                   label = label, ...)
  [20:24:30.511]                 if (!future$lazy) 
  [20:24:30.511]                   future <- run(future)
  [20:24:30.511]                 invisible(future)
  [20:24:30.511]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.511]         }
  [20:24:30.511]     }
  [20:24:30.511]     if (base::is.na(TRUE)) {
  [20:24:30.511]     }
  [20:24:30.511]     else {
  [20:24:30.511]         if (TRUE) {
  [20:24:30.511]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.511]                 open = "w")
  [20:24:30.511]         }
  [20:24:30.511]         else {
  [20:24:30.511]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.511]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.511]         }
  [20:24:30.511]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.511]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.511]             base::sink(type = "output", split = FALSE)
  [20:24:30.511]             base::close(...future.stdout)
  [20:24:30.511]         }, add = TRUE)
  [20:24:30.511]     }
  [20:24:30.511]     ...future.frame <- base::sys.nframe()
  [20:24:30.511]     ...future.conditions <- base::list()
  [20:24:30.511]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.511]     ...future.result <- base::tryCatch({
  [20:24:30.511]         base::withCallingHandlers({
  [20:24:30.511]             ...future.value <- base::withVisible(base::local({
  [20:24:30.511]                 doFuture::registerDoFuture()
  [20:24:30.511]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.511]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.511]                   {
  [20:24:30.511]                     a <- NULL
  [20:24:30.511]                     b <- NULL
  [20:24:30.511]                   }
  [20:24:30.511]                   ...future.env <- environment()
  [20:24:30.511]                   local({
  [20:24:30.511]                     for (name in names(...future.x_jj)) {
  [20:24:30.511]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.511]                         inherits = FALSE)
  [20:24:30.511]                     }
  [20:24:30.511]                   })
  [20:24:30.511]                   tryCatch({
  [20:24:30.511]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.511]                       plan = future::plan("next"))
  [20:24:30.511]                   }, error = identity)
  [20:24:30.511]                 })
  [20:24:30.511]             }))
  [20:24:30.511]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.511]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.511]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.511]                 version = "1.8")
  [20:24:30.511]         }, condition = base::local({
  [20:24:30.511]             c <- base::c
  [20:24:30.511]             inherits <- base::inherits
  [20:24:30.511]             invokeRestart <- base::invokeRestart
  [20:24:30.511]             length <- base::length
  [20:24:30.511]             list <- base::list
  [20:24:30.511]             seq.int <- base::seq.int
  [20:24:30.511]             signalCondition <- base::signalCondition
  [20:24:30.511]             sys.calls <- base::sys.calls
  [20:24:30.511]             Sys.time <- base::Sys.time
  [20:24:30.511]             `[[` <- base::`[[`
  [20:24:30.511]             `+` <- base::`+`
  [20:24:30.511]             `<<-` <- base::`<<-`
  [20:24:30.511]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.511]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.511]                   3L)]
  [20:24:30.511]             }
  [20:24:30.511]             function(cond) {
  [20:24:30.511]                 if (inherits(cond, "error")) {
  [20:24:30.511]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.511]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.511]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.511]                   signalCondition(cond)
  [20:24:30.511]                 }
  [20:24:30.511]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:30.511]                 ))) {
  [20:24:30.511]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:30.511]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.511]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.511]                   if (!signal) {
  [20:24:30.511]                     muffleCondition <- function (cond) 
  [20:24:30.511]                     {
  [20:24:30.511]                       inherits <- base::inherits
  [20:24:30.511]                       invokeRestart <- base::invokeRestart
  [20:24:30.511]                       muffled <- FALSE
  [20:24:30.511]                       if (inherits(cond, "message")) {
  [20:24:30.511]                         invokeRestart("muffleMessage")
  [20:24:30.511]                         muffled <- TRUE
  [20:24:30.511]                       }
  [20:24:30.511]                       else if (inherits(cond, "warning")) {
  [20:24:30.511]                         invokeRestart("muffleWarning")
  [20:24:30.511]                         muffled <- TRUE
  [20:24:30.511]                       }
  [20:24:30.511]                       else if (inherits(cond, "condition")) {
  [20:24:30.511]                         computeRestarts <- base::computeRestarts
  [20:24:30.511]                         grepl <- base::grepl
  [20:24:30.511]                         is.null <- base::is.null
  [20:24:30.511]                         restarts <- computeRestarts(cond)
  [20:24:30.511]                         for (restart in restarts) {
  [20:24:30.511]                           name <- restart$name
  [20:24:30.511]                           if (is.null(name)) 
  [20:24:30.511]                             next
  [20:24:30.511]                           if (!grepl("^muffle", name)) 
  [20:24:30.511]                             next
  [20:24:30.511]                           invokeRestart(restart)
  [20:24:30.511]                           muffled <- TRUE
  [20:24:30.511]                           break
  [20:24:30.511]                         }
  [20:24:30.511]                       }
  [20:24:30.511]                       invisible(muffled)
  [20:24:30.511]                     }
  [20:24:30.511]                     muffleCondition(cond)
  [20:24:30.511]                   }
  [20:24:30.511]                 }
  [20:24:30.511]             }
  [20:24:30.511]         }))
  [20:24:30.511]     }, error = function(ex) {
  [20:24:30.511]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.511]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.511]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.511]     }, finally = {
  [20:24:30.511]         {
  [20:24:30.511]             NULL
  [20:24:30.511]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.511]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.511]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.511]                 label = NULL, ...) 
  [20:24:30.511]             {
  [20:24:30.511]                 if (substitute) 
  [20:24:30.511]                   expr <- substitute(expr)
  [20:24:30.511]                 local <- as.logical(local)
  [20:24:30.511]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.511]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.511]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.511]                   label = label, ...)
  [20:24:30.511]                 if (!future$lazy) 
  [20:24:30.511]                   future <- run(future)
  [20:24:30.511]                 invisible(future)
  [20:24:30.511]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.511]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:30.511]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:24:30.511]                 label = NULL, ...) 
  [20:24:30.511]             {
  [20:24:30.511]                 if (substitute) 
  [20:24:30.511]                   expr <- substitute(expr)
  [20:24:30.511]                 if (is.function(workers)) 
  [20:24:30.511]                   workers <- workers()
  [20:24:30.511]                 workers <- as.integer(workers)
  [20:24:30.511]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:30.511]                   workers >= 1)
  [20:24:30.511]                 if (workers == 1L) {
  [20:24:30.511]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.511]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:30.511]                     local = TRUE, label = label, ...))
  [20:24:30.511]                 }
  [20:24:30.511]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:30.511]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:30.511]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.511]                   globals = globals, persistent = persistent, 
  [20:24:30.511]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:30.511]                   label = label, ...)
  [20:24:30.511]                 if (!future$lazy) 
  [20:24:30.511]                   future <- run(future)
  [20:24:30.511]                 invisible(future)
  [20:24:30.511]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.511]         }
  [20:24:30.511]         base::options(...future.oldOptions)
  [20:24:30.511]     })
  [20:24:30.511]     Sys.time
  [20:24:30.511]     if (base::is.na(TRUE)) {
  [20:24:30.511]     }
  [20:24:30.511]     else {
  [20:24:30.511]         base::sink(type = "output", split = FALSE)
  [20:24:30.511]         if (TRUE) {
  [20:24:30.511]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.511]         }
  [20:24:30.511]         else {
  [20:24:30.511]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.511]         }
  [20:24:30.511]         base::close(...future.stdout)
  [20:24:30.511]         ...future.stdout <- NULL
  [20:24:30.511]     }
  [20:24:30.511]     ...future.result$conditions <- ...future.conditions
  [20:24:30.511]     ...future.result
  [20:24:30.511] }
  [20:24:30.517] plan(): Setting new future strategy stack:
  [20:24:30.517] List of future strategies:
  [20:24:30.517] 1. multisession:
  [20:24:30.517]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.517]    - tweaked: FALSE
  [20:24:30.517]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.518] plan(): nbrOfWorkers() = 2
  [20:24:30.520] plan(): Setting new future strategy stack:
  [20:24:30.521] List of future strategies:
  [20:24:30.521] 1. sequential:
  [20:24:30.521]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.521]    - tweaked: FALSE
  [20:24:30.521]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.521] 2. multisession:
  [20:24:30.521]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.521]    - tweaked: FALSE
  [20:24:30.521]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.522] plan(): nbrOfWorkers() = 1
  [20:24:30.522] SequentialFuture started (and completed)
  [20:24:30.523] Chunk #1 of 1 ... DONE
  [20:24:30.523] Launching 1 futures (chunks) ... DONE
  [20:24:30.523] - resolving futures
  [20:24:30.523]   - gathering results & relaying conditions (except errors)
  [20:24:30.524] resolve() on list ...
  [20:24:30.524]  recursive: 0
  [20:24:30.524]  length: 1
  [20:24:30.524] 
  [20:24:30.525] Future #1
  [20:24:30.525] signalConditionsASAP(SequentialFuture, pos=1) ...
  [20:24:30.525] - nx: 1
  [20:24:30.525] - relay: TRUE
  [20:24:30.542] - stdout: TRUE
  [20:24:30.542] - signal: TRUE
  [20:24:30.542] - resignal: FALSE
  [20:24:30.543] - force: FALSE
  [20:24:30.543] - relayed: [n=1] FALSE
  [20:24:30.543] - queued futures: [n=1] FALSE
  [20:24:30.543]  - until=1
  [20:24:30.544]  - relaying element #1
  [20:24:30.544] - relayed: [n=1] TRUE
  [20:24:30.544] - queued futures: [n=1] TRUE
  [20:24:30.545] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [20:24:30.545]  length: 0 (resolved future 1)
  [20:24:30.545] Relaying remaining futures
  [20:24:30.545] signalConditionsASAP(NULL, pos=0) ...
  [20:24:30.546] - nx: 1
  [20:24:30.546] - relay: TRUE
  [20:24:30.546] - stdout: TRUE
  [20:24:30.546] - signal: TRUE
  [20:24:30.547] - resignal: FALSE
  [20:24:30.547] - force: FALSE
  [20:24:30.547] - relayed: [n=1] TRUE
  [20:24:30.547] - queued futures: [n=1] TRUE
   - flush all
  [20:24:30.548] - relayed: [n=1] TRUE
  [20:24:30.548] - queued futures: [n=1] TRUE
  [20:24:30.548] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:30.548] resolve() on list ... DONE
  [20:24:30.549] - collecting values of futures
  [20:24:30.549] - accumulating results
  [20:24:30.551] - processing errors (handler = 'stop')
  [20:24:30.552] - extracting results
  [20:24:30.552] doFuture() ... DONE
  - plan(list('sequential', 'multisession')) ... DONE
  - plan(list('sequential', 'cluster')) ...
  [20:24:30.553] plan(): Setting new future strategy stack:
  [20:24:30.553] List of future strategies:
  [20:24:30.553] 1. sequential:
  [20:24:30.553]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.553]    - tweaked: FALSE
  [20:24:30.553]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.553] 2. cluster:
  [20:24:30.553]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.553]    - tweaked: FALSE
  [20:24:30.553]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.555] plan(): nbrOfWorkers() = 1
  [20:24:30.555] doFuture() ...
  [20:24:30.575] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:30.576] - R expression:
  [20:24:30.576] {
  [20:24:30.576]     doFuture::registerDoFuture()
  [20:24:30.576]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.576]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.576]         {
  [20:24:30.576]             a <- NULL
  [20:24:30.576]             b <- NULL
  [20:24:30.576]         }
  [20:24:30.576]         ...future.env <- environment()
  [20:24:30.576]         local({
  [20:24:30.576]             for (name in names(...future.x_jj)) {
  [20:24:30.576]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.576]                   inherits = FALSE)
  [20:24:30.576]             }
  [20:24:30.576]         })
  [20:24:30.576]         tryCatch({
  [20:24:30.576]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.576]                 plan = future::plan("next"))
  [20:24:30.576]         }, error = identity)
  [20:24:30.576]     })
  [20:24:30.576] }
  [20:24:30.577] - identifying globals and packages ...
  [20:24:30.577] getGlobalsAndPackages() ...
  [20:24:30.578] Searching for globals...
  [20:24:30.607] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:30.608] Searching for globals ... DONE
  [20:24:30.608] Resolving globals: FALSE
  [20:24:30.612] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:30.612] - globals: [1] '...future.x_ii'
  [20:24:30.613] 
  [20:24:30.613] getGlobalsAndPackages() ... DONE
  [20:24:30.613] List of 1
  [20:24:30.613]  $ ...future.x_ii: NULL
  [20:24:30.613]  - attr(*, "where")=List of 1
  [20:24:30.613]   ..$ ...future.x_ii:<environment: 0x55bc233d0490> 
  [20:24:30.613]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.613]  - attr(*, "resolved")= logi FALSE
  [20:24:30.613]  - attr(*, "total_size")= num 0
  [20:24:30.619]   - R expression:
  [20:24:30.619] {
  [20:24:30.619]     doFuture::registerDoFuture()
  [20:24:30.619]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.619]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.619]         {
  [20:24:30.619]             a <- NULL
  [20:24:30.619]             b <- NULL
  [20:24:30.619]         }
  [20:24:30.619]         ...future.env <- environment()
  [20:24:30.619]         local({
  [20:24:30.619]             for (name in names(...future.x_jj)) {
  [20:24:30.619]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.619]                   inherits = FALSE)
  [20:24:30.619]             }
  [20:24:30.619]         })
  [20:24:30.619]         tryCatch({
  [20:24:30.619]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.619]                 plan = future::plan("next"))
  [20:24:30.619]         }, error = identity)
  [20:24:30.619]     })
  [20:24:30.619] }
  [20:24:30.620]   - globals: [1] '...future.x_ii'
  [20:24:30.620] List of 1
  [20:24:30.620]  $ ...future.x_ii: NULL
  [20:24:30.620]  - attr(*, "where")=List of 1
  [20:24:30.620]   ..$ ...future.x_ii:<environment: 0x55bc233d0490> 
  [20:24:30.620]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.620]  - attr(*, "resolved")= logi FALSE
  [20:24:30.620]  - attr(*, "total_size")= num 0
  [20:24:30.642]   - packages: [1] 'doFuture'
  [20:24:30.643] - identifying globals and packages ... DONE
  [20:24:30.643] Number of chunks: 1
  [20:24:30.643] Number of futures (= number of chunks): 1
  [20:24:30.644] Launching 1 futures (chunks) ...
  [20:24:30.644] Chunk #1 of 1 ...
  [20:24:30.644]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:30.645] getGlobalsAndPackages() ...
  [20:24:30.645] Searching for globals...
  [20:24:30.646] 
  [20:24:30.646] Searching for globals ... DONE
  [20:24:30.646] - globals: [0] <none>
  [20:24:30.647] getGlobalsAndPackages() ... DONE
  [20:24:30.647] 
  [20:24:30.647] 
  [20:24:30.647]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:30.648] getGlobalsAndPackages() ...
  [20:24:30.648] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.648] Resolving globals: FALSE
  [20:24:30.649] The total size of the 1 globals is 672 bytes (672 bytes)
  [20:24:30.650] - globals: [1] '...future.x_ii'
  [20:24:30.650] 
  [20:24:30.650] getGlobalsAndPackages() ... DONE
  [20:24:30.652] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.652] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.673] {
  [20:24:30.673]     {
  [20:24:30.673]         ...future.startTime <- base::Sys.time()
  [20:24:30.673]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.673]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.673]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:30.673]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.673]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.673]         {
  [20:24:30.673]             {
  [20:24:30.673]                 {
  [20:24:30.673]                   has_future <- base::requireNamespace("future", 
  [20:24:30.673]                     quietly = TRUE)
  [20:24:30.673]                   version <- if (has_future) 
  [20:24:30.673]                     utils::packageVersion("future")
  [20:24:30.673]                   else NULL
  [20:24:30.673]                   if (!has_future || version < "1.8.0") {
  [20:24:30.673]                     info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.673]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.673]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.673]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.673]                         "release", "version")], collapse = " "), 
  [20:24:30.673]                       hostname = base::Sys.info()[["nodename"]])
  [20:24:30.673]                     info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.673]                       info)
  [20:24:30.673]                     info <- base::paste(info, collapse = "; ")
  [20:24:30.673]                     if (!has_future) {
  [20:24:30.673]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.673]                         info)
  [20:24:30.673]                     }
  [20:24:30.673]                     else {
  [20:24:30.673]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.673]                         info, version)
  [20:24:30.673]                     }
  [20:24:30.673]                     base::stop(msg)
  [20:24:30.673]                   }
  [20:24:30.673]                 }
  [20:24:30.673]                 base::local({
  [20:24:30.673]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.673]                     base::loadNamespace(pkg)
  [20:24:30.673]                     base::library(pkg, character.only = TRUE)
  [20:24:30.673]                   }
  [20:24:30.673]                 })
  [20:24:30.673]             }
  [20:24:30.673]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.673]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.673]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:24:30.673]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:24:30.673]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:30.673]                 ...) 
  [20:24:30.673]             {
  [20:24:30.673]                 if (substitute) 
  [20:24:30.673]                   expr <- substitute(expr)
  [20:24:30.673]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:30.673]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.673]                   globals = globals, persistent = persistent, 
  [20:24:30.673]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:30.673]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:30.673]                   label = label, ...)
  [20:24:30.673]                 if (!future$lazy) 
  [20:24:30.673]                   future <- run(future)
  [20:24:30.673]                 invisible(future)
  [20:24:30.673]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.673]         }
  [20:24:30.673]     }
  [20:24:30.673]     if (base::is.na(TRUE)) {
  [20:24:30.673]     }
  [20:24:30.673]     else {
  [20:24:30.673]         if (TRUE) {
  [20:24:30.673]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.673]                 open = "w")
  [20:24:30.673]         }
  [20:24:30.673]         else {
  [20:24:30.673]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.673]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.673]         }
  [20:24:30.673]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.673]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.673]             base::sink(type = "output", split = FALSE)
  [20:24:30.673]             base::close(...future.stdout)
  [20:24:30.673]         }, add = TRUE)
  [20:24:30.673]     }
  [20:24:30.673]     ...future.frame <- base::sys.nframe()
  [20:24:30.673]     ...future.conditions <- base::list()
  [20:24:30.673]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.673]     ...future.result <- base::tryCatch({
  [20:24:30.673]         base::withCallingHandlers({
  [20:24:30.673]             ...future.value <- base::withVisible(base::local({
  [20:24:30.673]                 doFuture::registerDoFuture()
  [20:24:30.673]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.673]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.673]                   {
  [20:24:30.673]                     a <- NULL
  [20:24:30.673]                     b <- NULL
  [20:24:30.673]                   }
  [20:24:30.673]                   ...future.env <- environment()
  [20:24:30.673]                   local({
  [20:24:30.673]                     for (name in names(...future.x_jj)) {
  [20:24:30.673]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.673]                         inherits = FALSE)
  [20:24:30.673]                     }
  [20:24:30.673]                   })
  [20:24:30.673]                   tryCatch({
  [20:24:30.673]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.673]                       plan = future::plan("next"))
  [20:24:30.673]                   }, error = identity)
  [20:24:30.673]                 })
  [20:24:30.673]             }))
  [20:24:30.673]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.673]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.673]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.673]                 version = "1.8")
  [20:24:30.673]         }, condition = base::local({
  [20:24:30.673]             c <- base::c
  [20:24:30.673]             inherits <- base::inherits
  [20:24:30.673]             invokeRestart <- base::invokeRestart
  [20:24:30.673]             length <- base::length
  [20:24:30.673]             list <- base::list
  [20:24:30.673]             seq.int <- base::seq.int
  [20:24:30.673]             signalCondition <- base::signalCondition
  [20:24:30.673]             sys.calls <- base::sys.calls
  [20:24:30.673]             Sys.time <- base::Sys.time
  [20:24:30.673]             `[[` <- base::`[[`
  [20:24:30.673]             `+` <- base::`+`
  [20:24:30.673]             `<<-` <- base::`<<-`
  [20:24:30.673]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.673]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.673]                   3L)]
  [20:24:30.673]             }
  [20:24:30.673]             function(cond) {
  [20:24:30.673]                 if (inherits(cond, "error")) {
  [20:24:30.673]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.673]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.673]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.673]                   signalCondition(cond)
  [20:24:30.673]                 }
  [20:24:30.673]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:30.673]                 ))) {
  [20:24:30.673]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:30.673]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.673]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.673]                   if (!signal) {
  [20:24:30.673]                     muffleCondition <- function (cond) 
  [20:24:30.673]                     {
  [20:24:30.673]                       inherits <- base::inherits
  [20:24:30.673]                       invokeRestart <- base::invokeRestart
  [20:24:30.673]                       muffled <- FALSE
  [20:24:30.673]                       if (inherits(cond, "message")) {
  [20:24:30.673]                         invokeRestart("muffleMessage")
  [20:24:30.673]                         muffled <- TRUE
  [20:24:30.673]                       }
  [20:24:30.673]                       else if (inherits(cond, "warning")) {
  [20:24:30.673]                         invokeRestart("muffleWarning")
  [20:24:30.673]                         muffled <- TRUE
  [20:24:30.673]                       }
  [20:24:30.673]                       else if (inherits(cond, "condition")) {
  [20:24:30.673]                         computeRestarts <- base::computeRestarts
  [20:24:30.673]                         grepl <- base::grepl
  [20:24:30.673]                         is.null <- base::is.null
  [20:24:30.673]                         restarts <- computeRestarts(cond)
  [20:24:30.673]                         for (restart in restarts) {
  [20:24:30.673]                           name <- restart$name
  [20:24:30.673]                           if (is.null(name)) 
  [20:24:30.673]                             next
  [20:24:30.673]                           if (!grepl("^muffle", name)) 
  [20:24:30.673]                             next
  [20:24:30.673]                           invokeRestart(restart)
  [20:24:30.673]                           muffled <- TRUE
  [20:24:30.673]                           break
  [20:24:30.673]                         }
  [20:24:30.673]                       }
  [20:24:30.673]                       invisible(muffled)
  [20:24:30.673]                     }
  [20:24:30.673]                     muffleCondition(cond)
  [20:24:30.673]                   }
  [20:24:30.673]                 }
  [20:24:30.673]             }
  [20:24:30.673]         }))
  [20:24:30.673]     }, error = function(ex) {
  [20:24:30.673]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.673]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.673]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.673]     }, finally = {
  [20:24:30.673]         {
  [20:24:30.673]             NULL
  [20:24:30.673]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.673]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.673]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.673]                 label = NULL, ...) 
  [20:24:30.673]             {
  [20:24:30.673]                 if (substitute) 
  [20:24:30.673]                   expr <- substitute(expr)
  [20:24:30.673]                 local <- as.logical(local)
  [20:24:30.673]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.673]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.673]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.673]                   label = label, ...)
  [20:24:30.673]                 if (!future$lazy) 
  [20:24:30.673]                   future <- run(future)
  [20:24:30.673]                 invisible(future)
  [20:24:30.673]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.673]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:30.673]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [20:24:30.673]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [20:24:30.673]                 label = NULL, ...) 
  [20:24:30.673]             {
  [20:24:30.673]                 if (substitute) 
  [20:24:30.673]                   expr <- substitute(expr)
  [20:24:30.673]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:30.673]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.673]                   globals = globals, persistent = persistent, 
  [20:24:30.673]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:30.673]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:30.673]                   label = label, ...)
  [20:24:30.673]                 if (!future$lazy) 
  [20:24:30.673]                   future <- run(future)
  [20:24:30.673]                 invisible(future)
  [20:24:30.673]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.673]         }
  [20:24:30.673]         base::options(...future.oldOptions)
  [20:24:30.673]     })
  [20:24:30.673]     Sys.time
  [20:24:30.673]     if (base::is.na(TRUE)) {
  [20:24:30.673]     }
  [20:24:30.673]     else {
  [20:24:30.673]         base::sink(type = "output", split = FALSE)
  [20:24:30.673]         if (TRUE) {
  [20:24:30.673]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.673]         }
  [20:24:30.673]         else {
  [20:24:30.673]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.673]         }
  [20:24:30.673]         base::close(...future.stdout)
  [20:24:30.673]         ...future.stdout <- NULL
  [20:24:30.673]     }
  [20:24:30.673]     ...future.result$conditions <- ...future.conditions
  [20:24:30.673]     ...future.result
  [20:24:30.673] }
  [20:24:30.679] plan(): Setting new future strategy stack:
  [20:24:30.679] List of future strategies:
  [20:24:30.679] 1. cluster:
  [20:24:30.679]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.679]    - tweaked: FALSE
  [20:24:30.679]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.682] plan(): nbrOfWorkers() = 2
  [20:24:30.684] plan(): Setting new future strategy stack:
  [20:24:30.684] List of future strategies:
  [20:24:30.684] 1. sequential:
  [20:24:30.684]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.684]    - tweaked: FALSE
  [20:24:30.684]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.684] 2. cluster:
  [20:24:30.684]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.684]    - tweaked: FALSE
  [20:24:30.684]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.685] plan(): nbrOfWorkers() = 1
  [20:24:30.702] SequentialFuture started (and completed)
  [20:24:30.703] Chunk #1 of 1 ... DONE
  [20:24:30.703] Launching 1 futures (chunks) ... DONE
  [20:24:30.703] - resolving futures
  [20:24:30.703]   - gathering results & relaying conditions (except errors)
  [20:24:30.704] resolve() on list ...
  [20:24:30.704]  recursive: 0
  [20:24:30.704]  length: 1
  [20:24:30.704] 
  [20:24:30.705] Future #1
  [20:24:30.705] signalConditionsASAP(SequentialFuture, pos=1) ...
  [20:24:30.705] - nx: 1
  [20:24:30.706] - relay: TRUE
  [20:24:30.706] - stdout: TRUE
  [20:24:30.706] - signal: TRUE
  [20:24:30.706] - resignal: FALSE
  [20:24:30.707] - force: FALSE
  [20:24:30.707] - relayed: [n=1] FALSE
  [20:24:30.707] - queued futures: [n=1] FALSE
  [20:24:30.707]  - until=1
  [20:24:30.708]  - relaying element #1
  [20:24:30.708] - relayed: [n=1] TRUE
  [20:24:30.708] - queued futures: [n=1] TRUE
  [20:24:30.709] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [20:24:30.709]  length: 0 (resolved future 1)
  [20:24:30.709] Relaying remaining futures
  [20:24:30.710] signalConditionsASAP(NULL, pos=0) ...
  [20:24:30.710] - nx: 1
  [20:24:30.710] - relay: TRUE
  [20:24:30.710] - stdout: TRUE
  [20:24:30.711] - signal: TRUE
  [20:24:30.711] - resignal: FALSE
  [20:24:30.711] - force: FALSE
  [20:24:30.711] - relayed: [n=1] TRUE
  [20:24:30.712] - queued futures: [n=1] TRUE
   - flush all
  [20:24:30.712] - relayed: [n=1] TRUE
  [20:24:30.713] - queued futures: [n=1] TRUE
  [20:24:30.713] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:30.713] resolve() on list ... DONE
  [20:24:30.713] - collecting values of futures
  [20:24:30.714] - accumulating results
  [20:24:30.716] - processing errors (handler = 'stop')
  [20:24:30.717] - extracting results
  [20:24:30.717] doFuture() ... DONE
  - plan(list('sequential', 'cluster')) ... DONE
  - plan(list('multicore', 'sequential')) ...
  [20:24:30.734] plan(): Setting new future strategy stack:
  [20:24:30.735] List of future strategies:
  [20:24:30.735] 1. multicore:
  [20:24:30.735]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.735]    - tweaked: FALSE
  [20:24:30.735]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.735] 2. sequential:
  [20:24:30.735]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.735]    - tweaked: FALSE
  [20:24:30.735]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.736] plan(): nbrOfWorkers() = 2
  [20:24:30.740] doFuture() ...
  [20:24:30.744] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:30.745] - R expression:
  [20:24:30.746] {
  [20:24:30.746]     doFuture::registerDoFuture()
  [20:24:30.746]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.746]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.746]         {
  [20:24:30.746]             a <- NULL
  [20:24:30.746]             b <- NULL
  [20:24:30.746]         }
  [20:24:30.746]         ...future.env <- environment()
  [20:24:30.746]         local({
  [20:24:30.746]             for (name in names(...future.x_jj)) {
  [20:24:30.746]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.746]                   inherits = FALSE)
  [20:24:30.746]             }
  [20:24:30.746]         })
  [20:24:30.746]         tryCatch({
  [20:24:30.746]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.746]                 plan = future::plan("next"))
  [20:24:30.746]         }, error = identity)
  [20:24:30.746]     })
  [20:24:30.746] }
  [20:24:30.746] - identifying globals and packages ...
  [20:24:30.747] getGlobalsAndPackages() ...
  [20:24:30.747] Searching for globals...
  [20:24:30.776] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:30.777] Searching for globals ... DONE
  [20:24:30.777] Resolving globals: FALSE
  [20:24:30.778] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:30.779] - globals: [1] '...future.x_ii'
  [20:24:30.779] 
  [20:24:30.779] getGlobalsAndPackages() ... DONE
  [20:24:30.780] List of 1
  [20:24:30.780]  $ ...future.x_ii: NULL
  [20:24:30.780]  - attr(*, "where")=List of 1
  [20:24:30.780]   ..$ ...future.x_ii:<environment: 0x55bc219c43c8> 
  [20:24:30.780]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.780]  - attr(*, "resolved")= logi FALSE
  [20:24:30.780]  - attr(*, "total_size")= num 0
  [20:24:30.802]   - R expression:
  [20:24:30.802] {
  [20:24:30.802]     doFuture::registerDoFuture()
  [20:24:30.802]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.802]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.802]         {
  [20:24:30.802]             a <- NULL
  [20:24:30.802]             b <- NULL
  [20:24:30.802]         }
  [20:24:30.802]         ...future.env <- environment()
  [20:24:30.802]         local({
  [20:24:30.802]             for (name in names(...future.x_jj)) {
  [20:24:30.802]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.802]                   inherits = FALSE)
  [20:24:30.802]             }
  [20:24:30.802]         })
  [20:24:30.802]         tryCatch({
  [20:24:30.802]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.802]                 plan = future::plan("next"))
  [20:24:30.802]         }, error = identity)
  [20:24:30.802]     })
  [20:24:30.802] }
  [20:24:30.803]   - globals: [1] '...future.x_ii'
  [20:24:30.803] List of 1
  [20:24:30.803]  $ ...future.x_ii: NULL
  [20:24:30.803]  - attr(*, "where")=List of 1
  [20:24:30.803]   ..$ ...future.x_ii:<environment: 0x55bc219c43c8> 
  [20:24:30.803]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:30.803]  - attr(*, "resolved")= logi FALSE
  [20:24:30.803]  - attr(*, "total_size")= num 0
  [20:24:30.808]   - packages: [1] 'doFuture'
  [20:24:30.809] - identifying globals and packages ... DONE
  [20:24:30.812] Number of chunks: 2
  [20:24:30.812] Number of futures (= number of chunks): 2
  [20:24:30.813] Launching 2 futures (chunks) ...
  [20:24:30.813] Chunk #1 of 2 ...
  [20:24:30.830]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:30.830] getGlobalsAndPackages() ...
  [20:24:30.830] Searching for globals...
  [20:24:30.831] 
  [20:24:30.831] Searching for globals ... DONE
  [20:24:30.832] - globals: [0] <none>
  [20:24:30.832] getGlobalsAndPackages() ... DONE
  [20:24:30.832] 
  [20:24:30.832] 
  [20:24:30.833]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:30.834] getGlobalsAndPackages() ...
  [20:24:30.834] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.834] Resolving globals: FALSE
  [20:24:30.835] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:30.835] - globals: [1] '...future.x_ii'
  [20:24:30.836] 
  [20:24:30.836] getGlobalsAndPackages() ... DONE
  [20:24:30.838] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.839] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.862] {
  [20:24:30.862]     {
  [20:24:30.862]         ...future.startTime <- base::Sys.time()
  [20:24:30.862]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.862]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.862]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:30.862]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.862]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.862]         {
  [20:24:30.862]             {
  [20:24:30.862]                 {
  [20:24:30.862]                   {
  [20:24:30.862]                     has_future <- base::requireNamespace("future", 
  [20:24:30.862]                       quietly = TRUE)
  [20:24:30.862]                     version <- if (has_future) 
  [20:24:30.862]                       utils::packageVersion("future")
  [20:24:30.862]                     else NULL
  [20:24:30.862]                     if (!has_future || version < "1.8.0") {
  [20:24:30.862]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.862]                         "", base::R.version$version.string), 
  [20:24:30.862]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.862]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.862]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.862]                           "release", "version")], collapse = " "), 
  [20:24:30.862]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:30.862]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.862]                         info)
  [20:24:30.862]                       info <- base::paste(info, collapse = "; ")
  [20:24:30.862]                       if (!has_future) {
  [20:24:30.862]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.862]                           info)
  [20:24:30.862]                       }
  [20:24:30.862]                       else {
  [20:24:30.862]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.862]                           info, version)
  [20:24:30.862]                       }
  [20:24:30.862]                       base::stop(msg)
  [20:24:30.862]                     }
  [20:24:30.862]                   }
  [20:24:30.862]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:30.862]                   base::options(mc.cores = 1L)
  [20:24:30.862]                 }
  [20:24:30.862]                 base::local({
  [20:24:30.862]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.862]                     base::loadNamespace(pkg)
  [20:24:30.862]                     base::library(pkg, character.only = TRUE)
  [20:24:30.862]                   }
  [20:24:30.862]                 })
  [20:24:30.862]             }
  [20:24:30.862]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.862]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.862]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.862]                 label = NULL, ...) 
  [20:24:30.862]             {
  [20:24:30.862]                 if (substitute) 
  [20:24:30.862]                   expr <- substitute(expr)
  [20:24:30.862]                 local <- as.logical(local)
  [20:24:30.862]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.862]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.862]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.862]                   label = label, ...)
  [20:24:30.862]                 if (!future$lazy) 
  [20:24:30.862]                   future <- run(future)
  [20:24:30.862]                 invisible(future)
  [20:24:30.862]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.862]         }
  [20:24:30.862]     }
  [20:24:30.862]     if (base::is.na(TRUE)) {
  [20:24:30.862]     }
  [20:24:30.862]     else {
  [20:24:30.862]         if (TRUE) {
  [20:24:30.862]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.862]                 open = "w")
  [20:24:30.862]         }
  [20:24:30.862]         else {
  [20:24:30.862]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.862]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.862]         }
  [20:24:30.862]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.862]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.862]             base::sink(type = "output", split = FALSE)
  [20:24:30.862]             base::close(...future.stdout)
  [20:24:30.862]         }, add = TRUE)
  [20:24:30.862]     }
  [20:24:30.862]     ...future.frame <- base::sys.nframe()
  [20:24:30.862]     ...future.conditions <- base::list()
  [20:24:30.862]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.862]     ...future.result <- base::tryCatch({
  [20:24:30.862]         base::withCallingHandlers({
  [20:24:30.862]             ...future.value <- base::withVisible(base::local({
  [20:24:30.862]                 doFuture::registerDoFuture()
  [20:24:30.862]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.862]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.862]                   {
  [20:24:30.862]                     a <- NULL
  [20:24:30.862]                     b <- NULL
  [20:24:30.862]                   }
  [20:24:30.862]                   ...future.env <- environment()
  [20:24:30.862]                   local({
  [20:24:30.862]                     for (name in names(...future.x_jj)) {
  [20:24:30.862]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.862]                         inherits = FALSE)
  [20:24:30.862]                     }
  [20:24:30.862]                   })
  [20:24:30.862]                   tryCatch({
  [20:24:30.862]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.862]                       plan = future::plan("next"))
  [20:24:30.862]                   }, error = identity)
  [20:24:30.862]                 })
  [20:24:30.862]             }))
  [20:24:30.862]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.862]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.862]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.862]                 version = "1.8")
  [20:24:30.862]         }, condition = base::local({
  [20:24:30.862]             c <- base::c
  [20:24:30.862]             inherits <- base::inherits
  [20:24:30.862]             invokeRestart <- base::invokeRestart
  [20:24:30.862]             length <- base::length
  [20:24:30.862]             list <- base::list
  [20:24:30.862]             seq.int <- base::seq.int
  [20:24:30.862]             signalCondition <- base::signalCondition
  [20:24:30.862]             sys.calls <- base::sys.calls
  [20:24:30.862]             Sys.time <- base::Sys.time
  [20:24:30.862]             `[[` <- base::`[[`
  [20:24:30.862]             `+` <- base::`+`
  [20:24:30.862]             `<<-` <- base::`<<-`
  [20:24:30.862]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.862]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.862]                   3L)]
  [20:24:30.862]             }
  [20:24:30.862]             function(cond) {
  [20:24:30.862]                 if (inherits(cond, "error")) {
  [20:24:30.862]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.862]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.862]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.862]                   signalCondition(cond)
  [20:24:30.862]                 }
  [20:24:30.862]                 else if (inherits(cond, "condition")) {
  [20:24:30.862]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:30.862]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.862]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.862]                   if (!signal) {
  [20:24:30.862]                     muffleCondition <- function (cond) 
  [20:24:30.862]                     {
  [20:24:30.862]                       inherits <- base::inherits
  [20:24:30.862]                       invokeRestart <- base::invokeRestart
  [20:24:30.862]                       muffled <- FALSE
  [20:24:30.862]                       if (inherits(cond, "message")) {
  [20:24:30.862]                         invokeRestart("muffleMessage")
  [20:24:30.862]                         muffled <- TRUE
  [20:24:30.862]                       }
  [20:24:30.862]                       else if (inherits(cond, "warning")) {
  [20:24:30.862]                         invokeRestart("muffleWarning")
  [20:24:30.862]                         muffled <- TRUE
  [20:24:30.862]                       }
  [20:24:30.862]                       else if (inherits(cond, "condition")) {
  [20:24:30.862]                         computeRestarts <- base::computeRestarts
  [20:24:30.862]                         grepl <- base::grepl
  [20:24:30.862]                         is.null <- base::is.null
  [20:24:30.862]                         restarts <- computeRestarts(cond)
  [20:24:30.862]                         for (restart in restarts) {
  [20:24:30.862]                           name <- restart$name
  [20:24:30.862]                           if (is.null(name)) 
  [20:24:30.862]                             next
  [20:24:30.862]                           if (!grepl("^muffle", name)) 
  [20:24:30.862]                             next
  [20:24:30.862]                           invokeRestart(restart)
  [20:24:30.862]                           muffled <- TRUE
  [20:24:30.862]                           break
  [20:24:30.862]                         }
  [20:24:30.862]                       }
  [20:24:30.862]                       invisible(muffled)
  [20:24:30.862]                     }
  [20:24:30.862]                     muffleCondition(cond)
  [20:24:30.862]                   }
  [20:24:30.862]                 }
  [20:24:30.862]             }
  [20:24:30.862]         }))
  [20:24:30.862]     }, error = function(ex) {
  [20:24:30.862]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.862]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.862]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.862]     }, finally = {
  [20:24:30.862]         {
  [20:24:30.862]             {
  [20:24:30.862]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:30.862]             }
  [20:24:30.862]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.862]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.862]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:30.862]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.862]             {
  [20:24:30.862]                 if (substitute) 
  [20:24:30.862]                   expr <- substitute(expr)
  [20:24:30.862]                 if (is.function(workers)) 
  [20:24:30.862]                   workers <- workers()
  [20:24:30.862]                 workers <- as.integer(workers)
  [20:24:30.862]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:30.862]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:30.862]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.862]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:30.862]                     local = TRUE, label = label, ...))
  [20:24:30.862]                 }
  [20:24:30.862]                 oopts <- options(mc.cores = workers)
  [20:24:30.862]                 on.exit(options(oopts))
  [20:24:30.862]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:30.862]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.862]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:30.862]                   label = label, ...)
  [20:24:30.862]                 if (!future$lazy) 
  [20:24:30.862]                   future <- run(future)
  [20:24:30.862]                 invisible(future)
  [20:24:30.862]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.862]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:30.862]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.862]             {
  [20:24:30.862]                 if (substitute) 
  [20:24:30.862]                   expr <- substitute(expr)
  [20:24:30.862]                 local <- as.logical(local)
  [20:24:30.862]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.862]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.862]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.862]                   label = label, ...)
  [20:24:30.862]                 if (!future$lazy) 
  [20:24:30.862]                   future <- run(future)
  [20:24:30.862]                 invisible(future)
  [20:24:30.862]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.862]         }
  [20:24:30.862]         base::options(...future.oldOptions)
  [20:24:30.862]     })
  [20:24:30.862]     Sys.time
  [20:24:30.862]     if (base::is.na(TRUE)) {
  [20:24:30.862]     }
  [20:24:30.862]     else {
  [20:24:30.862]         base::sink(type = "output", split = FALSE)
  [20:24:30.862]         if (TRUE) {
  [20:24:30.862]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.862]         }
  [20:24:30.862]         else {
  [20:24:30.862]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.862]         }
  [20:24:30.862]         base::close(...future.stdout)
  [20:24:30.862]         ...future.stdout <- NULL
  [20:24:30.862]     }
  [20:24:30.862]     ...future.result$conditions <- ...future.conditions
  [20:24:30.862]     ...future.result
  [20:24:30.862] }
  [20:24:30.867] requestCore(): workers = 2
  [20:24:30.871] MulticoreFuture started
  [20:24:30.872] Chunk #1 of 2 ... DONE
  [20:24:30.872] Chunk #2 of 2 ...
  [20:24:30.873]  - Finding globals in 'args_list' chunk #2 ...
  [20:24:30.873] getGlobalsAndPackages() ...
  [20:24:30.873] Searching for globals...
  [20:24:30.875] 
  [20:24:30.875] Searching for globals ... DONE
  [20:24:30.875] - globals: [0] <none>
  [20:24:30.876] getGlobalsAndPackages() ... DONE
  [20:24:30.876] 
  [20:24:30.876] 
  [20:24:30.877]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:24:30.886] plan(): Setting new future strategy stack:
  [20:24:30.887] List of future strategies:
  [20:24:30.887] 1. sequential:
  [20:24:30.887]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.887]    - tweaked: FALSE
  [20:24:30.887]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.888] plan(): nbrOfWorkers() = 1
  [20:24:30.890] plan(): Setting new future strategy stack:
  [20:24:30.891] List of future strategies:
  [20:24:30.891] 1. multicore:
  [20:24:30.891]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.891]    - tweaked: FALSE
  [20:24:30.891]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.891] 2. sequential:
  [20:24:30.891]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.891]    - tweaked: FALSE
  [20:24:30.891]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.901] plan(): nbrOfWorkers() = 2
  [20:24:30.906] getGlobalsAndPackages() ...
  [20:24:30.907] - globals passed as-is: [1] '...future.x_ii'
  [20:24:30.907] Resolving globals: FALSE
  [20:24:30.908] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:30.909] - globals: [1] '...future.x_ii'
  [20:24:30.909] 
  [20:24:30.909] getGlobalsAndPackages() ... DONE
  [20:24:30.912] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:30.912] Packages needed by future strategies (n = 1): 'future'
  [20:24:30.917] {
  [20:24:30.917]     {
  [20:24:30.917]         ...future.startTime <- base::Sys.time()
  [20:24:30.917]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:30.917]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:30.917]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:30.917]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:30.917]             future.resolve.recursive = NULL, width = 80L)
  [20:24:30.917]         {
  [20:24:30.917]             {
  [20:24:30.917]                 {
  [20:24:30.917]                   {
  [20:24:30.917]                     has_future <- base::requireNamespace("future", 
  [20:24:30.917]                       quietly = TRUE)
  [20:24:30.917]                     version <- if (has_future) 
  [20:24:30.917]                       utils::packageVersion("future")
  [20:24:30.917]                     else NULL
  [20:24:30.917]                     if (!has_future || version < "1.8.0") {
  [20:24:30.917]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:30.917]                         "", base::R.version$version.string), 
  [20:24:30.917]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:30.917]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:30.917]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:30.917]                           "release", "version")], collapse = " "), 
  [20:24:30.917]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:30.917]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:30.917]                         info)
  [20:24:30.917]                       info <- base::paste(info, collapse = "; ")
  [20:24:30.917]                       if (!has_future) {
  [20:24:30.917]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:30.917]                           info)
  [20:24:30.917]                       }
  [20:24:30.917]                       else {
  [20:24:30.917]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:30.917]                           info, version)
  [20:24:30.917]                       }
  [20:24:30.917]                       base::stop(msg)
  [20:24:30.917]                     }
  [20:24:30.917]                   }
  [20:24:30.917]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:30.917]                   base::options(mc.cores = 1L)
  [20:24:30.917]                 }
  [20:24:30.917]                 base::local({
  [20:24:30.917]                   for (pkg in c("doFuture", "future")) {
  [20:24:30.917]                     base::loadNamespace(pkg)
  [20:24:30.917]                     base::library(pkg, character.only = TRUE)
  [20:24:30.917]                   }
  [20:24:30.917]                 })
  [20:24:30.917]             }
  [20:24:30.917]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:30.917]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.917]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:30.917]                 label = NULL, ...) 
  [20:24:30.917]             {
  [20:24:30.917]                 if (substitute) 
  [20:24:30.917]                   expr <- substitute(expr)
  [20:24:30.917]                 local <- as.logical(local)
  [20:24:30.917]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.917]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.917]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.917]                   label = label, ...)
  [20:24:30.917]                 if (!future$lazy) 
  [20:24:30.917]                   future <- run(future)
  [20:24:30.917]                 invisible(future)
  [20:24:30.917]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.917]         }
  [20:24:30.917]     }
  [20:24:30.917]     if (base::is.na(TRUE)) {
  [20:24:30.917]     }
  [20:24:30.917]     else {
  [20:24:30.917]         if (TRUE) {
  [20:24:30.917]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:30.917]                 open = "w")
  [20:24:30.917]         }
  [20:24:30.917]         else {
  [20:24:30.917]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:30.917]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:30.917]         }
  [20:24:30.917]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:30.917]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:30.917]             base::sink(type = "output", split = FALSE)
  [20:24:30.917]             base::close(...future.stdout)
  [20:24:30.917]         }, add = TRUE)
  [20:24:30.917]     }
  [20:24:30.917]     ...future.frame <- base::sys.nframe()
  [20:24:30.917]     ...future.conditions <- base::list()
  [20:24:30.917]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:30.917]     ...future.result <- base::tryCatch({
  [20:24:30.917]         base::withCallingHandlers({
  [20:24:30.917]             ...future.value <- base::withVisible(base::local({
  [20:24:30.917]                 doFuture::registerDoFuture()
  [20:24:30.917]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:30.917]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:30.917]                   {
  [20:24:30.917]                     a <- NULL
  [20:24:30.917]                     b <- NULL
  [20:24:30.917]                   }
  [20:24:30.917]                   ...future.env <- environment()
  [20:24:30.917]                   local({
  [20:24:30.917]                     for (name in names(...future.x_jj)) {
  [20:24:30.917]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:30.917]                         inherits = FALSE)
  [20:24:30.917]                     }
  [20:24:30.917]                   })
  [20:24:30.917]                   tryCatch({
  [20:24:30.917]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:30.917]                       plan = future::plan("next"))
  [20:24:30.917]                   }, error = identity)
  [20:24:30.917]                 })
  [20:24:30.917]             }))
  [20:24:30.917]             future::FutureResult(value = ...future.value$value, 
  [20:24:30.917]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.917]                   ...future.rng), started = ...future.startTime, 
  [20:24:30.917]                 version = "1.8")
  [20:24:30.917]         }, condition = base::local({
  [20:24:30.917]             c <- base::c
  [20:24:30.917]             inherits <- base::inherits
  [20:24:30.917]             invokeRestart <- base::invokeRestart
  [20:24:30.917]             length <- base::length
  [20:24:30.917]             list <- base::list
  [20:24:30.917]             seq.int <- base::seq.int
  [20:24:30.917]             signalCondition <- base::signalCondition
  [20:24:30.917]             sys.calls <- base::sys.calls
  [20:24:30.917]             Sys.time <- base::Sys.time
  [20:24:30.917]             `[[` <- base::`[[`
  [20:24:30.917]             `+` <- base::`+`
  [20:24:30.917]             `<<-` <- base::`<<-`
  [20:24:30.917]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:30.917]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:30.917]                   3L)]
  [20:24:30.917]             }
  [20:24:30.917]             function(cond) {
  [20:24:30.917]                 if (inherits(cond, "error")) {
  [20:24:30.917]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.917]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:30.917]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:30.917]                   signalCondition(cond)
  [20:24:30.917]                 }
  [20:24:30.917]                 else if (inherits(cond, "condition")) {
  [20:24:30.917]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:30.917]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:30.917]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:30.917]                   if (!signal) {
  [20:24:30.917]                     muffleCondition <- function (cond) 
  [20:24:30.917]                     {
  [20:24:30.917]                       inherits <- base::inherits
  [20:24:30.917]                       invokeRestart <- base::invokeRestart
  [20:24:30.917]                       muffled <- FALSE
  [20:24:30.917]                       if (inherits(cond, "message")) {
  [20:24:30.917]                         invokeRestart("muffleMessage")
  [20:24:30.917]                         muffled <- TRUE
  [20:24:30.917]                       }
  [20:24:30.917]                       else if (inherits(cond, "warning")) {
  [20:24:30.917]                         invokeRestart("muffleWarning")
  [20:24:30.917]                         muffled <- TRUE
  [20:24:30.917]                       }
  [20:24:30.917]                       else if (inherits(cond, "condition")) {
  [20:24:30.917]                         computeRestarts <- base::computeRestarts
  [20:24:30.917]                         grepl <- base::grepl
  [20:24:30.917]                         is.null <- base::is.null
  [20:24:30.917]                         restarts <- computeRestarts(cond)
  [20:24:30.917]                         for (restart in restarts) {
  [20:24:30.917]                           name <- restart$name
  [20:24:30.917]                           if (is.null(name)) 
  [20:24:30.917]                             next
  [20:24:30.917]                           if (!grepl("^muffle", name)) 
  [20:24:30.917]                             next
  [20:24:30.917]                           invokeRestart(restart)
  [20:24:30.917]                           muffled <- TRUE
  [20:24:30.917]                           break
  [20:24:30.917]                         }
  [20:24:30.917]                       }
  [20:24:30.917]                       invisible(muffled)
  [20:24:30.917]                     }
  [20:24:30.917]                     muffleCondition(cond)
  [20:24:30.917]                   }
  [20:24:30.917]                 }
  [20:24:30.917]             }
  [20:24:30.917]         }))
  [20:24:30.917]     }, error = function(ex) {
  [20:24:30.917]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:30.917]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:30.917]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:30.917]     }, finally = {
  [20:24:30.917]         {
  [20:24:30.917]             {
  [20:24:30.917]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:30.917]             }
  [20:24:30.917]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:30.917]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:30.917]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:30.917]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.917]             {
  [20:24:30.917]                 if (substitute) 
  [20:24:30.917]                   expr <- substitute(expr)
  [20:24:30.917]                 if (is.function(workers)) 
  [20:24:30.917]                   workers <- workers()
  [20:24:30.917]                 workers <- as.integer(workers)
  [20:24:30.917]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:30.917]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:30.917]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:30.917]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:30.917]                     local = TRUE, label = label, ...))
  [20:24:30.917]                 }
  [20:24:30.917]                 oopts <- options(mc.cores = workers)
  [20:24:30.917]                 on.exit(options(oopts))
  [20:24:30.917]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:30.917]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.917]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:30.917]                   label = label, ...)
  [20:24:30.917]                 if (!future$lazy) 
  [20:24:30.917]                   future <- run(future)
  [20:24:30.917]                 invisible(future)
  [20:24:30.917]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:30.917]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:30.917]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:30.917]             {
  [20:24:30.917]                 if (substitute) 
  [20:24:30.917]                   expr <- substitute(expr)
  [20:24:30.917]                 local <- as.logical(local)
  [20:24:30.917]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:30.917]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:30.917]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:30.917]                   label = label, ...)
  [20:24:30.917]                 if (!future$lazy) 
  [20:24:30.917]                   future <- run(future)
  [20:24:30.917]                 invisible(future)
  [20:24:30.917]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:30.917]         }
  [20:24:30.917]         base::options(...future.oldOptions)
  [20:24:30.917]     })
  [20:24:30.917]     Sys.time
  [20:24:30.917]     if (base::is.na(TRUE)) {
  [20:24:30.917]     }
  [20:24:30.917]     else {
  [20:24:30.917]         base::sink(type = "output", split = FALSE)
  [20:24:30.917]         if (TRUE) {
  [20:24:30.917]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:30.917]         }
  [20:24:30.917]         else {
  [20:24:30.917]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:30.917]         }
  [20:24:30.917]         base::close(...future.stdout)
  [20:24:30.917]         ...future.stdout <- NULL
  [20:24:30.917]     }
  [20:24:30.917]     ...future.result$conditions <- ...future.conditions
  [20:24:30.917]     ...future.result
  [20:24:30.917] }
  [20:24:30.939] requestCore(): workers = 2
  [20:24:30.948] MulticoreFuture started
  [20:24:30.949] Chunk #2 of 2 ... DONE
  [20:24:30.950] Launching 2 futures (chunks) ... DONE
  [20:24:30.950] - resolving futures
  [20:24:30.950]   - gathering results & relaying conditions (except errors)
  [20:24:30.951] resolve() on list ...
  [20:24:30.951]  recursive: 0
  [20:24:30.951]  length: 2
  [20:24:30.952] 
  [20:24:30.962] plan(): Setting new future strategy stack:
  [20:24:30.962] List of future strategies:
  [20:24:30.962] 1. sequential:
  [20:24:30.962]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.962]    - tweaked: FALSE
  [20:24:30.962]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.963] Future #1
  [20:24:30.964] plan(): nbrOfWorkers() = 1
  [20:24:30.966] plan(): Setting new future strategy stack:
  [20:24:30.968] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [20:24:30.968] - nx: 2
  [20:24:30.969] - relay: TRUE
  [20:24:30.969] - stdout: TRUE
  [20:24:30.969] - signal: TRUE
  [20:24:30.969] - resignal: FALSE
  [20:24:30.970] - force: FALSE
  [20:24:30.970] - relayed: [n=2] FALSE, FALSE
  [20:24:30.970] - queued futures: [n=2] FALSE, FALSE
  [20:24:30.970]  - until=1
  [20:24:30.971]  - relaying element #1
  [20:24:30.971] - relayed: [n=2] TRUE, FALSE
  [20:24:30.971] - queued futures: [n=2] TRUE, FALSE
  [20:24:30.972] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [20:24:30.972]  length: 1 (resolved future 1)
  [20:24:30.966] List of future strategies:
  [20:24:30.966] 1. multicore:
  [20:24:30.966]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:30.966]    - tweaked: FALSE
  [20:24:30.966]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.966] 2. sequential:
  [20:24:30.966]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:30.966]    - tweaked: FALSE
  [20:24:30.966]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:30.987] plan(): nbrOfWorkers() = 2
  [20:24:30.988] Future #2
  [20:24:30.990] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [20:24:30.990] - nx: 2
  [20:24:30.990] - relay: TRUE
  [20:24:30.991] - stdout: TRUE
  [20:24:30.991] - signal: TRUE
  [20:24:30.991] - resignal: FALSE
  [20:24:30.991] - force: FALSE
  [20:24:30.992] - relayed: [n=2] TRUE, FALSE
  [20:24:30.992] - queued futures: [n=2] TRUE, FALSE
  [20:24:30.992]  - until=2
  [20:24:30.992]  - relaying element #2
  [20:24:30.993] - relayed: [n=2] TRUE, TRUE
  [20:24:30.993] - queued futures: [n=2] TRUE, TRUE
  [20:24:30.993] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [20:24:30.994]  length: 0 (resolved future 2)
  [20:24:30.994] Relaying remaining futures
  [20:24:30.994] signalConditionsASAP(NULL, pos=0) ...
  [20:24:30.994] - nx: 2
  [20:24:30.995] - relay: TRUE
  [20:24:30.995] - stdout: TRUE
  [20:24:30.995] - signal: TRUE
  [20:24:30.995] - resignal: FALSE
  [20:24:30.996] - force: FALSE
  [20:24:30.996] - relayed: [n=2] TRUE, TRUE
  [20:24:30.996] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:24:30.997] - relayed: [n=2] TRUE, TRUE
  [20:24:30.997] - queued futures: [n=2] TRUE, TRUE
  [20:24:30.997] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:30.997] resolve() on list ... DONE
  [20:24:31.014] - collecting values of futures
  [20:24:31.015] - accumulating results
  [20:24:31.017] - processing errors (handler = 'stop')
  [20:24:31.017] - extracting results
  [20:24:31.017] doFuture() ... DONE
  - plan(list('multicore', 'sequential')) ... DONE
  - plan(list('multicore', 'multicore')) ...
  [20:24:31.018] plan(): Setting new future strategy stack:
  [20:24:31.019] List of future strategies:
  [20:24:31.019] 1. multicore:
  [20:24:31.019]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.019]    - tweaked: FALSE
  [20:24:31.019]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.019] 2. multicore:
  [20:24:31.019]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.019]    - tweaked: FALSE
  [20:24:31.019]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.020] plan(): nbrOfWorkers() = 2
  [20:24:31.025] doFuture() ...
  [20:24:31.029] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:31.046] - R expression:
  [20:24:31.047] {
  [20:24:31.047]     doFuture::registerDoFuture()
  [20:24:31.047]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.047]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.047]         {
  [20:24:31.047]             a <- NULL
  [20:24:31.047]             b <- NULL
  [20:24:31.047]         }
  [20:24:31.047]         ...future.env <- environment()
  [20:24:31.047]         local({
  [20:24:31.047]             for (name in names(...future.x_jj)) {
  [20:24:31.047]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.047]                   inherits = FALSE)
  [20:24:31.047]             }
  [20:24:31.047]         })
  [20:24:31.047]         tryCatch({
  [20:24:31.047]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.047]                 plan = future::plan("next"))
  [20:24:31.047]         }, error = identity)
  [20:24:31.047]     })
  [20:24:31.047] }
  [20:24:31.047] - identifying globals and packages ...
  [20:24:31.048] getGlobalsAndPackages() ...
  [20:24:31.048] Searching for globals...
  [20:24:31.062] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:31.078] Searching for globals ... DONE
  [20:24:31.078] Resolving globals: FALSE
  [20:24:31.080] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:31.080] - globals: [1] '...future.x_ii'
  [20:24:31.080] 
  [20:24:31.081] getGlobalsAndPackages() ... DONE
  [20:24:31.081] List of 1
  [20:24:31.081]  $ ...future.x_ii: NULL
  [20:24:31.081]  - attr(*, "where")=List of 1
  [20:24:31.081]   ..$ ...future.x_ii:<environment: 0x55bc219400c0> 
  [20:24:31.081]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.081]  - attr(*, "resolved")= logi FALSE
  [20:24:31.081]  - attr(*, "total_size")= num 0
  [20:24:31.086]   - R expression:
  [20:24:31.087] {
  [20:24:31.087]     doFuture::registerDoFuture()
  [20:24:31.087]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.087]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.087]         {
  [20:24:31.087]             a <- NULL
  [20:24:31.087]             b <- NULL
  [20:24:31.087]         }
  [20:24:31.087]         ...future.env <- environment()
  [20:24:31.087]         local({
  [20:24:31.087]             for (name in names(...future.x_jj)) {
  [20:24:31.087]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.087]                   inherits = FALSE)
  [20:24:31.087]             }
  [20:24:31.087]         })
  [20:24:31.087]         tryCatch({
  [20:24:31.087]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.087]                 plan = future::plan("next"))
  [20:24:31.087]         }, error = identity)
  [20:24:31.087]     })
  [20:24:31.087] }
  [20:24:31.087]   - globals: [1] '...future.x_ii'
  [20:24:31.088] List of 1
  [20:24:31.088]  $ ...future.x_ii: NULL
  [20:24:31.088]  - attr(*, "where")=List of 1
  [20:24:31.088]   ..$ ...future.x_ii:<environment: 0x55bc219400c0> 
  [20:24:31.088]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.088]  - attr(*, "resolved")= logi FALSE
  [20:24:31.088]  - attr(*, "total_size")= num 0
  [20:24:31.093]   - packages: [1] 'doFuture'
  [20:24:31.093] - identifying globals and packages ... DONE
  [20:24:31.107] Number of chunks: 2
  [20:24:31.107] Number of futures (= number of chunks): 2
  [20:24:31.108] Launching 2 futures (chunks) ...
  [20:24:31.108] Chunk #1 of 2 ...
  [20:24:31.108]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:31.108] getGlobalsAndPackages() ...
  [20:24:31.109] Searching for globals...
  [20:24:31.109] 
  [20:24:31.110] Searching for globals ... DONE
  [20:24:31.110] - globals: [0] <none>
  [20:24:31.110] getGlobalsAndPackages() ... DONE
  [20:24:31.110] 
  [20:24:31.111] 
  [20:24:31.111]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:31.112] getGlobalsAndPackages() ...
  [20:24:31.112] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.112] Resolving globals: FALSE
  [20:24:31.113] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.113] - globals: [1] '...future.x_ii'
  [20:24:31.114] 
  [20:24:31.114] getGlobalsAndPackages() ... DONE
  [20:24:31.119] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.120] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.140] {
  [20:24:31.140]     {
  [20:24:31.140]         ...future.startTime <- base::Sys.time()
  [20:24:31.140]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.140]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.140]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.140]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.140]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.140]         {
  [20:24:31.140]             {
  [20:24:31.140]                 {
  [20:24:31.140]                   {
  [20:24:31.140]                     has_future <- base::requireNamespace("future", 
  [20:24:31.140]                       quietly = TRUE)
  [20:24:31.140]                     version <- if (has_future) 
  [20:24:31.140]                       utils::packageVersion("future")
  [20:24:31.140]                     else NULL
  [20:24:31.140]                     if (!has_future || version < "1.8.0") {
  [20:24:31.140]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.140]                         "", base::R.version$version.string), 
  [20:24:31.140]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.140]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.140]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.140]                           "release", "version")], collapse = " "), 
  [20:24:31.140]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.140]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.140]                         info)
  [20:24:31.140]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.140]                       if (!has_future) {
  [20:24:31.140]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.140]                           info)
  [20:24:31.140]                       }
  [20:24:31.140]                       else {
  [20:24:31.140]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.140]                           info, version)
  [20:24:31.140]                       }
  [20:24:31.140]                       base::stop(msg)
  [20:24:31.140]                     }
  [20:24:31.140]                   }
  [20:24:31.140]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.140]                   base::options(mc.cores = 1L)
  [20:24:31.140]                 }
  [20:24:31.140]                 base::local({
  [20:24:31.140]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.140]                     base::loadNamespace(pkg)
  [20:24:31.140]                     base::library(pkg, character.only = TRUE)
  [20:24:31.140]                   }
  [20:24:31.140]                 })
  [20:24:31.140]             }
  [20:24:31.140]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.140]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.140]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.140]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.140]             {
  [20:24:31.140]                 if (substitute) 
  [20:24:31.140]                   expr <- substitute(expr)
  [20:24:31.140]                 if (is.function(workers)) 
  [20:24:31.140]                   workers <- workers()
  [20:24:31.140]                 workers <- as.integer(workers)
  [20:24:31.140]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.140]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.140]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.140]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.140]                     local = TRUE, label = label, ...))
  [20:24:31.140]                 }
  [20:24:31.140]                 oopts <- options(mc.cores = workers)
  [20:24:31.140]                 on.exit(options(oopts))
  [20:24:31.140]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.140]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.140]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.140]                   label = label, ...)
  [20:24:31.140]                 if (!future$lazy) 
  [20:24:31.140]                   future <- run(future)
  [20:24:31.140]                 invisible(future)
  [20:24:31.140]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.140]         }
  [20:24:31.140]     }
  [20:24:31.140]     if (base::is.na(TRUE)) {
  [20:24:31.140]     }
  [20:24:31.140]     else {
  [20:24:31.140]         if (TRUE) {
  [20:24:31.140]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.140]                 open = "w")
  [20:24:31.140]         }
  [20:24:31.140]         else {
  [20:24:31.140]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.140]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.140]         }
  [20:24:31.140]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.140]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.140]             base::sink(type = "output", split = FALSE)
  [20:24:31.140]             base::close(...future.stdout)
  [20:24:31.140]         }, add = TRUE)
  [20:24:31.140]     }
  [20:24:31.140]     ...future.frame <- base::sys.nframe()
  [20:24:31.140]     ...future.conditions <- base::list()
  [20:24:31.140]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.140]     ...future.result <- base::tryCatch({
  [20:24:31.140]         base::withCallingHandlers({
  [20:24:31.140]             ...future.value <- base::withVisible(base::local({
  [20:24:31.140]                 doFuture::registerDoFuture()
  [20:24:31.140]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.140]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.140]                   {
  [20:24:31.140]                     a <- NULL
  [20:24:31.140]                     b <- NULL
  [20:24:31.140]                   }
  [20:24:31.140]                   ...future.env <- environment()
  [20:24:31.140]                   local({
  [20:24:31.140]                     for (name in names(...future.x_jj)) {
  [20:24:31.140]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.140]                         inherits = FALSE)
  [20:24:31.140]                     }
  [20:24:31.140]                   })
  [20:24:31.140]                   tryCatch({
  [20:24:31.140]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.140]                       plan = future::plan("next"))
  [20:24:31.140]                   }, error = identity)
  [20:24:31.140]                 })
  [20:24:31.140]             }))
  [20:24:31.140]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.140]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.140]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.140]                 version = "1.8")
  [20:24:31.140]         }, condition = base::local({
  [20:24:31.140]             c <- base::c
  [20:24:31.140]             inherits <- base::inherits
  [20:24:31.140]             invokeRestart <- base::invokeRestart
  [20:24:31.140]             length <- base::length
  [20:24:31.140]             list <- base::list
  [20:24:31.140]             seq.int <- base::seq.int
  [20:24:31.140]             signalCondition <- base::signalCondition
  [20:24:31.140]             sys.calls <- base::sys.calls
  [20:24:31.140]             Sys.time <- base::Sys.time
  [20:24:31.140]             `[[` <- base::`[[`
  [20:24:31.140]             `+` <- base::`+`
  [20:24:31.140]             `<<-` <- base::`<<-`
  [20:24:31.140]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.140]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.140]                   3L)]
  [20:24:31.140]             }
  [20:24:31.140]             function(cond) {
  [20:24:31.140]                 if (inherits(cond, "error")) {
  [20:24:31.140]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.140]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.140]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.140]                   signalCondition(cond)
  [20:24:31.140]                 }
  [20:24:31.140]                 else if (inherits(cond, "condition")) {
  [20:24:31.140]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.140]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.140]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.140]                   if (!signal) {
  [20:24:31.140]                     muffleCondition <- function (cond) 
  [20:24:31.140]                     {
  [20:24:31.140]                       inherits <- base::inherits
  [20:24:31.140]                       invokeRestart <- base::invokeRestart
  [20:24:31.140]                       muffled <- FALSE
  [20:24:31.140]                       if (inherits(cond, "message")) {
  [20:24:31.140]                         invokeRestart("muffleMessage")
  [20:24:31.140]                         muffled <- TRUE
  [20:24:31.140]                       }
  [20:24:31.140]                       else if (inherits(cond, "warning")) {
  [20:24:31.140]                         invokeRestart("muffleWarning")
  [20:24:31.140]                         muffled <- TRUE
  [20:24:31.140]                       }
  [20:24:31.140]                       else if (inherits(cond, "condition")) {
  [20:24:31.140]                         computeRestarts <- base::computeRestarts
  [20:24:31.140]                         grepl <- base::grepl
  [20:24:31.140]                         is.null <- base::is.null
  [20:24:31.140]                         restarts <- computeRestarts(cond)
  [20:24:31.140]                         for (restart in restarts) {
  [20:24:31.140]                           name <- restart$name
  [20:24:31.140]                           if (is.null(name)) 
  [20:24:31.140]                             next
  [20:24:31.140]                           if (!grepl("^muffle", name)) 
  [20:24:31.140]                             next
  [20:24:31.140]                           invokeRestart(restart)
  [20:24:31.140]                           muffled <- TRUE
  [20:24:31.140]                           break
  [20:24:31.140]                         }
  [20:24:31.140]                       }
  [20:24:31.140]                       invisible(muffled)
  [20:24:31.140]                     }
  [20:24:31.140]                     muffleCondition(cond)
  [20:24:31.140]                   }
  [20:24:31.140]                 }
  [20:24:31.140]             }
  [20:24:31.140]         }))
  [20:24:31.140]     }, error = function(ex) {
  [20:24:31.140]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.140]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.140]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.140]     }, finally = {
  [20:24:31.140]         {
  [20:24:31.140]             {
  [20:24:31.140]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.140]             }
  [20:24:31.140]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.140]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.140]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.140]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.140]             {
  [20:24:31.140]                 if (substitute) 
  [20:24:31.140]                   expr <- substitute(expr)
  [20:24:31.140]                 if (is.function(workers)) 
  [20:24:31.140]                   workers <- workers()
  [20:24:31.140]                 workers <- as.integer(workers)
  [20:24:31.140]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.140]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.140]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.140]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.140]                     local = TRUE, label = label, ...))
  [20:24:31.140]                 }
  [20:24:31.140]                 oopts <- options(mc.cores = workers)
  [20:24:31.140]                 on.exit(options(oopts))
  [20:24:31.140]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.140]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.140]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.140]                   label = label, ...)
  [20:24:31.140]                 if (!future$lazy) 
  [20:24:31.140]                   future <- run(future)
  [20:24:31.140]                 invisible(future)
  [20:24:31.140]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.140]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.140]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.140]             {
  [20:24:31.140]                 if (substitute) 
  [20:24:31.140]                   expr <- substitute(expr)
  [20:24:31.140]                 if (is.function(workers)) 
  [20:24:31.140]                   workers <- workers()
  [20:24:31.140]                 workers <- as.integer(workers)
  [20:24:31.140]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.140]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.140]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.140]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.140]                     local = TRUE, label = label, ...))
  [20:24:31.140]                 }
  [20:24:31.140]                 oopts <- options(mc.cores = workers)
  [20:24:31.140]                 on.exit(options(oopts))
  [20:24:31.140]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.140]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.140]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.140]                   label = label, ...)
  [20:24:31.140]                 if (!future$lazy) 
  [20:24:31.140]                   future <- run(future)
  [20:24:31.140]                 invisible(future)
  [20:24:31.140]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.140]         }
  [20:24:31.140]         base::options(...future.oldOptions)
  [20:24:31.140]     })
  [20:24:31.140]     Sys.time
  [20:24:31.140]     if (base::is.na(TRUE)) {
  [20:24:31.140]     }
  [20:24:31.140]     else {
  [20:24:31.140]         base::sink(type = "output", split = FALSE)
  [20:24:31.140]         if (TRUE) {
  [20:24:31.140]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.140]         }
  [20:24:31.140]         else {
  [20:24:31.140]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.140]         }
  [20:24:31.140]         base::close(...future.stdout)
  [20:24:31.140]         ...future.stdout <- NULL
  [20:24:31.140]     }
  [20:24:31.140]     ...future.result$conditions <- ...future.conditions
  [20:24:31.140]     ...future.result
  [20:24:31.140] }
  [20:24:31.145] requestCore(): workers = 2
  [20:24:31.148] MulticoreFuture started
  [20:24:31.149] Chunk #1 of 2 ... DONE
  [20:24:31.150] Chunk #2 of 2 ...
  [20:24:31.162]  - Finding globals in 'args_list' chunk #2 ...
  [20:24:31.163] getGlobalsAndPackages() ...
  [20:24:31.163] Searching for globals...
  [20:24:31.164] 
  [20:24:31.164] Searching for globals ... DONE
  [20:24:31.165] - globals: [0] <none>
  [20:24:31.165] getGlobalsAndPackages() ... DONE
  [20:24:31.165] 
  [20:24:31.178] plan(): Setting new future strategy stack:
  [20:24:31.179] List of future strategies:
  [20:24:31.179] 1. multicore:
  [20:24:31.179]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.179]    - tweaked: FALSE
  [20:24:31.179]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.181] plan(): nbrOfWorkers() = 1
  [20:24:31.166] 
  [20:24:31.182]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:24:31.183] getGlobalsAndPackages() ...
  [20:24:31.183] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.184] plan(): Setting new future strategy stack:
  [20:24:31.184] Resolving globals: FALSE
  [20:24:31.185] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.184] List of future strategies:
  [20:24:31.184] 1. multicore:
  [20:24:31.184]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.184]    - tweaked: FALSE
  [20:24:31.184]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.184] 2. multicore:
  [20:24:31.184]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.184]    - tweaked: FALSE
  [20:24:31.184]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.185] - globals: [1] '...future.x_ii'
  [20:24:31.185] 
  [20:24:31.186] getGlobalsAndPackages() ... DONE
  [20:24:31.188] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.188] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.200] plan(): nbrOfWorkers() = 2
  [20:24:31.193] {
  [20:24:31.193]     {
  [20:24:31.193]         ...future.startTime <- base::Sys.time()
  [20:24:31.193]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.193]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.193]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.193]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.193]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.193]         {
  [20:24:31.193]             {
  [20:24:31.193]                 {
  [20:24:31.193]                   {
  [20:24:31.193]                     has_future <- base::requireNamespace("future", 
  [20:24:31.193]                       quietly = TRUE)
  [20:24:31.193]                     version <- if (has_future) 
  [20:24:31.193]                       utils::packageVersion("future")
  [20:24:31.193]                     else NULL
  [20:24:31.193]                     if (!has_future || version < "1.8.0") {
  [20:24:31.193]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.193]                         "", base::R.version$version.string), 
  [20:24:31.193]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.193]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.193]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.193]                           "release", "version")], collapse = " "), 
  [20:24:31.193]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.193]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.193]                         info)
  [20:24:31.193]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.193]                       if (!has_future) {
  [20:24:31.193]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.193]                           info)
  [20:24:31.193]                       }
  [20:24:31.193]                       else {
  [20:24:31.193]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.193]                           info, version)
  [20:24:31.193]                       }
  [20:24:31.193]                       base::stop(msg)
  [20:24:31.193]                     }
  [20:24:31.193]                   }
  [20:24:31.193]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.193]                   base::options(mc.cores = 1L)
  [20:24:31.193]                 }
  [20:24:31.193]                 base::local({
  [20:24:31.193]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.193]                     base::loadNamespace(pkg)
  [20:24:31.193]                     base::library(pkg, character.only = TRUE)
  [20:24:31.193]                   }
  [20:24:31.193]                 })
  [20:24:31.193]             }
  [20:24:31.193]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.193]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.193]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.193]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.193]             {
  [20:24:31.193]                 if (substitute) 
  [20:24:31.193]                   expr <- substitute(expr)
  [20:24:31.193]                 if (is.function(workers)) 
  [20:24:31.193]                   workers <- workers()
  [20:24:31.193]                 workers <- as.integer(workers)
  [20:24:31.193]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.193]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.193]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.193]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.193]                     local = TRUE, label = label, ...))
  [20:24:31.193]                 }
  [20:24:31.193]                 oopts <- options(mc.cores = workers)
  [20:24:31.193]                 on.exit(options(oopts))
  [20:24:31.193]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.193]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.193]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.193]                   label = label, ...)
  [20:24:31.193]                 if (!future$lazy) 
  [20:24:31.193]                   future <- run(future)
  [20:24:31.193]                 invisible(future)
  [20:24:31.193]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.193]         }
  [20:24:31.193]     }
  [20:24:31.193]     if (base::is.na(TRUE)) {
  [20:24:31.193]     }
  [20:24:31.193]     else {
  [20:24:31.193]         if (TRUE) {
  [20:24:31.193]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.193]                 open = "w")
  [20:24:31.193]         }
  [20:24:31.193]         else {
  [20:24:31.193]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.193]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.193]         }
  [20:24:31.193]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.193]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.193]             base::sink(type = "output", split = FALSE)
  [20:24:31.193]             base::close(...future.stdout)
  [20:24:31.193]         }, add = TRUE)
  [20:24:31.193]     }
  [20:24:31.193]     ...future.frame <- base::sys.nframe()
  [20:24:31.193]     ...future.conditions <- base::list()
  [20:24:31.193]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.193]     ...future.result <- base::tryCatch({
  [20:24:31.193]         base::withCallingHandlers({
  [20:24:31.193]             ...future.value <- base::withVisible(base::local({
  [20:24:31.193]                 doFuture::registerDoFuture()
  [20:24:31.193]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.193]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.193]                   {
  [20:24:31.193]                     a <- NULL
  [20:24:31.193]                     b <- NULL
  [20:24:31.193]                   }
  [20:24:31.193]                   ...future.env <- environment()
  [20:24:31.193]                   local({
  [20:24:31.193]                     for (name in names(...future.x_jj)) {
  [20:24:31.193]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.193]                         inherits = FALSE)
  [20:24:31.193]                     }
  [20:24:31.193]                   })
  [20:24:31.193]                   tryCatch({
  [20:24:31.193]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.193]                       plan = future::plan("next"))
  [20:24:31.193]                   }, error = identity)
  [20:24:31.193]                 })
  [20:24:31.193]             }))
  [20:24:31.193]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.193]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.193]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.193]                 version = "1.8")
  [20:24:31.193]         }, condition = base::local({
  [20:24:31.193]             c <- base::c
  [20:24:31.193]             inherits <- base::inherits
  [20:24:31.193]             invokeRestart <- base::invokeRestart
  [20:24:31.193]             length <- base::length
  [20:24:31.193]             list <- base::list
  [20:24:31.193]             seq.int <- base::seq.int
  [20:24:31.193]             signalCondition <- base::signalCondition
  [20:24:31.193]             sys.calls <- base::sys.calls
  [20:24:31.193]             Sys.time <- base::Sys.time
  [20:24:31.193]             `[[` <- base::`[[`
  [20:24:31.193]             `+` <- base::`+`
  [20:24:31.193]             `<<-` <- base::`<<-`
  [20:24:31.193]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.193]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.193]                   3L)]
  [20:24:31.193]             }
  [20:24:31.193]             function(cond) {
  [20:24:31.193]                 if (inherits(cond, "error")) {
  [20:24:31.193]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.193]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.193]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.193]                   signalCondition(cond)
  [20:24:31.193]                 }
  [20:24:31.193]                 else if (inherits(cond, "condition")) {
  [20:24:31.193]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.193]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.193]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.193]                   if (!signal) {
  [20:24:31.193]                     muffleCondition <- function (cond) 
  [20:24:31.193]                     {
  [20:24:31.193]                       inherits <- base::inherits
  [20:24:31.193]                       invokeRestart <- base::invokeRestart
  [20:24:31.193]                       muffled <- FALSE
  [20:24:31.193]                       if (inherits(cond, "message")) {
  [20:24:31.193]                         invokeRestart("muffleMessage")
  [20:24:31.193]                         muffled <- TRUE
  [20:24:31.193]                       }
  [20:24:31.193]                       else if (inherits(cond, "warning")) {
  [20:24:31.193]                         invokeRestart("muffleWarning")
  [20:24:31.193]                         muffled <- TRUE
  [20:24:31.193]                       }
  [20:24:31.193]                       else if (inherits(cond, "condition")) {
  [20:24:31.193]                         computeRestarts <- base::computeRestarts
  [20:24:31.193]                         grepl <- base::grepl
  [20:24:31.193]                         is.null <- base::is.null
  [20:24:31.193]                         restarts <- computeRestarts(cond)
  [20:24:31.193]                         for (restart in restarts) {
  [20:24:31.193]                           name <- restart$name
  [20:24:31.193]                           if (is.null(name)) 
  [20:24:31.193]                             next
  [20:24:31.193]                           if (!grepl("^muffle", name)) 
  [20:24:31.193]                             next
  [20:24:31.193]                           invokeRestart(restart)
  [20:24:31.193]                           muffled <- TRUE
  [20:24:31.193]                           break
  [20:24:31.193]                         }
  [20:24:31.193]                       }
  [20:24:31.193]                       invisible(muffled)
  [20:24:31.193]                     }
  [20:24:31.193]                     muffleCondition(cond)
  [20:24:31.193]                   }
  [20:24:31.193]                 }
  [20:24:31.193]             }
  [20:24:31.193]         }))
  [20:24:31.193]     }, error = function(ex) {
  [20:24:31.193]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.193]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.193]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.193]     }, finally = {
  [20:24:31.193]         {
  [20:24:31.193]             {
  [20:24:31.193]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.193]             }
  [20:24:31.193]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.193]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.193]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.193]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.193]             {
  [20:24:31.193]                 if (substitute) 
  [20:24:31.193]                   expr <- substitute(expr)
  [20:24:31.193]                 if (is.function(workers)) 
  [20:24:31.193]                   workers <- workers()
  [20:24:31.193]                 workers <- as.integer(workers)
  [20:24:31.193]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.193]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.193]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.193]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.193]                     local = TRUE, label = label, ...))
  [20:24:31.193]                 }
  [20:24:31.193]                 oopts <- options(mc.cores = workers)
  [20:24:31.193]                 on.exit(options(oopts))
  [20:24:31.193]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.193]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.193]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.193]                   label = label, ...)
  [20:24:31.193]                 if (!future$lazy) 
  [20:24:31.193]                   future <- run(future)
  [20:24:31.193]                 invisible(future)
  [20:24:31.193]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.193]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.193]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.193]             {
  [20:24:31.193]                 if (substitute) 
  [20:24:31.193]                   expr <- substitute(expr)
  [20:24:31.193]                 if (is.function(workers)) 
  [20:24:31.193]                   workers <- workers()
  [20:24:31.193]                 workers <- as.integer(workers)
  [20:24:31.193]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.193]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.193]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.193]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.193]                     local = TRUE, label = label, ...))
  [20:24:31.193]                 }
  [20:24:31.193]                 oopts <- options(mc.cores = workers)
  [20:24:31.193]                 on.exit(options(oopts))
  [20:24:31.193]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.193]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.193]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.193]                   label = label, ...)
  [20:24:31.193]                 if (!future$lazy) 
  [20:24:31.193]                   future <- run(future)
  [20:24:31.193]                 invisible(future)
  [20:24:31.193]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.193]         }
  [20:24:31.193]         base::options(...future.oldOptions)
  [20:24:31.193]     })
  [20:24:31.193]     Sys.time
  [20:24:31.193]     if (base::is.na(TRUE)) {
  [20:24:31.193]     }
  [20:24:31.193]     else {
  [20:24:31.193]         base::sink(type = "output", split = FALSE)
  [20:24:31.193]         if (TRUE) {
  [20:24:31.193]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.193]         }
  [20:24:31.193]         else {
  [20:24:31.193]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.193]         }
  [20:24:31.193]         base::close(...future.stdout)
  [20:24:31.193]         ...future.stdout <- NULL
  [20:24:31.193]     }
  [20:24:31.193]     ...future.result$conditions <- ...future.conditions
  [20:24:31.193]     ...future.result
  [20:24:31.193] }
  [20:24:31.215] requestCore(): workers = 2
  [20:24:31.218] MulticoreFuture started
  [20:24:31.219] Chunk #2 of 2 ... DONE
  [20:24:31.220] Launching 2 futures (chunks) ... DONE
  [20:24:31.220] - resolving futures
  [20:24:31.220]   - gathering results & relaying conditions (except errors)
  [20:24:31.221] resolve() on list ...
  [20:24:31.221]  recursive: 0
  [20:24:31.221]  length: 2
  [20:24:31.222] 
  [20:24:31.222] Future #1
  [20:24:31.225] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [20:24:31.226] - nx: 2
  [20:24:31.226] - relay: TRUE
  [20:24:31.226] - stdout: TRUE
  [20:24:31.226] - signal: TRUE
  [20:24:31.227] - resignal: FALSE
  [20:24:31.227] - force: FALSE
  [20:24:31.227] - relayed: [n=2] FALSE, FALSE
  [20:24:31.228] - queued futures: [n=2] FALSE, FALSE
  [20:24:31.228]  - until=1
  [20:24:31.228]  - relaying element #1
  [20:24:31.229] - relayed: [n=2] TRUE, FALSE
  [20:24:31.229] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.229] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [20:24:31.234] plan(): Setting new future strategy stack:
  [20:24:31.246]  length: 1 (resolved future 1)
  [20:24:31.246] List of future strategies:
  [20:24:31.246] 1. multicore:
  [20:24:31.246]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.246]    - tweaked: FALSE
  [20:24:31.246]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.248] plan(): nbrOfWorkers() = 1
  [20:24:31.250] plan(): Setting new future strategy stack:
  [20:24:31.251] List of future strategies:
  [20:24:31.251] 1. multicore:
  [20:24:31.251]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.251]    - tweaked: FALSE
  [20:24:31.251]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.251] 2. multicore:
  [20:24:31.251]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.251]    - tweaked: FALSE
  [20:24:31.251]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.253] plan(): nbrOfWorkers() = 2
  [20:24:31.254] Future #2
  [20:24:31.256] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [20:24:31.256] - nx: 2
  [20:24:31.257] - relay: TRUE
  [20:24:31.257] - stdout: TRUE
  [20:24:31.257] - signal: TRUE
  [20:24:31.257] - resignal: FALSE
  [20:24:31.258] - force: FALSE
  [20:24:31.258] - relayed: [n=2] TRUE, FALSE
  [20:24:31.258] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.259]  - until=2
  [20:24:31.259]  - relaying element #2
  [20:24:31.259] - relayed: [n=2] TRUE, TRUE
  [20:24:31.260] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.260] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [20:24:31.260]  length: 0 (resolved future 2)
  [20:24:31.261] Relaying remaining futures
  [20:24:31.261] signalConditionsASAP(NULL, pos=0) ...
  [20:24:31.261] - nx: 2
  [20:24:31.261] - relay: TRUE
  [20:24:31.262] - stdout: TRUE
  [20:24:31.262] - signal: TRUE
  [20:24:31.262] - resignal: FALSE
  [20:24:31.263] - force: FALSE
  [20:24:31.263] - relayed: [n=2] TRUE, TRUE
  [20:24:31.263] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:24:31.264] - relayed: [n=2] TRUE, TRUE
  [20:24:31.264] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.264] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:31.264] resolve() on list ... DONE
  [20:24:31.265] - collecting values of futures
  [20:24:31.265] - accumulating results
  [20:24:31.267] - processing errors (handler = 'stop')
  [20:24:31.268] - extracting results
  [20:24:31.268] doFuture() ... DONE
  - plan(list('multicore', 'multicore')) ... DONE
  - plan(list('multicore', 'multisession')) ...
  [20:24:31.269] plan(): Setting new future strategy stack:
  [20:24:31.269] List of future strategies:
  [20:24:31.269] 1. multicore:
  [20:24:31.269]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.269]    - tweaked: FALSE
  [20:24:31.269]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.269] 2. multisession:
  [20:24:31.269]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.269]    - tweaked: FALSE
  [20:24:31.269]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.288] plan(): nbrOfWorkers() = 2
  [20:24:31.288] doFuture() ...
  [20:24:31.299] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:31.300] - R expression:
  [20:24:31.300] {
  [20:24:31.300]     doFuture::registerDoFuture()
  [20:24:31.300]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.300]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.300]         {
  [20:24:31.300]             a <- NULL
  [20:24:31.300]             b <- NULL
  [20:24:31.300]         }
  [20:24:31.300]         ...future.env <- environment()
  [20:24:31.300]         local({
  [20:24:31.300]             for (name in names(...future.x_jj)) {
  [20:24:31.300]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.300]                   inherits = FALSE)
  [20:24:31.300]             }
  [20:24:31.300]         })
  [20:24:31.300]         tryCatch({
  [20:24:31.300]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.300]                 plan = future::plan("next"))
  [20:24:31.300]         }, error = identity)
  [20:24:31.300]     })
  [20:24:31.300] }
  [20:24:31.301] - identifying globals and packages ...
  [20:24:31.301] getGlobalsAndPackages() ...
  [20:24:31.302] Searching for globals...
  [20:24:31.316] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:31.316] Searching for globals ... DONE
  [20:24:31.317] Resolving globals: FALSE
  [20:24:31.318] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:31.318] - globals: [1] '...future.x_ii'
  [20:24:31.319] 
  [20:24:31.319] getGlobalsAndPackages() ... DONE
  [20:24:31.319] List of 1
  [20:24:31.319]  $ ...future.x_ii: NULL
  [20:24:31.319]  - attr(*, "where")=List of 1
  [20:24:31.319]   ..$ ...future.x_ii:<environment: 0x55bc221f8ec0> 
  [20:24:31.319]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.319]  - attr(*, "resolved")= logi FALSE
  [20:24:31.319]  - attr(*, "total_size")= num 0
  [20:24:31.326]   - R expression:
  [20:24:31.327] {
  [20:24:31.327]     doFuture::registerDoFuture()
  [20:24:31.327]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.327]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.327]         {
  [20:24:31.327]             a <- NULL
  [20:24:31.327]             b <- NULL
  [20:24:31.327]         }
  [20:24:31.327]         ...future.env <- environment()
  [20:24:31.327]         local({
  [20:24:31.327]             for (name in names(...future.x_jj)) {
  [20:24:31.327]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.327]                   inherits = FALSE)
  [20:24:31.327]             }
  [20:24:31.327]         })
  [20:24:31.327]         tryCatch({
  [20:24:31.327]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.327]                 plan = future::plan("next"))
  [20:24:31.327]         }, error = identity)
  [20:24:31.327]     })
  [20:24:31.327] }
  [20:24:31.327]   - globals: [1] '...future.x_ii'
  [20:24:31.328] List of 1
  [20:24:31.328]  $ ...future.x_ii: NULL
  [20:24:31.328]  - attr(*, "where")=List of 1
  [20:24:31.328]   ..$ ...future.x_ii:<environment: 0x55bc221f8ec0> 
  [20:24:31.328]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.328]  - attr(*, "resolved")= logi FALSE
  [20:24:31.328]  - attr(*, "total_size")= num 0
  [20:24:31.333]   - packages: [1] 'doFuture'
  [20:24:31.333] - identifying globals and packages ... DONE
  [20:24:31.334] Number of chunks: 2
  [20:24:31.335] Number of futures (= number of chunks): 2
  [20:24:31.335] Launching 2 futures (chunks) ...
  [20:24:31.335] Chunk #1 of 2 ...
  [20:24:31.336]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:31.336] getGlobalsAndPackages() ...
  [20:24:31.336] Searching for globals...
  [20:24:31.337] 
  [20:24:31.337] Searching for globals ... DONE
  [20:24:31.338] - globals: [0] <none>
  [20:24:31.340] getGlobalsAndPackages() ... DONE
  [20:24:31.340] 
  [20:24:31.340] 
  [20:24:31.340]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:31.341] getGlobalsAndPackages() ...
  [20:24:31.341] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.342] Resolving globals: FALSE
  [20:24:31.343] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.343] - globals: [1] '...future.x_ii'
  [20:24:31.343] 
  [20:24:31.344] getGlobalsAndPackages() ... DONE
  [20:24:31.345] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.346] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.354] {
  [20:24:31.354]     {
  [20:24:31.354]         ...future.startTime <- base::Sys.time()
  [20:24:31.354]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.354]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.354]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.354]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.354]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.354]         {
  [20:24:31.354]             {
  [20:24:31.354]                 {
  [20:24:31.354]                   {
  [20:24:31.354]                     has_future <- base::requireNamespace("future", 
  [20:24:31.354]                       quietly = TRUE)
  [20:24:31.354]                     version <- if (has_future) 
  [20:24:31.354]                       utils::packageVersion("future")
  [20:24:31.354]                     else NULL
  [20:24:31.354]                     if (!has_future || version < "1.8.0") {
  [20:24:31.354]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.354]                         "", base::R.version$version.string), 
  [20:24:31.354]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.354]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.354]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.354]                           "release", "version")], collapse = " "), 
  [20:24:31.354]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.354]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.354]                         info)
  [20:24:31.354]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.354]                       if (!has_future) {
  [20:24:31.354]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.354]                           info)
  [20:24:31.354]                       }
  [20:24:31.354]                       else {
  [20:24:31.354]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.354]                           info, version)
  [20:24:31.354]                       }
  [20:24:31.354]                       base::stop(msg)
  [20:24:31.354]                     }
  [20:24:31.354]                   }
  [20:24:31.354]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.354]                   base::options(mc.cores = 1L)
  [20:24:31.354]                 }
  [20:24:31.354]                 base::local({
  [20:24:31.354]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.354]                     base::loadNamespace(pkg)
  [20:24:31.354]                     base::library(pkg, character.only = TRUE)
  [20:24:31.354]                   }
  [20:24:31.354]                 })
  [20:24:31.354]             }
  [20:24:31.354]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.354]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.354]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:31.354]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:31.354]                 ...) 
  [20:24:31.354]             {
  [20:24:31.354]                 if (substitute) 
  [20:24:31.354]                   expr <- substitute(expr)
  [20:24:31.354]                 if (is.function(workers)) 
  [20:24:31.354]                   workers <- workers()
  [20:24:31.354]                 workers <- as.integer(workers)
  [20:24:31.354]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:31.354]                   workers >= 1)
  [20:24:31.354]                 if (workers == 1L) {
  [20:24:31.354]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.354]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:31.354]                     local = TRUE, label = label, ...))
  [20:24:31.354]                 }
  [20:24:31.354]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:31.354]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:31.354]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.354]                   globals = globals, persistent = persistent, 
  [20:24:31.354]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:31.354]                   label = label, ...)
  [20:24:31.354]                 if (!future$lazy) 
  [20:24:31.354]                   future <- run(future)
  [20:24:31.354]                 invisible(future)
  [20:24:31.354]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.354]         }
  [20:24:31.354]     }
  [20:24:31.354]     if (base::is.na(TRUE)) {
  [20:24:31.354]     }
  [20:24:31.354]     else {
  [20:24:31.354]         if (TRUE) {
  [20:24:31.354]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.354]                 open = "w")
  [20:24:31.354]         }
  [20:24:31.354]         else {
  [20:24:31.354]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.354]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.354]         }
  [20:24:31.354]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.354]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.354]             base::sink(type = "output", split = FALSE)
  [20:24:31.354]             base::close(...future.stdout)
  [20:24:31.354]         }, add = TRUE)
  [20:24:31.354]     }
  [20:24:31.354]     ...future.frame <- base::sys.nframe()
  [20:24:31.354]     ...future.conditions <- base::list()
  [20:24:31.354]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.354]     ...future.result <- base::tryCatch({
  [20:24:31.354]         base::withCallingHandlers({
  [20:24:31.354]             ...future.value <- base::withVisible(base::local({
  [20:24:31.354]                 doFuture::registerDoFuture()
  [20:24:31.354]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.354]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.354]                   {
  [20:24:31.354]                     a <- NULL
  [20:24:31.354]                     b <- NULL
  [20:24:31.354]                   }
  [20:24:31.354]                   ...future.env <- environment()
  [20:24:31.354]                   local({
  [20:24:31.354]                     for (name in names(...future.x_jj)) {
  [20:24:31.354]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.354]                         inherits = FALSE)
  [20:24:31.354]                     }
  [20:24:31.354]                   })
  [20:24:31.354]                   tryCatch({
  [20:24:31.354]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.354]                       plan = future::plan("next"))
  [20:24:31.354]                   }, error = identity)
  [20:24:31.354]                 })
  [20:24:31.354]             }))
  [20:24:31.354]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.354]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.354]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.354]                 version = "1.8")
  [20:24:31.354]         }, condition = base::local({
  [20:24:31.354]             c <- base::c
  [20:24:31.354]             inherits <- base::inherits
  [20:24:31.354]             invokeRestart <- base::invokeRestart
  [20:24:31.354]             length <- base::length
  [20:24:31.354]             list <- base::list
  [20:24:31.354]             seq.int <- base::seq.int
  [20:24:31.354]             signalCondition <- base::signalCondition
  [20:24:31.354]             sys.calls <- base::sys.calls
  [20:24:31.354]             Sys.time <- base::Sys.time
  [20:24:31.354]             `[[` <- base::`[[`
  [20:24:31.354]             `+` <- base::`+`
  [20:24:31.354]             `<<-` <- base::`<<-`
  [20:24:31.354]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.354]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.354]                   3L)]
  [20:24:31.354]             }
  [20:24:31.354]             function(cond) {
  [20:24:31.354]                 if (inherits(cond, "error")) {
  [20:24:31.354]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.354]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.354]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.354]                   signalCondition(cond)
  [20:24:31.354]                 }
  [20:24:31.354]                 else if (inherits(cond, "condition")) {
  [20:24:31.354]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.354]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.354]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.354]                   if (!signal) {
  [20:24:31.354]                     muffleCondition <- function (cond) 
  [20:24:31.354]                     {
  [20:24:31.354]                       inherits <- base::inherits
  [20:24:31.354]                       invokeRestart <- base::invokeRestart
  [20:24:31.354]                       muffled <- FALSE
  [20:24:31.354]                       if (inherits(cond, "message")) {
  [20:24:31.354]                         invokeRestart("muffleMessage")
  [20:24:31.354]                         muffled <- TRUE
  [20:24:31.354]                       }
  [20:24:31.354]                       else if (inherits(cond, "warning")) {
  [20:24:31.354]                         invokeRestart("muffleWarning")
  [20:24:31.354]                         muffled <- TRUE
  [20:24:31.354]                       }
  [20:24:31.354]                       else if (inherits(cond, "condition")) {
  [20:24:31.354]                         computeRestarts <- base::computeRestarts
  [20:24:31.354]                         grepl <- base::grepl
  [20:24:31.354]                         is.null <- base::is.null
  [20:24:31.354]                         restarts <- computeRestarts(cond)
  [20:24:31.354]                         for (restart in restarts) {
  [20:24:31.354]                           name <- restart$name
  [20:24:31.354]                           if (is.null(name)) 
  [20:24:31.354]                             next
  [20:24:31.354]                           if (!grepl("^muffle", name)) 
  [20:24:31.354]                             next
  [20:24:31.354]                           invokeRestart(restart)
  [20:24:31.354]                           muffled <- TRUE
  [20:24:31.354]                           break
  [20:24:31.354]                         }
  [20:24:31.354]                       }
  [20:24:31.354]                       invisible(muffled)
  [20:24:31.354]                     }
  [20:24:31.354]                     muffleCondition(cond)
  [20:24:31.354]                   }
  [20:24:31.354]                 }
  [20:24:31.354]             }
  [20:24:31.354]         }))
  [20:24:31.354]     }, error = function(ex) {
  [20:24:31.354]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.354]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.354]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.354]     }, finally = {
  [20:24:31.354]         {
  [20:24:31.354]             {
  [20:24:31.354]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.354]             }
  [20:24:31.354]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.354]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.354]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.354]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.354]             {
  [20:24:31.354]                 if (substitute) 
  [20:24:31.354]                   expr <- substitute(expr)
  [20:24:31.354]                 if (is.function(workers)) 
  [20:24:31.354]                   workers <- workers()
  [20:24:31.354]                 workers <- as.integer(workers)
  [20:24:31.354]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.354]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.354]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.354]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.354]                     local = TRUE, label = label, ...))
  [20:24:31.354]                 }
  [20:24:31.354]                 oopts <- options(mc.cores = workers)
  [20:24:31.354]                 on.exit(options(oopts))
  [20:24:31.354]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.354]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.354]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.354]                   label = label, ...)
  [20:24:31.354]                 if (!future$lazy) 
  [20:24:31.354]                   future <- run(future)
  [20:24:31.354]                 invisible(future)
  [20:24:31.354]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.354]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:31.354]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:24:31.354]                 label = NULL, ...) 
  [20:24:31.354]             {
  [20:24:31.354]                 if (substitute) 
  [20:24:31.354]                   expr <- substitute(expr)
  [20:24:31.354]                 if (is.function(workers)) 
  [20:24:31.354]                   workers <- workers()
  [20:24:31.354]                 workers <- as.integer(workers)
  [20:24:31.354]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:31.354]                   workers >= 1)
  [20:24:31.354]                 if (workers == 1L) {
  [20:24:31.354]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.354]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:31.354]                     local = TRUE, label = label, ...))
  [20:24:31.354]                 }
  [20:24:31.354]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:31.354]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:31.354]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.354]                   globals = globals, persistent = persistent, 
  [20:24:31.354]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:31.354]                   label = label, ...)
  [20:24:31.354]                 if (!future$lazy) 
  [20:24:31.354]                   future <- run(future)
  [20:24:31.354]                 invisible(future)
  [20:24:31.354]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.354]         }
  [20:24:31.354]         base::options(...future.oldOptions)
  [20:24:31.354]     })
  [20:24:31.354]     Sys.time
  [20:24:31.354]     if (base::is.na(TRUE)) {
  [20:24:31.354]     }
  [20:24:31.354]     else {
  [20:24:31.354]         base::sink(type = "output", split = FALSE)
  [20:24:31.354]         if (TRUE) {
  [20:24:31.354]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.354]         }
  [20:24:31.354]         else {
  [20:24:31.354]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.354]         }
  [20:24:31.354]         base::close(...future.stdout)
  [20:24:31.354]         ...future.stdout <- NULL
  [20:24:31.354]     }
  [20:24:31.354]     ...future.result$conditions <- ...future.conditions
  [20:24:31.354]     ...future.result
  [20:24:31.354] }
  [20:24:31.359] requestCore(): workers = 2
  [20:24:31.362] MulticoreFuture started
  [20:24:31.363] Chunk #1 of 2 ... DONE
  [20:24:31.364] Chunk #2 of 2 ...
  [20:24:31.364]  - Finding globals in 'args_list' chunk #2 ...
  [20:24:31.364] getGlobalsAndPackages() ...
  [20:24:31.365] Searching for globals...
  [20:24:31.366] 
  [20:24:31.366] Searching for globals ... DONE
  [20:24:31.367] - globals: [0] <none>
  [20:24:31.367] getGlobalsAndPackages() ... DONE
  [20:24:31.367] 
  [20:24:31.367] 
  [20:24:31.368]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:24:31.369] getGlobalsAndPackages() ...
  [20:24:31.378] plan(): Setting new future strategy stack:
  [20:24:31.378] List of future strategies:
  [20:24:31.378] 1. multisession:
  [20:24:31.378]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.378]    - tweaked: FALSE
  [20:24:31.378]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.380] plan(): nbrOfWorkers() = 1
  [20:24:31.383] plan(): Setting new future strategy stack:
  [20:24:31.383] List of future strategies:
  [20:24:31.383] 1. multicore:
  [20:24:31.383]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.383]    - tweaked: FALSE
  [20:24:31.383]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.383] 2. multisession:
  [20:24:31.383]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.383]    - tweaked: FALSE
  [20:24:31.383]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.385] plan(): nbrOfWorkers() = 2
  [20:24:31.370] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.398] Resolving globals: FALSE
  [20:24:31.399] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.400] - globals: [1] '...future.x_ii'
  [20:24:31.400] 
  [20:24:31.400] getGlobalsAndPackages() ... DONE
  [20:24:31.403] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.403] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.408] {
  [20:24:31.408]     {
  [20:24:31.408]         ...future.startTime <- base::Sys.time()
  [20:24:31.408]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.408]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.408]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.408]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.408]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.408]         {
  [20:24:31.408]             {
  [20:24:31.408]                 {
  [20:24:31.408]                   {
  [20:24:31.408]                     has_future <- base::requireNamespace("future", 
  [20:24:31.408]                       quietly = TRUE)
  [20:24:31.408]                     version <- if (has_future) 
  [20:24:31.408]                       utils::packageVersion("future")
  [20:24:31.408]                     else NULL
  [20:24:31.408]                     if (!has_future || version < "1.8.0") {
  [20:24:31.408]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.408]                         "", base::R.version$version.string), 
  [20:24:31.408]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.408]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.408]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.408]                           "release", "version")], collapse = " "), 
  [20:24:31.408]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.408]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.408]                         info)
  [20:24:31.408]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.408]                       if (!has_future) {
  [20:24:31.408]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.408]                           info)
  [20:24:31.408]                       }
  [20:24:31.408]                       else {
  [20:24:31.408]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.408]                           info, version)
  [20:24:31.408]                       }
  [20:24:31.408]                       base::stop(msg)
  [20:24:31.408]                     }
  [20:24:31.408]                   }
  [20:24:31.408]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.408]                   base::options(mc.cores = 1L)
  [20:24:31.408]                 }
  [20:24:31.408]                 base::local({
  [20:24:31.408]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.408]                     base::loadNamespace(pkg)
  [20:24:31.408]                     base::library(pkg, character.only = TRUE)
  [20:24:31.408]                   }
  [20:24:31.408]                 })
  [20:24:31.408]             }
  [20:24:31.408]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.408]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.408]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:31.408]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:31.408]                 ...) 
  [20:24:31.408]             {
  [20:24:31.408]                 if (substitute) 
  [20:24:31.408]                   expr <- substitute(expr)
  [20:24:31.408]                 if (is.function(workers)) 
  [20:24:31.408]                   workers <- workers()
  [20:24:31.408]                 workers <- as.integer(workers)
  [20:24:31.408]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:31.408]                   workers >= 1)
  [20:24:31.408]                 if (workers == 1L) {
  [20:24:31.408]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.408]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:31.408]                     local = TRUE, label = label, ...))
  [20:24:31.408]                 }
  [20:24:31.408]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:31.408]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:31.408]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.408]                   globals = globals, persistent = persistent, 
  [20:24:31.408]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:31.408]                   label = label, ...)
  [20:24:31.408]                 if (!future$lazy) 
  [20:24:31.408]                   future <- run(future)
  [20:24:31.408]                 invisible(future)
  [20:24:31.408]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.408]         }
  [20:24:31.408]     }
  [20:24:31.408]     if (base::is.na(TRUE)) {
  [20:24:31.408]     }
  [20:24:31.408]     else {
  [20:24:31.408]         if (TRUE) {
  [20:24:31.408]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.408]                 open = "w")
  [20:24:31.408]         }
  [20:24:31.408]         else {
  [20:24:31.408]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.408]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.408]         }
  [20:24:31.408]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.408]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.408]             base::sink(type = "output", split = FALSE)
  [20:24:31.408]             base::close(...future.stdout)
  [20:24:31.408]         }, add = TRUE)
  [20:24:31.408]     }
  [20:24:31.408]     ...future.frame <- base::sys.nframe()
  [20:24:31.408]     ...future.conditions <- base::list()
  [20:24:31.408]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.408]     ...future.result <- base::tryCatch({
  [20:24:31.408]         base::withCallingHandlers({
  [20:24:31.408]             ...future.value <- base::withVisible(base::local({
  [20:24:31.408]                 doFuture::registerDoFuture()
  [20:24:31.408]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.408]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.408]                   {
  [20:24:31.408]                     a <- NULL
  [20:24:31.408]                     b <- NULL
  [20:24:31.408]                   }
  [20:24:31.408]                   ...future.env <- environment()
  [20:24:31.408]                   local({
  [20:24:31.408]                     for (name in names(...future.x_jj)) {
  [20:24:31.408]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.408]                         inherits = FALSE)
  [20:24:31.408]                     }
  [20:24:31.408]                   })
  [20:24:31.408]                   tryCatch({
  [20:24:31.408]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.408]                       plan = future::plan("next"))
  [20:24:31.408]                   }, error = identity)
  [20:24:31.408]                 })
  [20:24:31.408]             }))
  [20:24:31.408]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.408]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.408]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.408]                 version = "1.8")
  [20:24:31.408]         }, condition = base::local({
  [20:24:31.408]             c <- base::c
  [20:24:31.408]             inherits <- base::inherits
  [20:24:31.408]             invokeRestart <- base::invokeRestart
  [20:24:31.408]             length <- base::length
  [20:24:31.408]             list <- base::list
  [20:24:31.408]             seq.int <- base::seq.int
  [20:24:31.408]             signalCondition <- base::signalCondition
  [20:24:31.408]             sys.calls <- base::sys.calls
  [20:24:31.408]             Sys.time <- base::Sys.time
  [20:24:31.408]             `[[` <- base::`[[`
  [20:24:31.408]             `+` <- base::`+`
  [20:24:31.408]             `<<-` <- base::`<<-`
  [20:24:31.408]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.408]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.408]                   3L)]
  [20:24:31.408]             }
  [20:24:31.408]             function(cond) {
  [20:24:31.408]                 if (inherits(cond, "error")) {
  [20:24:31.408]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.408]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.408]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.408]                   signalCondition(cond)
  [20:24:31.408]                 }
  [20:24:31.408]                 else if (inherits(cond, "condition")) {
  [20:24:31.408]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.408]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.408]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.408]                   if (!signal) {
  [20:24:31.408]                     muffleCondition <- function (cond) 
  [20:24:31.408]                     {
  [20:24:31.408]                       inherits <- base::inherits
  [20:24:31.408]                       invokeRestart <- base::invokeRestart
  [20:24:31.408]                       muffled <- FALSE
  [20:24:31.408]                       if (inherits(cond, "message")) {
  [20:24:31.408]                         invokeRestart("muffleMessage")
  [20:24:31.408]                         muffled <- TRUE
  [20:24:31.408]                       }
  [20:24:31.408]                       else if (inherits(cond, "warning")) {
  [20:24:31.408]                         invokeRestart("muffleWarning")
  [20:24:31.408]                         muffled <- TRUE
  [20:24:31.408]                       }
  [20:24:31.408]                       else if (inherits(cond, "condition")) {
  [20:24:31.408]                         computeRestarts <- base::computeRestarts
  [20:24:31.408]                         grepl <- base::grepl
  [20:24:31.408]                         is.null <- base::is.null
  [20:24:31.408]                         restarts <- computeRestarts(cond)
  [20:24:31.408]                         for (restart in restarts) {
  [20:24:31.408]                           name <- restart$name
  [20:24:31.408]                           if (is.null(name)) 
  [20:24:31.408]                             next
  [20:24:31.408]                           if (!grepl("^muffle", name)) 
  [20:24:31.408]                             next
  [20:24:31.408]                           invokeRestart(restart)
  [20:24:31.408]                           muffled <- TRUE
  [20:24:31.408]                           break
  [20:24:31.408]                         }
  [20:24:31.408]                       }
  [20:24:31.408]                       invisible(muffled)
  [20:24:31.408]                     }
  [20:24:31.408]                     muffleCondition(cond)
  [20:24:31.408]                   }
  [20:24:31.408]                 }
  [20:24:31.408]             }
  [20:24:31.408]         }))
  [20:24:31.408]     }, error = function(ex) {
  [20:24:31.408]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.408]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.408]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.408]     }, finally = {
  [20:24:31.408]         {
  [20:24:31.408]             {
  [20:24:31.408]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.408]             }
  [20:24:31.408]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.408]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.408]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.408]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.408]             {
  [20:24:31.408]                 if (substitute) 
  [20:24:31.408]                   expr <- substitute(expr)
  [20:24:31.408]                 if (is.function(workers)) 
  [20:24:31.408]                   workers <- workers()
  [20:24:31.408]                 workers <- as.integer(workers)
  [20:24:31.408]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.408]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.408]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.408]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.408]                     local = TRUE, label = label, ...))
  [20:24:31.408]                 }
  [20:24:31.408]                 oopts <- options(mc.cores = workers)
  [20:24:31.408]                 on.exit(options(oopts))
  [20:24:31.408]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.408]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.408]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.408]                   label = label, ...)
  [20:24:31.408]                 if (!future$lazy) 
  [20:24:31.408]                   future <- run(future)
  [20:24:31.408]                 invisible(future)
  [20:24:31.408]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.408]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:31.408]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:24:31.408]                 label = NULL, ...) 
  [20:24:31.408]             {
  [20:24:31.408]                 if (substitute) 
  [20:24:31.408]                   expr <- substitute(expr)
  [20:24:31.408]                 if (is.function(workers)) 
  [20:24:31.408]                   workers <- workers()
  [20:24:31.408]                 workers <- as.integer(workers)
  [20:24:31.408]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:31.408]                   workers >= 1)
  [20:24:31.408]                 if (workers == 1L) {
  [20:24:31.408]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.408]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:31.408]                     local = TRUE, label = label, ...))
  [20:24:31.408]                 }
  [20:24:31.408]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:31.408]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:31.408]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.408]                   globals = globals, persistent = persistent, 
  [20:24:31.408]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:31.408]                   label = label, ...)
  [20:24:31.408]                 if (!future$lazy) 
  [20:24:31.408]                   future <- run(future)
  [20:24:31.408]                 invisible(future)
  [20:24:31.408]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.408]         }
  [20:24:31.408]         base::options(...future.oldOptions)
  [20:24:31.408]     })
  [20:24:31.408]     Sys.time
  [20:24:31.408]     if (base::is.na(TRUE)) {
  [20:24:31.408]     }
  [20:24:31.408]     else {
  [20:24:31.408]         base::sink(type = "output", split = FALSE)
  [20:24:31.408]         if (TRUE) {
  [20:24:31.408]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.408]         }
  [20:24:31.408]         else {
  [20:24:31.408]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.408]         }
  [20:24:31.408]         base::close(...future.stdout)
  [20:24:31.408]         ...future.stdout <- NULL
  [20:24:31.408]     }
  [20:24:31.408]     ...future.result$conditions <- ...future.conditions
  [20:24:31.408]     ...future.result
  [20:24:31.408] }
  [20:24:31.438] requestCore(): workers = 2
  [20:24:31.441] MulticoreFuture started
  [20:24:31.442] Chunk #2 of 2 ... DONE
  [20:24:31.443] Launching 2 futures (chunks) ... DONE
  [20:24:31.443] - resolving futures
  [20:24:31.443]   - gathering results & relaying conditions (except errors)
  [20:24:31.444] resolve() on list ...
  [20:24:31.444]  recursive: 0
  [20:24:31.444]  length: 2
  [20:24:31.444] 
  [20:24:31.445] Future #1
  [20:24:31.454] plan(): Setting new future strategy stack:
  [20:24:31.454] List of future strategies:
  [20:24:31.454] 1. multisession:
  [20:24:31.454]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.454]    - tweaked: FALSE
  [20:24:31.454]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.472] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [20:24:31.472] - nx: 2
  [20:24:31.473] plan(): nbrOfWorkers() = 1
  [20:24:31.473] - relay: TRUE
  [20:24:31.473] - stdout: TRUE
  [20:24:31.473] - signal: TRUE
  [20:24:31.474] - resignal: FALSE
  [20:24:31.474] - force: FALSE
  [20:24:31.474] - relayed: [n=2] FALSE, FALSE
  [20:24:31.474] - queued futures: [n=2] FALSE, FALSE
  [20:24:31.475] plan(): Setting new future strategy stack:
  [20:24:31.475]  - until=1
  [20:24:31.475]  - relaying element #1
  [20:24:31.476] - relayed: [n=2] TRUE, FALSE
  [20:24:31.475] List of future strategies:
  [20:24:31.475] 1. multicore:
  [20:24:31.475]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.475]    - tweaked: FALSE
  [20:24:31.475]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.475] 2. multisession:
  [20:24:31.475]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.475]    - tweaked: FALSE
  [20:24:31.475]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.476] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.476] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [20:24:31.477] plan(): nbrOfWorkers() = 2
  [20:24:31.477]  length: 1 (resolved future 1)
  [20:24:31.486] Future #2
  [20:24:31.488] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [20:24:31.488] - nx: 2
  [20:24:31.489] - relay: TRUE
  [20:24:31.489] - stdout: TRUE
  [20:24:31.489] - signal: TRUE
  [20:24:31.489] - resignal: FALSE
  [20:24:31.502] - force: FALSE
  [20:24:31.502] - relayed: [n=2] TRUE, FALSE
  [20:24:31.502] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.503]  - until=2
  [20:24:31.503]  - relaying element #2
  [20:24:31.504] - relayed: [n=2] TRUE, TRUE
  [20:24:31.504] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.504] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [20:24:31.504]  length: 0 (resolved future 2)
  [20:24:31.505] Relaying remaining futures
  [20:24:31.505] signalConditionsASAP(NULL, pos=0) ...
  [20:24:31.505] - nx: 2
  [20:24:31.506] - relay: TRUE
  [20:24:31.506] - stdout: TRUE
  [20:24:31.506] - signal: TRUE
  [20:24:31.506] - resignal: FALSE
  [20:24:31.507] - force: FALSE
  [20:24:31.507] - relayed: [n=2] TRUE, TRUE
  [20:24:31.507] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:24:31.508] - relayed: [n=2] TRUE, TRUE
  [20:24:31.508] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.508] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:31.508] resolve() on list ... DONE
  [20:24:31.509] - collecting values of futures
  [20:24:31.509] - accumulating results
  [20:24:31.512] - processing errors (handler = 'stop')
  [20:24:31.512] - extracting results
  [20:24:31.512] doFuture() ... DONE
  - plan(list('multicore', 'multisession')) ... DONE
  - plan(list('multicore', 'cluster')) ...
  [20:24:31.513] plan(): Setting new future strategy stack:
  [20:24:31.530] List of future strategies:
  [20:24:31.530] 1. multicore:
  [20:24:31.530]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.530]    - tweaked: FALSE
  [20:24:31.530]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.530] 2. cluster:
  [20:24:31.530]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.530]    - tweaked: FALSE
  [20:24:31.530]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.532] plan(): nbrOfWorkers() = 2
  [20:24:31.533] doFuture() ...
  [20:24:31.542] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:31.543] - R expression:
  [20:24:31.543] {
  [20:24:31.543]     doFuture::registerDoFuture()
  [20:24:31.543]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.543]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.543]         {
  [20:24:31.543]             a <- NULL
  [20:24:31.543]             b <- NULL
  [20:24:31.543]         }
  [20:24:31.543]         ...future.env <- environment()
  [20:24:31.543]         local({
  [20:24:31.543]             for (name in names(...future.x_jj)) {
  [20:24:31.543]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.543]                   inherits = FALSE)
  [20:24:31.543]             }
  [20:24:31.543]         })
  [20:24:31.543]         tryCatch({
  [20:24:31.543]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.543]                 plan = future::plan("next"))
  [20:24:31.543]         }, error = identity)
  [20:24:31.543]     })
  [20:24:31.543] }
  [20:24:31.544] - identifying globals and packages ...
  [20:24:31.544] getGlobalsAndPackages() ...
  [20:24:31.545] Searching for globals...
  [20:24:31.575] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:31.575] Searching for globals ... DONE
  [20:24:31.575] Resolving globals: FALSE
  [20:24:31.577] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:31.577] - globals: [1] '...future.x_ii'
  [20:24:31.577] 
  [20:24:31.594] getGlobalsAndPackages() ... DONE
  [20:24:31.594] List of 1
  [20:24:31.594]  $ ...future.x_ii: NULL
  [20:24:31.594]  - attr(*, "where")=List of 1
  [20:24:31.594]   ..$ ...future.x_ii:<environment: 0x55bc221e5a40> 
  [20:24:31.594]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.594]  - attr(*, "resolved")= logi FALSE
  [20:24:31.594]  - attr(*, "total_size")= num 0
  [20:24:31.601]   - R expression:
  [20:24:31.601] {
  [20:24:31.601]     doFuture::registerDoFuture()
  [20:24:31.601]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.601]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.601]         {
  [20:24:31.601]             a <- NULL
  [20:24:31.601]             b <- NULL
  [20:24:31.601]         }
  [20:24:31.601]         ...future.env <- environment()
  [20:24:31.601]         local({
  [20:24:31.601]             for (name in names(...future.x_jj)) {
  [20:24:31.601]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.601]                   inherits = FALSE)
  [20:24:31.601]             }
  [20:24:31.601]         })
  [20:24:31.601]         tryCatch({
  [20:24:31.601]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.601]                 plan = future::plan("next"))
  [20:24:31.601]         }, error = identity)
  [20:24:31.601]     })
  [20:24:31.601] }
  [20:24:31.602]   - globals: [1] '...future.x_ii'
  [20:24:31.602] List of 1
  [20:24:31.602]  $ ...future.x_ii: NULL
  [20:24:31.602]  - attr(*, "where")=List of 1
  [20:24:31.602]   ..$ ...future.x_ii:<environment: 0x55bc221e5a40> 
  [20:24:31.602]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:31.602]  - attr(*, "resolved")= logi FALSE
  [20:24:31.602]  - attr(*, "total_size")= num 0
  [20:24:31.608]   - packages: [1] 'doFuture'
  [20:24:31.608] - identifying globals and packages ... DONE
  [20:24:31.609] Number of chunks: 2
  [20:24:31.609] Number of futures (= number of chunks): 2
  [20:24:31.634] Launching 2 futures (chunks) ...
  [20:24:31.635] Chunk #1 of 2 ...
  [20:24:31.635]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:31.635] getGlobalsAndPackages() ...
  [20:24:31.635] Searching for globals...
  [20:24:31.636] 
  [20:24:31.636] Searching for globals ... DONE
  [20:24:31.637] - globals: [0] <none>
  [20:24:31.637] getGlobalsAndPackages() ... DONE
  [20:24:31.637] 
  [20:24:31.637] 
  [20:24:31.638]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:31.638] getGlobalsAndPackages() ...
  [20:24:31.639] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.639] Resolving globals: FALSE
  [20:24:31.640] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.640] - globals: [1] '...future.x_ii'
  [20:24:31.641] 
  [20:24:31.641] getGlobalsAndPackages() ... DONE
  [20:24:31.646] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.646] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.667] {
  [20:24:31.667]     {
  [20:24:31.667]         ...future.startTime <- base::Sys.time()
  [20:24:31.667]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.667]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.667]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.667]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.667]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.667]         {
  [20:24:31.667]             {
  [20:24:31.667]                 {
  [20:24:31.667]                   {
  [20:24:31.667]                     has_future <- base::requireNamespace("future", 
  [20:24:31.667]                       quietly = TRUE)
  [20:24:31.667]                     version <- if (has_future) 
  [20:24:31.667]                       utils::packageVersion("future")
  [20:24:31.667]                     else NULL
  [20:24:31.667]                     if (!has_future || version < "1.8.0") {
  [20:24:31.667]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.667]                         "", base::R.version$version.string), 
  [20:24:31.667]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.667]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.667]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.667]                           "release", "version")], collapse = " "), 
  [20:24:31.667]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.667]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.667]                         info)
  [20:24:31.667]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.667]                       if (!has_future) {
  [20:24:31.667]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.667]                           info)
  [20:24:31.667]                       }
  [20:24:31.667]                       else {
  [20:24:31.667]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.667]                           info, version)
  [20:24:31.667]                       }
  [20:24:31.667]                       base::stop(msg)
  [20:24:31.667]                     }
  [20:24:31.667]                   }
  [20:24:31.667]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.667]                   base::options(mc.cores = 1L)
  [20:24:31.667]                 }
  [20:24:31.667]                 base::local({
  [20:24:31.667]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.667]                     base::loadNamespace(pkg)
  [20:24:31.667]                     base::library(pkg, character.only = TRUE)
  [20:24:31.667]                   }
  [20:24:31.667]                 })
  [20:24:31.667]             }
  [20:24:31.667]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.667]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.667]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:24:31.667]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:24:31.667]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:31.667]                 ...) 
  [20:24:31.667]             {
  [20:24:31.667]                 if (substitute) 
  [20:24:31.667]                   expr <- substitute(expr)
  [20:24:31.667]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:31.667]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.667]                   globals = globals, persistent = persistent, 
  [20:24:31.667]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:31.667]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:31.667]                   label = label, ...)
  [20:24:31.667]                 if (!future$lazy) 
  [20:24:31.667]                   future <- run(future)
  [20:24:31.667]                 invisible(future)
  [20:24:31.667]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.667]         }
  [20:24:31.667]     }
  [20:24:31.667]     if (base::is.na(TRUE)) {
  [20:24:31.667]     }
  [20:24:31.667]     else {
  [20:24:31.667]         if (TRUE) {
  [20:24:31.667]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.667]                 open = "w")
  [20:24:31.667]         }
  [20:24:31.667]         else {
  [20:24:31.667]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.667]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.667]         }
  [20:24:31.667]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.667]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.667]             base::sink(type = "output", split = FALSE)
  [20:24:31.667]             base::close(...future.stdout)
  [20:24:31.667]         }, add = TRUE)
  [20:24:31.667]     }
  [20:24:31.667]     ...future.frame <- base::sys.nframe()
  [20:24:31.667]     ...future.conditions <- base::list()
  [20:24:31.667]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.667]     ...future.result <- base::tryCatch({
  [20:24:31.667]         base::withCallingHandlers({
  [20:24:31.667]             ...future.value <- base::withVisible(base::local({
  [20:24:31.667]                 doFuture::registerDoFuture()
  [20:24:31.667]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.667]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.667]                   {
  [20:24:31.667]                     a <- NULL
  [20:24:31.667]                     b <- NULL
  [20:24:31.667]                   }
  [20:24:31.667]                   ...future.env <- environment()
  [20:24:31.667]                   local({
  [20:24:31.667]                     for (name in names(...future.x_jj)) {
  [20:24:31.667]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.667]                         inherits = FALSE)
  [20:24:31.667]                     }
  [20:24:31.667]                   })
  [20:24:31.667]                   tryCatch({
  [20:24:31.667]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.667]                       plan = future::plan("next"))
  [20:24:31.667]                   }, error = identity)
  [20:24:31.667]                 })
  [20:24:31.667]             }))
  [20:24:31.667]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.667]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.667]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.667]                 version = "1.8")
  [20:24:31.667]         }, condition = base::local({
  [20:24:31.667]             c <- base::c
  [20:24:31.667]             inherits <- base::inherits
  [20:24:31.667]             invokeRestart <- base::invokeRestart
  [20:24:31.667]             length <- base::length
  [20:24:31.667]             list <- base::list
  [20:24:31.667]             seq.int <- base::seq.int
  [20:24:31.667]             signalCondition <- base::signalCondition
  [20:24:31.667]             sys.calls <- base::sys.calls
  [20:24:31.667]             Sys.time <- base::Sys.time
  [20:24:31.667]             `[[` <- base::`[[`
  [20:24:31.667]             `+` <- base::`+`
  [20:24:31.667]             `<<-` <- base::`<<-`
  [20:24:31.667]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.667]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.667]                   3L)]
  [20:24:31.667]             }
  [20:24:31.667]             function(cond) {
  [20:24:31.667]                 if (inherits(cond, "error")) {
  [20:24:31.667]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.667]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.667]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.667]                   signalCondition(cond)
  [20:24:31.667]                 }
  [20:24:31.667]                 else if (inherits(cond, "condition")) {
  [20:24:31.667]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.667]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.667]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.667]                   if (!signal) {
  [20:24:31.667]                     muffleCondition <- function (cond) 
  [20:24:31.667]                     {
  [20:24:31.667]                       inherits <- base::inherits
  [20:24:31.667]                       invokeRestart <- base::invokeRestart
  [20:24:31.667]                       muffled <- FALSE
  [20:24:31.667]                       if (inherits(cond, "message")) {
  [20:24:31.667]                         invokeRestart("muffleMessage")
  [20:24:31.667]                         muffled <- TRUE
  [20:24:31.667]                       }
  [20:24:31.667]                       else if (inherits(cond, "warning")) {
  [20:24:31.667]                         invokeRestart("muffleWarning")
  [20:24:31.667]                         muffled <- TRUE
  [20:24:31.667]                       }
  [20:24:31.667]                       else if (inherits(cond, "condition")) {
  [20:24:31.667]                         computeRestarts <- base::computeRestarts
  [20:24:31.667]                         grepl <- base::grepl
  [20:24:31.667]                         is.null <- base::is.null
  [20:24:31.667]                         restarts <- computeRestarts(cond)
  [20:24:31.667]                         for (restart in restarts) {
  [20:24:31.667]                           name <- restart$name
  [20:24:31.667]                           if (is.null(name)) 
  [20:24:31.667]                             next
  [20:24:31.667]                           if (!grepl("^muffle", name)) 
  [20:24:31.667]                             next
  [20:24:31.667]                           invokeRestart(restart)
  [20:24:31.667]                           muffled <- TRUE
  [20:24:31.667]                           break
  [20:24:31.667]                         }
  [20:24:31.667]                       }
  [20:24:31.667]                       invisible(muffled)
  [20:24:31.667]                     }
  [20:24:31.667]                     muffleCondition(cond)
  [20:24:31.667]                   }
  [20:24:31.667]                 }
  [20:24:31.667]             }
  [20:24:31.667]         }))
  [20:24:31.667]     }, error = function(ex) {
  [20:24:31.667]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.667]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.667]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.667]     }, finally = {
  [20:24:31.667]         {
  [20:24:31.667]             {
  [20:24:31.667]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.667]             }
  [20:24:31.667]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.667]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.667]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.667]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.667]             {
  [20:24:31.667]                 if (substitute) 
  [20:24:31.667]                   expr <- substitute(expr)
  [20:24:31.667]                 if (is.function(workers)) 
  [20:24:31.667]                   workers <- workers()
  [20:24:31.667]                 workers <- as.integer(workers)
  [20:24:31.667]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.667]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.667]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.667]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.667]                     local = TRUE, label = label, ...))
  [20:24:31.667]                 }
  [20:24:31.667]                 oopts <- options(mc.cores = workers)
  [20:24:31.667]                 on.exit(options(oopts))
  [20:24:31.667]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.667]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.667]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.667]                   label = label, ...)
  [20:24:31.667]                 if (!future$lazy) 
  [20:24:31.667]                   future <- run(future)
  [20:24:31.667]                 invisible(future)
  [20:24:31.667]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.667]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:31.667]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [20:24:31.667]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [20:24:31.667]                 label = NULL, ...) 
  [20:24:31.667]             {
  [20:24:31.667]                 if (substitute) 
  [20:24:31.667]                   expr <- substitute(expr)
  [20:24:31.667]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:31.667]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.667]                   globals = globals, persistent = persistent, 
  [20:24:31.667]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:31.667]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:31.667]                   label = label, ...)
  [20:24:31.667]                 if (!future$lazy) 
  [20:24:31.667]                   future <- run(future)
  [20:24:31.667]                 invisible(future)
  [20:24:31.667]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.667]         }
  [20:24:31.667]         base::options(...future.oldOptions)
  [20:24:31.667]     })
  [20:24:31.667]     Sys.time
  [20:24:31.667]     if (base::is.na(TRUE)) {
  [20:24:31.667]     }
  [20:24:31.667]     else {
  [20:24:31.667]         base::sink(type = "output", split = FALSE)
  [20:24:31.667]         if (TRUE) {
  [20:24:31.667]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.667]         }
  [20:24:31.667]         else {
  [20:24:31.667]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.667]         }
  [20:24:31.667]         base::close(...future.stdout)
  [20:24:31.667]         ...future.stdout <- NULL
  [20:24:31.667]     }
  [20:24:31.667]     ...future.result$conditions <- ...future.conditions
  [20:24:31.667]     ...future.result
  [20:24:31.667] }
  [20:24:31.672] requestCore(): workers = 2
  [20:24:31.675] MulticoreFuture started
  [20:24:31.676] Chunk #1 of 2 ... DONE
  [20:24:31.676] Chunk #2 of 2 ...
  [20:24:31.676]  - Finding globals in 'args_list' chunk #2 ...
  [20:24:31.677] getGlobalsAndPackages() ...
  [20:24:31.677] Searching for globals...
  [20:24:31.678] 
  [20:24:31.679] Searching for globals ... DONE
  [20:24:31.679] - globals: [0] <none>
  [20:24:31.679] getGlobalsAndPackages() ... DONE
  [20:24:31.680] 
  [20:24:31.680] 
  [20:24:31.680]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:24:31.694] plan(): Setting new future strategy stack:
  [20:24:31.695] List of future strategies:
  [20:24:31.695] 1. cluster:
  [20:24:31.695]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.695]    - tweaked: FALSE
  [20:24:31.695]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.698] plan(): nbrOfWorkers() = 1
  [20:24:31.698] getGlobalsAndPackages() ...
  [20:24:31.698] - globals passed as-is: [1] '...future.x_ii'
  [20:24:31.699] Resolving globals: FALSE
  [20:24:31.700] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:31.700] plan(): Setting new future strategy stack:
  [20:24:31.700] - globals: [1] '...future.x_ii'
  [20:24:31.700] 
  [20:24:31.701] getGlobalsAndPackages() ... DONE
  [20:24:31.700] List of future strategies:
  [20:24:31.700] 1. multicore:
  [20:24:31.700]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.700]    - tweaked: FALSE
  [20:24:31.700]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.700] 2. cluster:
  [20:24:31.700]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.700]    - tweaked: FALSE
  [20:24:31.700]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.702] plan(): nbrOfWorkers() = 2
  [20:24:31.703] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:31.703] Packages needed by future strategies (n = 1): 'future'
  [20:24:31.708] {
  [20:24:31.708]     {
  [20:24:31.708]         ...future.startTime <- base::Sys.time()
  [20:24:31.708]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:31.708]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:31.708]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:31.708]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:31.708]             future.resolve.recursive = NULL, width = 80L)
  [20:24:31.708]         {
  [20:24:31.708]             {
  [20:24:31.708]                 {
  [20:24:31.708]                   {
  [20:24:31.708]                     has_future <- base::requireNamespace("future", 
  [20:24:31.708]                       quietly = TRUE)
  [20:24:31.708]                     version <- if (has_future) 
  [20:24:31.708]                       utils::packageVersion("future")
  [20:24:31.708]                     else NULL
  [20:24:31.708]                     if (!has_future || version < "1.8.0") {
  [20:24:31.708]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:31.708]                         "", base::R.version$version.string), 
  [20:24:31.708]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:31.708]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:31.708]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:31.708]                           "release", "version")], collapse = " "), 
  [20:24:31.708]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:31.708]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:31.708]                         info)
  [20:24:31.708]                       info <- base::paste(info, collapse = "; ")
  [20:24:31.708]                       if (!has_future) {
  [20:24:31.708]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:31.708]                           info)
  [20:24:31.708]                       }
  [20:24:31.708]                       else {
  [20:24:31.708]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:31.708]                           info, version)
  [20:24:31.708]                       }
  [20:24:31.708]                       base::stop(msg)
  [20:24:31.708]                     }
  [20:24:31.708]                   }
  [20:24:31.708]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:31.708]                   base::options(mc.cores = 1L)
  [20:24:31.708]                 }
  [20:24:31.708]                 base::local({
  [20:24:31.708]                   for (pkg in c("doFuture", "future")) {
  [20:24:31.708]                     base::loadNamespace(pkg)
  [20:24:31.708]                     base::library(pkg, character.only = TRUE)
  [20:24:31.708]                   }
  [20:24:31.708]                 })
  [20:24:31.708]             }
  [20:24:31.708]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:31.708]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.708]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [20:24:31.708]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:24:31.708]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:31.708]                 ...) 
  [20:24:31.708]             {
  [20:24:31.708]                 if (substitute) 
  [20:24:31.708]                   expr <- substitute(expr)
  [20:24:31.708]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:31.708]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.708]                   globals = globals, persistent = persistent, 
  [20:24:31.708]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:31.708]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:31.708]                   label = label, ...)
  [20:24:31.708]                 if (!future$lazy) 
  [20:24:31.708]                   future <- run(future)
  [20:24:31.708]                 invisible(future)
  [20:24:31.708]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.708]         }
  [20:24:31.708]     }
  [20:24:31.708]     if (base::is.na(TRUE)) {
  [20:24:31.708]     }
  [20:24:31.708]     else {
  [20:24:31.708]         if (TRUE) {
  [20:24:31.708]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:31.708]                 open = "w")
  [20:24:31.708]         }
  [20:24:31.708]         else {
  [20:24:31.708]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:31.708]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:31.708]         }
  [20:24:31.708]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:31.708]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:31.708]             base::sink(type = "output", split = FALSE)
  [20:24:31.708]             base::close(...future.stdout)
  [20:24:31.708]         }, add = TRUE)
  [20:24:31.708]     }
  [20:24:31.708]     ...future.frame <- base::sys.nframe()
  [20:24:31.708]     ...future.conditions <- base::list()
  [20:24:31.708]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:31.708]     ...future.result <- base::tryCatch({
  [20:24:31.708]         base::withCallingHandlers({
  [20:24:31.708]             ...future.value <- base::withVisible(base::local({
  [20:24:31.708]                 doFuture::registerDoFuture()
  [20:24:31.708]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:31.708]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:31.708]                   {
  [20:24:31.708]                     a <- NULL
  [20:24:31.708]                     b <- NULL
  [20:24:31.708]                   }
  [20:24:31.708]                   ...future.env <- environment()
  [20:24:31.708]                   local({
  [20:24:31.708]                     for (name in names(...future.x_jj)) {
  [20:24:31.708]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:31.708]                         inherits = FALSE)
  [20:24:31.708]                     }
  [20:24:31.708]                   })
  [20:24:31.708]                   tryCatch({
  [20:24:31.708]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:31.708]                       plan = future::plan("next"))
  [20:24:31.708]                   }, error = identity)
  [20:24:31.708]                 })
  [20:24:31.708]             }))
  [20:24:31.708]             future::FutureResult(value = ...future.value$value, 
  [20:24:31.708]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.708]                   ...future.rng), started = ...future.startTime, 
  [20:24:31.708]                 version = "1.8")
  [20:24:31.708]         }, condition = base::local({
  [20:24:31.708]             c <- base::c
  [20:24:31.708]             inherits <- base::inherits
  [20:24:31.708]             invokeRestart <- base::invokeRestart
  [20:24:31.708]             length <- base::length
  [20:24:31.708]             list <- base::list
  [20:24:31.708]             seq.int <- base::seq.int
  [20:24:31.708]             signalCondition <- base::signalCondition
  [20:24:31.708]             sys.calls <- base::sys.calls
  [20:24:31.708]             Sys.time <- base::Sys.time
  [20:24:31.708]             `[[` <- base::`[[`
  [20:24:31.708]             `+` <- base::`+`
  [20:24:31.708]             `<<-` <- base::`<<-`
  [20:24:31.708]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:31.708]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:31.708]                   3L)]
  [20:24:31.708]             }
  [20:24:31.708]             function(cond) {
  [20:24:31.708]                 if (inherits(cond, "error")) {
  [20:24:31.708]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.708]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:31.708]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:31.708]                   signalCondition(cond)
  [20:24:31.708]                 }
  [20:24:31.708]                 else if (inherits(cond, "condition")) {
  [20:24:31.708]                   signal <- FALSE && inherits(cond, character(0))
  [20:24:31.708]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:31.708]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:31.708]                   if (!signal) {
  [20:24:31.708]                     muffleCondition <- function (cond) 
  [20:24:31.708]                     {
  [20:24:31.708]                       inherits <- base::inherits
  [20:24:31.708]                       invokeRestart <- base::invokeRestart
  [20:24:31.708]                       muffled <- FALSE
  [20:24:31.708]                       if (inherits(cond, "message")) {
  [20:24:31.708]                         invokeRestart("muffleMessage")
  [20:24:31.708]                         muffled <- TRUE
  [20:24:31.708]                       }
  [20:24:31.708]                       else if (inherits(cond, "warning")) {
  [20:24:31.708]                         invokeRestart("muffleWarning")
  [20:24:31.708]                         muffled <- TRUE
  [20:24:31.708]                       }
  [20:24:31.708]                       else if (inherits(cond, "condition")) {
  [20:24:31.708]                         computeRestarts <- base::computeRestarts
  [20:24:31.708]                         grepl <- base::grepl
  [20:24:31.708]                         is.null <- base::is.null
  [20:24:31.708]                         restarts <- computeRestarts(cond)
  [20:24:31.708]                         for (restart in restarts) {
  [20:24:31.708]                           name <- restart$name
  [20:24:31.708]                           if (is.null(name)) 
  [20:24:31.708]                             next
  [20:24:31.708]                           if (!grepl("^muffle", name)) 
  [20:24:31.708]                             next
  [20:24:31.708]                           invokeRestart(restart)
  [20:24:31.708]                           muffled <- TRUE
  [20:24:31.708]                           break
  [20:24:31.708]                         }
  [20:24:31.708]                       }
  [20:24:31.708]                       invisible(muffled)
  [20:24:31.708]                     }
  [20:24:31.708]                     muffleCondition(cond)
  [20:24:31.708]                   }
  [20:24:31.708]                 }
  [20:24:31.708]             }
  [20:24:31.708]         }))
  [20:24:31.708]     }, error = function(ex) {
  [20:24:31.708]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:31.708]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:31.708]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:31.708]     }, finally = {
  [20:24:31.708]         {
  [20:24:31.708]             {
  [20:24:31.708]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:31.708]             }
  [20:24:31.708]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:31.708]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:31.708]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:24:31.708]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:31.708]             {
  [20:24:31.708]                 if (substitute) 
  [20:24:31.708]                   expr <- substitute(expr)
  [20:24:31.708]                 if (is.function(workers)) 
  [20:24:31.708]                   workers <- workers()
  [20:24:31.708]                 workers <- as.integer(workers)
  [20:24:31.708]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:24:31.708]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:24:31.708]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:31.708]                     lazy = lazy, seed = seed, globals = globals, 
  [20:24:31.708]                     local = TRUE, label = label, ...))
  [20:24:31.708]                 }
  [20:24:31.708]                 oopts <- options(mc.cores = workers)
  [20:24:31.708]                 on.exit(options(oopts))
  [20:24:31.708]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:24:31.708]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.708]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:24:31.708]                   label = label, ...)
  [20:24:31.708]                 if (!future$lazy) 
  [20:24:31.708]                   future <- run(future)
  [20:24:31.708]                 invisible(future)
  [20:24:31.708]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:31.708]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:24:31.708]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [20:24:31.708]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [20:24:31.708]                 label = NULL, ...) 
  [20:24:31.708]             {
  [20:24:31.708]                 if (substitute) 
  [20:24:31.708]                   expr <- substitute(expr)
  [20:24:31.708]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:24:31.708]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:31.708]                   globals = globals, persistent = persistent, 
  [20:24:31.708]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:24:31.708]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:24:31.708]                   label = label, ...)
  [20:24:31.708]                 if (!future$lazy) 
  [20:24:31.708]                   future <- run(future)
  [20:24:31.708]                 invisible(future)
  [20:24:31.708]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:31.708]         }
  [20:24:31.708]         base::options(...future.oldOptions)
  [20:24:31.708]     })
  [20:24:31.708]     Sys.time
  [20:24:31.708]     if (base::is.na(TRUE)) {
  [20:24:31.708]     }
  [20:24:31.708]     else {
  [20:24:31.708]         base::sink(type = "output", split = FALSE)
  [20:24:31.708]         if (TRUE) {
  [20:24:31.708]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:31.708]         }
  [20:24:31.708]         else {
  [20:24:31.708]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:31.708]         }
  [20:24:31.708]         base::close(...future.stdout)
  [20:24:31.708]         ...future.stdout <- NULL
  [20:24:31.708]     }
  [20:24:31.708]     ...future.result$conditions <- ...future.conditions
  [20:24:31.708]     ...future.result
  [20:24:31.708] }
  [20:24:31.730] requestCore(): workers = 2
  [20:24:31.733] MulticoreFuture started
  [20:24:31.734] Chunk #2 of 2 ... DONE
  [20:24:31.735] Launching 2 futures (chunks) ... DONE
  [20:24:31.735] - resolving futures
  [20:24:31.735]   - gathering results & relaying conditions (except errors)
  [20:24:31.736] resolve() on list ...
  [20:24:31.736]  recursive: 0
  [20:24:31.736]  length: 2
  [20:24:31.737] 
  [20:24:31.737] Future #1
  [20:24:31.740] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [20:24:31.740] - nx: 2
  [20:24:31.741] - relay: TRUE
  [20:24:31.741] - stdout: TRUE
  [20:24:31.741] - signal: TRUE
  [20:24:31.742] - resignal: FALSE
  [20:24:31.742] - force: FALSE
  [20:24:31.742] - relayed: [n=2] FALSE, FALSE
  [20:24:31.743] - queued futures: [n=2] FALSE, FALSE
  [20:24:31.743]  - until=1
  [20:24:31.743]  - relaying element #1
  [20:24:31.744] - relayed: [n=2] TRUE, FALSE
  [20:24:31.744] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.744] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [20:24:31.745]  length: 1 (resolved future 1)
  [20:24:31.746] plan(): Setting new future strategy stack:
  [20:24:31.746] List of future strategies:
  [20:24:31.746] 1. cluster:
  [20:24:31.746]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.746]    - tweaked: FALSE
  [20:24:31.746]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.749] plan(): nbrOfWorkers() = 1
  [20:24:31.762] plan(): Setting new future strategy stack:
  [20:24:31.762] List of future strategies:
  [20:24:31.762] 1. multicore:
  [20:24:31.762]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:31.762]    - tweaked: FALSE
  [20:24:31.762]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.762] 2. cluster:
  [20:24:31.762]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.762]    - tweaked: FALSE
  [20:24:31.762]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.764] plan(): nbrOfWorkers() = 2
  [20:24:31.766] Future #2
  [20:24:31.767] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [20:24:31.768] - nx: 2
  [20:24:31.768] - relay: TRUE
  [20:24:31.768] - stdout: TRUE
  [20:24:31.769] - signal: TRUE
  [20:24:31.769] - resignal: FALSE
  [20:24:31.769] - force: FALSE
  [20:24:31.769] - relayed: [n=2] TRUE, FALSE
  [20:24:31.770] - queued futures: [n=2] TRUE, FALSE
  [20:24:31.770]  - until=2
  [20:24:31.770]  - relaying element #2
  [20:24:31.771] - relayed: [n=2] TRUE, TRUE
  [20:24:31.771] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.771] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [20:24:31.772]  length: 0 (resolved future 2)
  [20:24:31.772] Relaying remaining futures
  [20:24:31.772] signalConditionsASAP(NULL, pos=0) ...
  [20:24:31.773] - nx: 2
  [20:24:31.773] - relay: TRUE
  [20:24:31.773] - stdout: TRUE
  [20:24:31.773] - signal: TRUE
  [20:24:31.774] - resignal: FALSE
  [20:24:31.774] - force: FALSE
  [20:24:31.774] - relayed: [n=2] TRUE, TRUE
  [20:24:31.774] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:24:31.775] - relayed: [n=2] TRUE, TRUE
  [20:24:31.775] - queued futures: [n=2] TRUE, TRUE
  [20:24:31.775] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:31.776] resolve() on list ... DONE
  [20:24:31.776] - collecting values of futures
  [20:24:31.777] - accumulating results
  [20:24:31.780] - processing errors (handler = 'stop')
  [20:24:31.781] - extracting results
  [20:24:31.781] doFuture() ... DONE
  - plan(list('multicore', 'cluster')) ... DONE
  - plan(list('multisession', 'sequential')) ...
  [20:24:31.782] plan(): Setting new future strategy stack:
  [20:24:31.782] List of future strategies:
  [20:24:31.782] 1. multisession:
  [20:24:31.782]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.782]    - tweaked: FALSE
  [20:24:31.782]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.782] 2. sequential:
  [20:24:31.782]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.782]    - tweaked: FALSE
  [20:24:31.782]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:31.783] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:24:31.784] multisession:
  [20:24:31.784] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:31.784] - tweaked: FALSE
  [20:24:31.784] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 29715
  [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/Rtmp1AMrfv/future.parent=2402.96250e1fe1e.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96250e1fe1e.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=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96250e1fe1e.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29715 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 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/Rtmp1AMrfv/future.parent=2402.9623c8632b3.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623c8632b3.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623c8632b3.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29715 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [20:24:51.531] getGlobalsAndPackages() ...
  [20:24:51.531] Not searching for globals
  [20:24:51.532] - globals: [0] <none>
  [20:24:51.532] getGlobalsAndPackages() ... DONE
  [20:24:51.536] Packages needed by the future expression (n = 0): <none>
  [20:24:51.537] Packages needed by future strategies (n = 1): 'future'
  [20:24:51.561] {
  [20:24:51.561]     {
  [20:24:51.561]         ...future.startTime <- base::Sys.time()
  [20:24:51.561]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:51.561]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:51.561]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:51.561]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:51.561]             future.resolve.recursive = NULL, width = 80L)
  [20:24:51.561]         {
  [20:24:51.561]             {
  [20:24:51.561]                 {
  [20:24:51.561]                   {
  [20:24:51.561]                     has_future <- base::requireNamespace("future", 
  [20:24:51.561]                       quietly = TRUE)
  [20:24:51.561]                     version <- if (has_future) 
  [20:24:51.561]                       utils::packageVersion("future")
  [20:24:51.561]                     else NULL
  [20:24:51.561]                     if (!has_future || version < "1.8.0") {
  [20:24:51.561]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:51.561]                         "", base::R.version$version.string), 
  [20:24:51.561]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:51.561]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:51.561]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:51.561]                           "release", "version")], collapse = " "), 
  [20:24:51.561]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:51.561]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:51.561]                         info)
  [20:24:51.561]                       info <- base::paste(info, collapse = "; ")
  [20:24:51.561]                       if (!has_future) {
  [20:24:51.561]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:51.561]                           info)
  [20:24:51.561]                       }
  [20:24:51.561]                       else {
  [20:24:51.561]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:51.561]                           info, version)
  [20:24:51.561]                       }
  [20:24:51.561]                       base::stop(msg)
  [20:24:51.561]                     }
  [20:24:51.561]                   }
  [20:24:51.561]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:51.561]                   base::options(mc.cores = 1L)
  [20:24:51.561]                 }
  [20:24:51.561]                 base::local({
  [20:24:51.561]                   for (pkg in "future") {
  [20:24:51.561]                     base::loadNamespace(pkg)
  [20:24:51.561]                     base::library(pkg, character.only = TRUE)
  [20:24:51.561]                   }
  [20:24:51.561]                 })
  [20:24:51.561]             }
  [20:24:51.561]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:51.561]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.561]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:51.561]                 label = NULL, ...) 
  [20:24:51.561]             {
  [20:24:51.561]                 if (substitute) 
  [20:24:51.561]                   expr <- substitute(expr)
  [20:24:51.561]                 local <- as.logical(local)
  [20:24:51.561]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.561]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.561]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.561]                   label = label, ...)
  [20:24:51.561]                 if (!future$lazy) 
  [20:24:51.561]                   future <- run(future)
  [20:24:51.561]                 invisible(future)
  [20:24:51.561]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.561]         }
  [20:24:51.561]     }
  [20:24:51.561]     if (base::is.na(TRUE)) {
  [20:24:51.561]     }
  [20:24:51.561]     else {
  [20:24:51.561]         if (TRUE) {
  [20:24:51.561]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:51.561]                 open = "w")
  [20:24:51.561]         }
  [20:24:51.561]         else {
  [20:24:51.561]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:51.561]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:51.561]         }
  [20:24:51.561]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:51.561]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:51.561]             base::sink(type = "output", split = FALSE)
  [20:24:51.561]             base::close(...future.stdout)
  [20:24:51.561]         }, add = TRUE)
  [20:24:51.561]     }
  [20:24:51.561]     ...future.frame <- base::sys.nframe()
  [20:24:51.561]     ...future.conditions <- base::list()
  [20:24:51.561]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:51.561]     ...future.result <- base::tryCatch({
  [20:24:51.561]         base::withCallingHandlers({
  [20:24:51.561]             ...future.value <- base::withVisible(base::local({
  [20:24:51.561]                 ...future.sendCondition <- local({
  [20:24:51.561]                   sendCondition <- NULL
  [20:24:51.561]                   function(frame = 1L) {
  [20:24:51.561]                     if (is.function(sendCondition)) 
  [20:24:51.561]                       return(sendCondition)
  [20:24:51.561]                     ns <- getNamespace("parallel")
  [20:24:51.561]                     if (exists("sendData", mode = "function", 
  [20:24:51.561]                       envir = ns)) {
  [20:24:51.561]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:24:51.561]                         envir = ns)
  [20:24:51.561]                       envir <- sys.frame(frame)
  [20:24:51.561]                       master <- NULL
  [20:24:51.561]                       while (!identical(envir, .GlobalEnv) && 
  [20:24:51.561]                         !identical(envir, emptyenv())) {
  [20:24:51.561]                         if (exists("master", mode = "list", envir = envir, 
  [20:24:51.561]                           inherits = FALSE)) {
  [20:24:51.561]                           master <- get("master", mode = "list", 
  [20:24:51.561]                             envir = envir, inherits = FALSE)
  [20:24:51.561]                           if (inherits(master, "SOCKnode")) {
  [20:24:51.561]                             sendCondition <<- function(cond) {
  [20:24:51.561]                               data <- list(type = "VALUE", value = cond, 
  [20:24:51.561]                                 success = TRUE)
  [20:24:51.561]                               parallel_sendData(master, data)
  [20:24:51.561]                             }
  [20:24:51.561]                             return(sendCondition)
  [20:24:51.561]                           }
  [20:24:51.561]                         }
  [20:24:51.561]                         frame <- frame + 1L
  [20:24:51.561]                         envir <- sys.frame(frame)
  [20:24:51.561]                       }
  [20:24:51.561]                     }
  [20:24:51.561]                     sendCondition <<- function(cond) NULL
  [20:24:51.561]                   }
  [20:24:51.561]                 })
  [20:24:51.561]                 withCallingHandlers({
  [20:24:51.561]                   NA
  [20:24:51.561]                 }, immediateCondition = function(cond) {
  [20:24:51.561]                   sendCondition <- ...future.sendCondition()
  [20:24:51.561]                   sendCondition(cond)
  [20:24:51.561]                   muffleCondition <- function (cond) 
  [20:24:51.561]                   {
  [20:24:51.561]                     inherits <- base::inherits
  [20:24:51.561]                     invokeRestart <- base::invokeRestart
  [20:24:51.561]                     muffled <- FALSE
  [20:24:51.561]                     if (inherits(cond, "message")) {
  [20:24:51.561]                       invokeRestart("muffleMessage")
  [20:24:51.561]                       muffled <- TRUE
  [20:24:51.561]                     }
  [20:24:51.561]                     else if (inherits(cond, "warning")) {
  [20:24:51.561]                       invokeRestart("muffleWarning")
  [20:24:51.561]                       muffled <- TRUE
  [20:24:51.561]                     }
  [20:24:51.561]                     else if (inherits(cond, "condition")) {
  [20:24:51.561]                       computeRestarts <- base::computeRestarts
  [20:24:51.561]                       grepl <- base::grepl
  [20:24:51.561]                       is.null <- base::is.null
  [20:24:51.561]                       restarts <- computeRestarts(cond)
  [20:24:51.561]                       for (restart in restarts) {
  [20:24:51.561]                         name <- restart$name
  [20:24:51.561]                         if (is.null(name)) 
  [20:24:51.561]                           next
  [20:24:51.561]                         if (!grepl("^muffle", name)) 
  [20:24:51.561]                           next
  [20:24:51.561]                         invokeRestart(restart)
  [20:24:51.561]                         muffled <- TRUE
  [20:24:51.561]                         break
  [20:24:51.561]                       }
  [20:24:51.561]                     }
  [20:24:51.561]                     invisible(muffled)
  [20:24:51.561]                   }
  [20:24:51.561]                   muffleCondition(cond)
  [20:24:51.561]                 })
  [20:24:51.561]             }))
  [20:24:51.561]             future::FutureResult(value = ...future.value$value, 
  [20:24:51.561]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.561]                   ...future.rng), started = ...future.startTime, 
  [20:24:51.561]                 version = "1.8")
  [20:24:51.561]         }, condition = base::local({
  [20:24:51.561]             c <- base::c
  [20:24:51.561]             inherits <- base::inherits
  [20:24:51.561]             invokeRestart <- base::invokeRestart
  [20:24:51.561]             length <- base::length
  [20:24:51.561]             list <- base::list
  [20:24:51.561]             seq.int <- base::seq.int
  [20:24:51.561]             signalCondition <- base::signalCondition
  [20:24:51.561]             sys.calls <- base::sys.calls
  [20:24:51.561]             Sys.time <- base::Sys.time
  [20:24:51.561]             `[[` <- base::`[[`
  [20:24:51.561]             `+` <- base::`+`
  [20:24:51.561]             `<<-` <- base::`<<-`
  [20:24:51.561]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:51.561]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:51.561]                   3L)]
  [20:24:51.561]             }
  [20:24:51.561]             function(cond) {
  [20:24:51.561]                 if (inherits(cond, "error")) {
  [20:24:51.561]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.561]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:51.561]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:51.561]                   signalCondition(cond)
  [20:24:51.561]                 }
  [20:24:51.561]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:51.561]                 ))) {
  [20:24:51.561]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:51.561]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.561]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:51.561]                   if (!signal) {
  [20:24:51.561]                     muffleCondition <- function (cond) 
  [20:24:51.561]                     {
  [20:24:51.561]                       inherits <- base::inherits
  [20:24:51.561]                       invokeRestart <- base::invokeRestart
  [20:24:51.561]                       muffled <- FALSE
  [20:24:51.561]                       if (inherits(cond, "message")) {
  [20:24:51.561]                         invokeRestart("muffleMessage")
  [20:24:51.561]                         muffled <- TRUE
  [20:24:51.561]                       }
  [20:24:51.561]                       else if (inherits(cond, "warning")) {
  [20:24:51.561]                         invokeRestart("muffleWarning")
  [20:24:51.561]                         muffled <- TRUE
  [20:24:51.561]                       }
  [20:24:51.561]                       else if (inherits(cond, "condition")) {
  [20:24:51.561]                         computeRestarts <- base::computeRestarts
  [20:24:51.561]                         grepl <- base::grepl
  [20:24:51.561]                         is.null <- base::is.null
  [20:24:51.561]                         restarts <- computeRestarts(cond)
  [20:24:51.561]                         for (restart in restarts) {
  [20:24:51.561]                           name <- restart$name
  [20:24:51.561]                           if (is.null(name)) 
  [20:24:51.561]                             next
  [20:24:51.561]                           if (!grepl("^muffle", name)) 
  [20:24:51.561]                             next
  [20:24:51.561]                           invokeRestart(restart)
  [20:24:51.561]                           muffled <- TRUE
  [20:24:51.561]                           break
  [20:24:51.561]                         }
  [20:24:51.561]                       }
  [20:24:51.561]                       invisible(muffled)
  [20:24:51.561]                     }
  [20:24:51.561]                     muffleCondition(cond)
  [20:24:51.561]                   }
  [20:24:51.561]                 }
  [20:24:51.561]             }
  [20:24:51.561]         }))
  [20:24:51.561]     }, error = function(ex) {
  [20:24:51.561]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:51.561]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.561]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:51.561]     }, finally = {
  [20:24:51.561]         {
  [20:24:51.561]             {
  [20:24:51.561]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:51.561]             }
  [20:24:51.561]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:51.561]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.561]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:51.561]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:51.561]                 ...) 
  [20:24:51.561]             {
  [20:24:51.561]                 if (substitute) 
  [20:24:51.561]                   expr <- substitute(expr)
  [20:24:51.561]                 if (is.function(workers)) 
  [20:24:51.561]                   workers <- workers()
  [20:24:51.561]                 workers <- as.integer(workers)
  [20:24:51.561]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:51.561]                   workers >= 1)
  [20:24:51.561]                 if (workers == 1L) {
  [20:24:51.561]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:51.561]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:51.561]                     local = TRUE, label = label, ...))
  [20:24:51.561]                 }
  [20:24:51.561]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:51.561]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:51.561]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.561]                   globals = globals, persistent = persistent, 
  [20:24:51.561]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:51.561]                   label = label, ...)
  [20:24:51.561]                 if (!future$lazy) 
  [20:24:51.561]                   future <- run(future)
  [20:24:51.561]                 invisible(future)
  [20:24:51.561]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:51.561]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:51.561]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:51.561]             {
  [20:24:51.561]                 if (substitute) 
  [20:24:51.561]                   expr <- substitute(expr)
  [20:24:51.561]                 local <- as.logical(local)
  [20:24:51.561]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.561]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.561]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.561]                   label = label, ...)
  [20:24:51.561]                 if (!future$lazy) 
  [20:24:51.561]                   future <- run(future)
  [20:24:51.561]                 invisible(future)
  [20:24:51.561]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.561]         }
  [20:24:51.561]         base::options(...future.oldOptions)
  [20:24:51.561]     })
  [20:24:51.561]     Sys.time
  [20:24:51.561]     if (base::is.na(TRUE)) {
  [20:24:51.561]     }
  [20:24:51.561]     else {
  [20:24:51.561]         base::sink(type = "output", split = FALSE)
  [20:24:51.561]         if (TRUE) {
  [20:24:51.561]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:51.561]         }
  [20:24:51.561]         else {
  [20:24:51.561]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:51.561]         }
  [20:24:51.561]         base::close(...future.stdout)
  [20:24:51.561]         ...future.stdout <- NULL
  [20:24:51.561]     }
  [20:24:51.561]     ...future.result$conditions <- ...future.conditions
  [20:24:51.561]     ...future.result
  [20:24:51.561] }
  [20:24:51.568] MultisessionFuture started
  [20:24:51.569] result() for ClusterFuture ...
  [20:24:51.570] receiveMessageFromWorker() for ClusterFuture ...
  [20:24:51.570] - Validating connection of MultisessionFuture
  [20:24:51.780] - received message: FutureResult
  [20:24:51.780] - Received FutureResult
  [20:24:51.781] - Erased future from FutureRegistry
  [20:24:51.781] result() for ClusterFuture ...
  [20:24:51.781] - result already collected: FutureResult
  [20:24:51.782] result() for ClusterFuture ... done
  [20:24:51.782] receiveMessageFromWorker() for ClusterFuture ... done
  [20:24:51.782] result() for ClusterFuture ... done
  [20:24:51.782] result() for ClusterFuture ...
  [20:24:51.783] - result already collected: FutureResult
  [20:24:51.783] result() for ClusterFuture ... done
  [20:24:51.783] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:24:51.784] plan(): nbrOfWorkers() = 2
  [20:24:51.785] doFuture() ...
  [20:24:51.789] - dummy globals (as locals): [2] 'a', 'b'
  [20:24:51.790] - R expression:
  [20:24:51.790] {
  [20:24:51.790]     doFuture::registerDoFuture()
  [20:24:51.790]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:51.790]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:51.790]         {
  [20:24:51.790]             a <- NULL
  [20:24:51.790]             b <- NULL
  [20:24:51.790]         }
  [20:24:51.790]         ...future.env <- environment()
  [20:24:51.790]         local({
  [20:24:51.790]             for (name in names(...future.x_jj)) {
  [20:24:51.790]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:51.790]                   inherits = FALSE)
  [20:24:51.790]             }
  [20:24:51.790]         })
  [20:24:51.790]         tryCatch({
  [20:24:51.790]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:51.790]                 plan = future::plan("next"))
  [20:24:51.790]         }, error = identity)
  [20:24:51.790]     })
  [20:24:51.790] }
  [20:24:51.790] - identifying globals and packages ...
  [20:24:51.791] getGlobalsAndPackages() ...
  [20:24:51.791] Searching for globals...
  [20:24:51.838] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:24:51.838] Searching for globals ... DONE
  [20:24:51.839] Resolving globals: FALSE
  [20:24:51.840] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:24:51.840] - globals: [1] '...future.x_ii'
  [20:24:51.841] 
  [20:24:51.841] getGlobalsAndPackages() ... DONE
  [20:24:51.841] List of 1
  [20:24:51.841]  $ ...future.x_ii: NULL
  [20:24:51.841]  - attr(*, "where")=List of 1
  [20:24:51.841]   ..$ ...future.x_ii:<environment: 0x55bc234a0e18> 
  [20:24:51.841]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:51.841]  - attr(*, "resolved")= logi FALSE
  [20:24:51.841]  - attr(*, "total_size")= num 0
  [20:24:51.847]   - R expression:
  [20:24:51.847] {
  [20:24:51.847]     doFuture::registerDoFuture()
  [20:24:51.847]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:51.847]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:51.847]         {
  [20:24:51.847]             a <- NULL
  [20:24:51.847]             b <- NULL
  [20:24:51.847]         }
  [20:24:51.847]         ...future.env <- environment()
  [20:24:51.847]         local({
  [20:24:51.847]             for (name in names(...future.x_jj)) {
  [20:24:51.847]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:24:51.847]                   inherits = FALSE)
  [20:24:51.847]             }
  [20:24:51.847]         })
  [20:24:51.847]         tryCatch({
  [20:24:51.847]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:51.847]                 plan = future::plan("next"))
  [20:24:51.847]         }, error = identity)
  [20:24:51.847]     })
  [20:24:51.847] }
  [20:24:51.848]   - globals: [1] '...future.x_ii'
  [20:24:51.848] List of 1
  [20:24:51.848]  $ ...future.x_ii: NULL
  [20:24:51.848]  - attr(*, "where")=List of 1
  [20:24:51.848]   ..$ ...future.x_ii:<environment: 0x55bc234a0e18> 
  [20:24:51.848]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:24:51.848]  - attr(*, "resolved")= logi FALSE
  [20:24:51.848]  - attr(*, "total_size")= num 0
  [20:24:51.856]   - packages: [1] 'doFuture'
  [20:24:51.856] - identifying globals and packages ... DONE
  [20:24:51.857] Number of chunks: 2
  [20:24:51.857] Number of futures (= number of chunks): 2
  [20:24:51.858] Launching 2 futures (chunks) ...
  [20:24:51.858] Chunk #1 of 2 ...
  [20:24:51.858]  - Finding globals in 'args_list' chunk #1 ...
  [20:24:51.859] getGlobalsAndPackages() ...
  [20:24:51.859] Searching for globals...
  [20:24:51.860] 
  [20:24:51.860] Searching for globals ... DONE
  [20:24:51.860] - globals: [0] <none>
  [20:24:51.860] getGlobalsAndPackages() ... DONE
  [20:24:51.860] 
  [20:24:51.861] 
  [20:24:51.861]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:24:51.884] getGlobalsAndPackages() ...
  [20:24:51.885] - globals passed as-is: [1] '...future.x_ii'
  [20:24:51.885] Resolving globals: FALSE
  [20:24:51.886] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:51.902] - globals: [1] '...future.x_ii'
  [20:24:51.907] 
  [20:24:51.907] getGlobalsAndPackages() ... DONE
  [20:24:51.910] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:51.911] Packages needed by future strategies (n = 1): 'future'
  [20:24:51.915] {
  [20:24:51.915]     {
  [20:24:51.915]         ...future.startTime <- base::Sys.time()
  [20:24:51.915]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:51.915]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:51.915]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:51.915]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:51.915]             future.resolve.recursive = NULL, width = 80L)
  [20:24:51.915]         {
  [20:24:51.915]             {
  [20:24:51.915]                 {
  [20:24:51.915]                   {
  [20:24:51.915]                     has_future <- base::requireNamespace("future", 
  [20:24:51.915]                       quietly = TRUE)
  [20:24:51.915]                     version <- if (has_future) 
  [20:24:51.915]                       utils::packageVersion("future")
  [20:24:51.915]                     else NULL
  [20:24:51.915]                     if (!has_future || version < "1.8.0") {
  [20:24:51.915]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:51.915]                         "", base::R.version$version.string), 
  [20:24:51.915]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:51.915]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:51.915]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:51.915]                           "release", "version")], collapse = " "), 
  [20:24:51.915]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:51.915]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:51.915]                         info)
  [20:24:51.915]                       info <- base::paste(info, collapse = "; ")
  [20:24:51.915]                       if (!has_future) {
  [20:24:51.915]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:51.915]                           info)
  [20:24:51.915]                       }
  [20:24:51.915]                       else {
  [20:24:51.915]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:51.915]                           info, version)
  [20:24:51.915]                       }
  [20:24:51.915]                       base::stop(msg)
  [20:24:51.915]                     }
  [20:24:51.915]                   }
  [20:24:51.915]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:51.915]                   base::options(mc.cores = 1L)
  [20:24:51.915]                 }
  [20:24:51.915]                 base::local({
  [20:24:51.915]                   for (pkg in c("doFuture", "future")) {
  [20:24:51.915]                     base::loadNamespace(pkg)
  [20:24:51.915]                     base::library(pkg, character.only = TRUE)
  [20:24:51.915]                   }
  [20:24:51.915]                 })
  [20:24:51.915]             }
  [20:24:51.915]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:51.915]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.915]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:51.915]                 label = NULL, ...) 
  [20:24:51.915]             {
  [20:24:51.915]                 if (substitute) 
  [20:24:51.915]                   expr <- substitute(expr)
  [20:24:51.915]                 local <- as.logical(local)
  [20:24:51.915]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.915]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.915]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.915]                   label = label, ...)
  [20:24:51.915]                 if (!future$lazy) 
  [20:24:51.915]                   future <- run(future)
  [20:24:51.915]                 invisible(future)
  [20:24:51.915]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.915]         }
  [20:24:51.915]     }
  [20:24:51.915]     if (base::is.na(TRUE)) {
  [20:24:51.915]     }
  [20:24:51.915]     else {
  [20:24:51.915]         if (TRUE) {
  [20:24:51.915]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:51.915]                 open = "w")
  [20:24:51.915]         }
  [20:24:51.915]         else {
  [20:24:51.915]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:51.915]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:51.915]         }
  [20:24:51.915]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:51.915]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:51.915]             base::sink(type = "output", split = FALSE)
  [20:24:51.915]             base::close(...future.stdout)
  [20:24:51.915]         }, add = TRUE)
  [20:24:51.915]     }
  [20:24:51.915]     ...future.frame <- base::sys.nframe()
  [20:24:51.915]     ...future.conditions <- base::list()
  [20:24:51.915]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:51.915]     ...future.result <- base::tryCatch({
  [20:24:51.915]         base::withCallingHandlers({
  [20:24:51.915]             ...future.value <- base::withVisible(base::local({
  [20:24:51.915]                 ...future.sendCondition <- local({
  [20:24:51.915]                   sendCondition <- NULL
  [20:24:51.915]                   function(frame = 1L) {
  [20:24:51.915]                     if (is.function(sendCondition)) 
  [20:24:51.915]                       return(sendCondition)
  [20:24:51.915]                     ns <- getNamespace("parallel")
  [20:24:51.915]                     if (exists("sendData", mode = "function", 
  [20:24:51.915]                       envir = ns)) {
  [20:24:51.915]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:24:51.915]                         envir = ns)
  [20:24:51.915]                       envir <- sys.frame(frame)
  [20:24:51.915]                       master <- NULL
  [20:24:51.915]                       while (!identical(envir, .GlobalEnv) && 
  [20:24:51.915]                         !identical(envir, emptyenv())) {
  [20:24:51.915]                         if (exists("master", mode = "list", envir = envir, 
  [20:24:51.915]                           inherits = FALSE)) {
  [20:24:51.915]                           master <- get("master", mode = "list", 
  [20:24:51.915]                             envir = envir, inherits = FALSE)
  [20:24:51.915]                           if (inherits(master, "SOCKnode")) {
  [20:24:51.915]                             sendCondition <<- function(cond) {
  [20:24:51.915]                               data <- list(type = "VALUE", value = cond, 
  [20:24:51.915]                                 success = TRUE)
  [20:24:51.915]                               parallel_sendData(master, data)
  [20:24:51.915]                             }
  [20:24:51.915]                             return(sendCondition)
  [20:24:51.915]                           }
  [20:24:51.915]                         }
  [20:24:51.915]                         frame <- frame + 1L
  [20:24:51.915]                         envir <- sys.frame(frame)
  [20:24:51.915]                       }
  [20:24:51.915]                     }
  [20:24:51.915]                     sendCondition <<- function(cond) NULL
  [20:24:51.915]                   }
  [20:24:51.915]                 })
  [20:24:51.915]                 withCallingHandlers({
  [20:24:51.915]                   {
  [20:24:51.915]                     doFuture::registerDoFuture()
  [20:24:51.915]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:51.915]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:51.915]                       {
  [20:24:51.915]                         a <- NULL
  [20:24:51.915]                         b <- NULL
  [20:24:51.915]                       }
  [20:24:51.915]                       ...future.env <- environment()
  [20:24:51.915]                       local({
  [20:24:51.915]                         for (name in names(...future.x_jj)) {
  [20:24:51.915]                           assign(name, ...future.x_jj[[name]], 
  [20:24:51.915]                             envir = ...future.env, inherits = FALSE)
  [20:24:51.915]                         }
  [20:24:51.915]                       })
  [20:24:51.915]                       tryCatch({
  [20:24:51.915]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:51.915]                           plan = future::plan("next"))
  [20:24:51.915]                       }, error = identity)
  [20:24:51.915]                     })
  [20:24:51.915]                   }
  [20:24:51.915]                 }, immediateCondition = function(cond) {
  [20:24:51.915]                   sendCondition <- ...future.sendCondition()
  [20:24:51.915]                   sendCondition(cond)
  [20:24:51.915]                   muffleCondition <- function (cond) 
  [20:24:51.915]                   {
  [20:24:51.915]                     inherits <- base::inherits
  [20:24:51.915]                     invokeRestart <- base::invokeRestart
  [20:24:51.915]                     muffled <- FALSE
  [20:24:51.915]                     if (inherits(cond, "message")) {
  [20:24:51.915]                       invokeRestart("muffleMessage")
  [20:24:51.915]                       muffled <- TRUE
  [20:24:51.915]                     }
  [20:24:51.915]                     else if (inherits(cond, "warning")) {
  [20:24:51.915]                       invokeRestart("muffleWarning")
  [20:24:51.915]                       muffled <- TRUE
  [20:24:51.915]                     }
  [20:24:51.915]                     else if (inherits(cond, "condition")) {
  [20:24:51.915]                       computeRestarts <- base::computeRestarts
  [20:24:51.915]                       grepl <- base::grepl
  [20:24:51.915]                       is.null <- base::is.null
  [20:24:51.915]                       restarts <- computeRestarts(cond)
  [20:24:51.915]                       for (restart in restarts) {
  [20:24:51.915]                         name <- restart$name
  [20:24:51.915]                         if (is.null(name)) 
  [20:24:51.915]                           next
  [20:24:51.915]                         if (!grepl("^muffle", name)) 
  [20:24:51.915]                           next
  [20:24:51.915]                         invokeRestart(restart)
  [20:24:51.915]                         muffled <- TRUE
  [20:24:51.915]                         break
  [20:24:51.915]                       }
  [20:24:51.915]                     }
  [20:24:51.915]                     invisible(muffled)
  [20:24:51.915]                   }
  [20:24:51.915]                   muffleCondition(cond)
  [20:24:51.915]                 })
  [20:24:51.915]             }))
  [20:24:51.915]             future::FutureResult(value = ...future.value$value, 
  [20:24:51.915]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.915]                   ...future.rng), started = ...future.startTime, 
  [20:24:51.915]                 version = "1.8")
  [20:24:51.915]         }, condition = base::local({
  [20:24:51.915]             c <- base::c
  [20:24:51.915]             inherits <- base::inherits
  [20:24:51.915]             invokeRestart <- base::invokeRestart
  [20:24:51.915]             length <- base::length
  [20:24:51.915]             list <- base::list
  [20:24:51.915]             seq.int <- base::seq.int
  [20:24:51.915]             signalCondition <- base::signalCondition
  [20:24:51.915]             sys.calls <- base::sys.calls
  [20:24:51.915]             Sys.time <- base::Sys.time
  [20:24:51.915]             `[[` <- base::`[[`
  [20:24:51.915]             `+` <- base::`+`
  [20:24:51.915]             `<<-` <- base::`<<-`
  [20:24:51.915]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:51.915]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:51.915]                   3L)]
  [20:24:51.915]             }
  [20:24:51.915]             function(cond) {
  [20:24:51.915]                 if (inherits(cond, "error")) {
  [20:24:51.915]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.915]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:51.915]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:51.915]                   signalCondition(cond)
  [20:24:51.915]                 }
  [20:24:51.915]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:51.915]                 ))) {
  [20:24:51.915]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:51.915]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.915]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:51.915]                   if (!signal) {
  [20:24:51.915]                     muffleCondition <- function (cond) 
  [20:24:51.915]                     {
  [20:24:51.915]                       inherits <- base::inherits
  [20:24:51.915]                       invokeRestart <- base::invokeRestart
  [20:24:51.915]                       muffled <- FALSE
  [20:24:51.915]                       if (inherits(cond, "message")) {
  [20:24:51.915]                         invokeRestart("muffleMessage")
  [20:24:51.915]                         muffled <- TRUE
  [20:24:51.915]                       }
  [20:24:51.915]                       else if (inherits(cond, "warning")) {
  [20:24:51.915]                         invokeRestart("muffleWarning")
  [20:24:51.915]                         muffled <- TRUE
  [20:24:51.915]                       }
  [20:24:51.915]                       else if (inherits(cond, "condition")) {
  [20:24:51.915]                         computeRestarts <- base::computeRestarts
  [20:24:51.915]                         grepl <- base::grepl
  [20:24:51.915]                         is.null <- base::is.null
  [20:24:51.915]                         restarts <- computeRestarts(cond)
  [20:24:51.915]                         for (restart in restarts) {
  [20:24:51.915]                           name <- restart$name
  [20:24:51.915]                           if (is.null(name)) 
  [20:24:51.915]                             next
  [20:24:51.915]                           if (!grepl("^muffle", name)) 
  [20:24:51.915]                             next
  [20:24:51.915]                           invokeRestart(restart)
  [20:24:51.915]                           muffled <- TRUE
  [20:24:51.915]                           break
  [20:24:51.915]                         }
  [20:24:51.915]                       }
  [20:24:51.915]                       invisible(muffled)
  [20:24:51.915]                     }
  [20:24:51.915]                     muffleCondition(cond)
  [20:24:51.915]                   }
  [20:24:51.915]                 }
  [20:24:51.915]             }
  [20:24:51.915]         }))
  [20:24:51.915]     }, error = function(ex) {
  [20:24:51.915]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:51.915]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.915]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:51.915]     }, finally = {
  [20:24:51.915]         {
  [20:24:51.915]             {
  [20:24:51.915]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:51.915]             }
  [20:24:51.915]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:51.915]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.915]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:51.915]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:51.915]                 ...) 
  [20:24:51.915]             {
  [20:24:51.915]                 if (substitute) 
  [20:24:51.915]                   expr <- substitute(expr)
  [20:24:51.915]                 if (is.function(workers)) 
  [20:24:51.915]                   workers <- workers()
  [20:24:51.915]                 workers <- as.integer(workers)
  [20:24:51.915]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:51.915]                   workers >= 1)
  [20:24:51.915]                 if (workers == 1L) {
  [20:24:51.915]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:51.915]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:51.915]                     local = TRUE, label = label, ...))
  [20:24:51.915]                 }
  [20:24:51.915]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:51.915]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:51.915]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.915]                   globals = globals, persistent = persistent, 
  [20:24:51.915]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:51.915]                   label = label, ...)
  [20:24:51.915]                 if (!future$lazy) 
  [20:24:51.915]                   future <- run(future)
  [20:24:51.915]                 invisible(future)
  [20:24:51.915]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:51.915]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:51.915]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:51.915]             {
  [20:24:51.915]                 if (substitute) 
  [20:24:51.915]                   expr <- substitute(expr)
  [20:24:51.915]                 local <- as.logical(local)
  [20:24:51.915]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.915]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.915]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.915]                   label = label, ...)
  [20:24:51.915]                 if (!future$lazy) 
  [20:24:51.915]                   future <- run(future)
  [20:24:51.915]                 invisible(future)
  [20:24:51.915]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.915]         }
  [20:24:51.915]         base::options(...future.oldOptions)
  [20:24:51.915]     })
  [20:24:51.915]     Sys.time
  [20:24:51.915]     if (base::is.na(TRUE)) {
  [20:24:51.915]     }
  [20:24:51.915]     else {
  [20:24:51.915]         base::sink(type = "output", split = FALSE)
  [20:24:51.915]         if (TRUE) {
  [20:24:51.915]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:51.915]         }
  [20:24:51.915]         else {
  [20:24:51.915]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:51.915]         }
  [20:24:51.915]         base::close(...future.stdout)
  [20:24:51.915]         ...future.stdout <- NULL
  [20:24:51.915]     }
  [20:24:51.915]     ...future.result$conditions <- ...future.conditions
  [20:24:51.915]     ...future.result
  [20:24:51.915] }
  [20:24:51.955] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [20:24:51.956] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [20:24:51.957] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [20:24:51.957] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [20:24:51.958] MultisessionFuture started
  [20:24:51.959] Chunk #1 of 2 ... DONE
  [20:24:51.959] Chunk #2 of 2 ...
  [20:24:51.959]  - Finding globals in 'args_list' chunk #2 ...
  [20:24:51.959] getGlobalsAndPackages() ...
  [20:24:51.959] Searching for globals...
  [20:24:51.960] 
  [20:24:51.960] Searching for globals ... DONE
  [20:24:51.961] - globals: [0] <none>
  [20:24:51.961] getGlobalsAndPackages() ... DONE
  [20:24:51.961] 
  [20:24:51.961] 
  [20:24:51.962]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:24:51.985] getGlobalsAndPackages() ...
  [20:24:51.985] - globals passed as-is: [1] '...future.x_ii'
  [20:24:51.985] Resolving globals: FALSE
  [20:24:51.986] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:24:51.987] - globals: [1] '...future.x_ii'
  [20:24:51.987] 
  [20:24:51.987] getGlobalsAndPackages() ... DONE
  [20:24:51.990] Packages needed by the future expression (n = 1): 'doFuture'
  [20:24:51.991] Packages needed by future strategies (n = 1): 'future'
  [20:24:51.995] {
  [20:24:51.995]     {
  [20:24:51.995]         ...future.startTime <- base::Sys.time()
  [20:24:51.995]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:24:51.995]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:24:51.995]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:24:51.995]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:24:51.995]             future.resolve.recursive = NULL, width = 80L)
  [20:24:51.995]         {
  [20:24:51.995]             {
  [20:24:51.995]                 {
  [20:24:51.995]                   {
  [20:24:51.995]                     has_future <- base::requireNamespace("future", 
  [20:24:51.995]                       quietly = TRUE)
  [20:24:51.995]                     version <- if (has_future) 
  [20:24:51.995]                       utils::packageVersion("future")
  [20:24:51.995]                     else NULL
  [20:24:51.995]                     if (!has_future || version < "1.8.0") {
  [20:24:51.995]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:24:51.995]                         "", base::R.version$version.string), 
  [20:24:51.995]                         platform = base::sprintf("%s (%s-bit)", 
  [20:24:51.995]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:24:51.995]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:24:51.995]                           "release", "version")], collapse = " "), 
  [20:24:51.995]                         hostname = base::Sys.info()[["nodename"]])
  [20:24:51.995]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:24:51.995]                         info)
  [20:24:51.995]                       info <- base::paste(info, collapse = "; ")
  [20:24:51.995]                       if (!has_future) {
  [20:24:51.995]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:24:51.995]                           info)
  [20:24:51.995]                       }
  [20:24:51.995]                       else {
  [20:24:51.995]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:24:51.995]                           info, version)
  [20:24:51.995]                       }
  [20:24:51.995]                       base::stop(msg)
  [20:24:51.995]                     }
  [20:24:51.995]                   }
  [20:24:51.995]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:24:51.995]                   base::options(mc.cores = 1L)
  [20:24:51.995]                 }
  [20:24:51.995]                 base::local({
  [20:24:51.995]                   for (pkg in c("doFuture", "future")) {
  [20:24:51.995]                     base::loadNamespace(pkg)
  [20:24:51.995]                     base::library(pkg, character.only = TRUE)
  [20:24:51.995]                   }
  [20:24:51.995]                 })
  [20:24:51.995]             }
  [20:24:51.995]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:24:51.995]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.995]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [20:24:51.995]                 label = NULL, ...) 
  [20:24:51.995]             {
  [20:24:51.995]                 if (substitute) 
  [20:24:51.995]                   expr <- substitute(expr)
  [20:24:51.995]                 local <- as.logical(local)
  [20:24:51.995]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.995]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.995]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.995]                   label = label, ...)
  [20:24:51.995]                 if (!future$lazy) 
  [20:24:51.995]                   future <- run(future)
  [20:24:51.995]                 invisible(future)
  [20:24:51.995]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.995]         }
  [20:24:51.995]     }
  [20:24:51.995]     if (base::is.na(TRUE)) {
  [20:24:51.995]     }
  [20:24:51.995]     else {
  [20:24:51.995]         if (TRUE) {
  [20:24:51.995]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:24:51.995]                 open = "w")
  [20:24:51.995]         }
  [20:24:51.995]         else {
  [20:24:51.995]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:24:51.995]                 windows = "NUL", "/dev/null"), open = "w")
  [20:24:51.995]         }
  [20:24:51.995]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:24:51.995]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:24:51.995]             base::sink(type = "output", split = FALSE)
  [20:24:51.995]             base::close(...future.stdout)
  [20:24:51.995]         }, add = TRUE)
  [20:24:51.995]     }
  [20:24:51.995]     ...future.frame <- base::sys.nframe()
  [20:24:51.995]     ...future.conditions <- base::list()
  [20:24:51.995]     ...future.rng <- base::globalenv()$.Random.seed
  [20:24:51.995]     ...future.result <- base::tryCatch({
  [20:24:51.995]         base::withCallingHandlers({
  [20:24:51.995]             ...future.value <- base::withVisible(base::local({
  [20:24:51.995]                 ...future.sendCondition <- local({
  [20:24:51.995]                   sendCondition <- NULL
  [20:24:51.995]                   function(frame = 1L) {
  [20:24:51.995]                     if (is.function(sendCondition)) 
  [20:24:51.995]                       return(sendCondition)
  [20:24:51.995]                     ns <- getNamespace("parallel")
  [20:24:51.995]                     if (exists("sendData", mode = "function", 
  [20:24:51.995]                       envir = ns)) {
  [20:24:51.995]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:24:51.995]                         envir = ns)
  [20:24:51.995]                       envir <- sys.frame(frame)
  [20:24:51.995]                       master <- NULL
  [20:24:51.995]                       while (!identical(envir, .GlobalEnv) && 
  [20:24:51.995]                         !identical(envir, emptyenv())) {
  [20:24:51.995]                         if (exists("master", mode = "list", envir = envir, 
  [20:24:51.995]                           inherits = FALSE)) {
  [20:24:51.995]                           master <- get("master", mode = "list", 
  [20:24:51.995]                             envir = envir, inherits = FALSE)
  [20:24:51.995]                           if (inherits(master, "SOCKnode")) {
  [20:24:51.995]                             sendCondition <<- function(cond) {
  [20:24:51.995]                               data <- list(type = "VALUE", value = cond, 
  [20:24:51.995]                                 success = TRUE)
  [20:24:51.995]                               parallel_sendData(master, data)
  [20:24:51.995]                             }
  [20:24:51.995]                             return(sendCondition)
  [20:24:51.995]                           }
  [20:24:51.995]                         }
  [20:24:51.995]                         frame <- frame + 1L
  [20:24:51.995]                         envir <- sys.frame(frame)
  [20:24:51.995]                       }
  [20:24:51.995]                     }
  [20:24:51.995]                     sendCondition <<- function(cond) NULL
  [20:24:51.995]                   }
  [20:24:51.995]                 })
  [20:24:51.995]                 withCallingHandlers({
  [20:24:51.995]                   {
  [20:24:51.995]                     doFuture::registerDoFuture()
  [20:24:51.995]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:24:51.995]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:24:51.995]                       {
  [20:24:51.995]                         a <- NULL
  [20:24:51.995]                         b <- NULL
  [20:24:51.995]                       }
  [20:24:51.995]                       ...future.env <- environment()
  [20:24:51.995]                       local({
  [20:24:51.995]                         for (name in names(...future.x_jj)) {
  [20:24:51.995]                           assign(name, ...future.x_jj[[name]], 
  [20:24:51.995]                             envir = ...future.env, inherits = FALSE)
  [20:24:51.995]                         }
  [20:24:51.995]                       })
  [20:24:51.995]                       tryCatch({
  [20:24:51.995]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:24:51.995]                           plan = future::plan("next"))
  [20:24:51.995]                       }, error = identity)
  [20:24:51.995]                     })
  [20:24:51.995]                   }
  [20:24:51.995]                 }, immediateCondition = function(cond) {
  [20:24:51.995]                   sendCondition <- ...future.sendCondition()
  [20:24:51.995]                   sendCondition(cond)
  [20:24:51.995]                   muffleCondition <- function (cond) 
  [20:24:51.995]                   {
  [20:24:51.995]                     inherits <- base::inherits
  [20:24:51.995]                     invokeRestart <- base::invokeRestart
  [20:24:51.995]                     muffled <- FALSE
  [20:24:51.995]                     if (inherits(cond, "message")) {
  [20:24:51.995]                       invokeRestart("muffleMessage")
  [20:24:51.995]                       muffled <- TRUE
  [20:24:51.995]                     }
  [20:24:51.995]                     else if (inherits(cond, "warning")) {
  [20:24:51.995]                       invokeRestart("muffleWarning")
  [20:24:51.995]                       muffled <- TRUE
  [20:24:51.995]                     }
  [20:24:51.995]                     else if (inherits(cond, "condition")) {
  [20:24:51.995]                       computeRestarts <- base::computeRestarts
  [20:24:51.995]                       grepl <- base::grepl
  [20:24:51.995]                       is.null <- base::is.null
  [20:24:51.995]                       restarts <- computeRestarts(cond)
  [20:24:51.995]                       for (restart in restarts) {
  [20:24:51.995]                         name <- restart$name
  [20:24:51.995]                         if (is.null(name)) 
  [20:24:51.995]                           next
  [20:24:51.995]                         if (!grepl("^muffle", name)) 
  [20:24:51.995]                           next
  [20:24:51.995]                         invokeRestart(restart)
  [20:24:51.995]                         muffled <- TRUE
  [20:24:51.995]                         break
  [20:24:51.995]                       }
  [20:24:51.995]                     }
  [20:24:51.995]                     invisible(muffled)
  [20:24:51.995]                   }
  [20:24:51.995]                   muffleCondition(cond)
  [20:24:51.995]                 })
  [20:24:51.995]             }))
  [20:24:51.995]             future::FutureResult(value = ...future.value$value, 
  [20:24:51.995]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.995]                   ...future.rng), started = ...future.startTime, 
  [20:24:51.995]                 version = "1.8")
  [20:24:51.995]         }, condition = base::local({
  [20:24:51.995]             c <- base::c
  [20:24:51.995]             inherits <- base::inherits
  [20:24:51.995]             invokeRestart <- base::invokeRestart
  [20:24:51.995]             length <- base::length
  [20:24:51.995]             list <- base::list
  [20:24:51.995]             seq.int <- base::seq.int
  [20:24:51.995]             signalCondition <- base::signalCondition
  [20:24:51.995]             sys.calls <- base::sys.calls
  [20:24:51.995]             Sys.time <- base::Sys.time
  [20:24:51.995]             `[[` <- base::`[[`
  [20:24:51.995]             `+` <- base::`+`
  [20:24:51.995]             `<<-` <- base::`<<-`
  [20:24:51.995]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:24:51.995]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:24:51.995]                   3L)]
  [20:24:51.995]             }
  [20:24:51.995]             function(cond) {
  [20:24:51.995]                 if (inherits(cond, "error")) {
  [20:24:51.995]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.995]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:24:51.995]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:24:51.995]                   signalCondition(cond)
  [20:24:51.995]                 }
  [20:24:51.995]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:24:51.995]                 ))) {
  [20:24:51.995]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:24:51.995]                   ...future.conditions[[length(...future.conditions) + 
  [20:24:51.995]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:24:51.995]                   if (!signal) {
  [20:24:51.995]                     muffleCondition <- function (cond) 
  [20:24:51.995]                     {
  [20:24:51.995]                       inherits <- base::inherits
  [20:24:51.995]                       invokeRestart <- base::invokeRestart
  [20:24:51.995]                       muffled <- FALSE
  [20:24:51.995]                       if (inherits(cond, "message")) {
  [20:24:51.995]                         invokeRestart("muffleMessage")
  [20:24:51.995]                         muffled <- TRUE
  [20:24:51.995]                       }
  [20:24:51.995]                       else if (inherits(cond, "warning")) {
  [20:24:51.995]                         invokeRestart("muffleWarning")
  [20:24:51.995]                         muffled <- TRUE
  [20:24:51.995]                       }
  [20:24:51.995]                       else if (inherits(cond, "condition")) {
  [20:24:51.995]                         computeRestarts <- base::computeRestarts
  [20:24:51.995]                         grepl <- base::grepl
  [20:24:51.995]                         is.null <- base::is.null
  [20:24:51.995]                         restarts <- computeRestarts(cond)
  [20:24:51.995]                         for (restart in restarts) {
  [20:24:51.995]                           name <- restart$name
  [20:24:51.995]                           if (is.null(name)) 
  [20:24:51.995]                             next
  [20:24:51.995]                           if (!grepl("^muffle", name)) 
  [20:24:51.995]                             next
  [20:24:51.995]                           invokeRestart(restart)
  [20:24:51.995]                           muffled <- TRUE
  [20:24:51.995]                           break
  [20:24:51.995]                         }
  [20:24:51.995]                       }
  [20:24:51.995]                       invisible(muffled)
  [20:24:51.995]                     }
  [20:24:51.995]                     muffleCondition(cond)
  [20:24:51.995]                   }
  [20:24:51.995]                 }
  [20:24:51.995]             }
  [20:24:51.995]         }))
  [20:24:51.995]     }, error = function(ex) {
  [20:24:51.995]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:24:51.995]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:24:51.995]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:24:51.995]     }, finally = {
  [20:24:51.995]         {
  [20:24:51.995]             {
  [20:24:51.995]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:24:51.995]             }
  [20:24:51.995]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:24:51.995]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:24:51.995]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:24:51.995]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:24:51.995]                 ...) 
  [20:24:51.995]             {
  [20:24:51.995]                 if (substitute) 
  [20:24:51.995]                   expr <- substitute(expr)
  [20:24:51.995]                 if (is.function(workers)) 
  [20:24:51.995]                   workers <- workers()
  [20:24:51.995]                 workers <- as.integer(workers)
  [20:24:51.995]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:24:51.995]                   workers >= 1)
  [20:24:51.995]                 if (workers == 1L) {
  [20:24:51.995]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:24:51.995]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:24:51.995]                     local = TRUE, label = label, ...))
  [20:24:51.995]                 }
  [20:24:51.995]                 workers <- ClusterRegistry("start", workers = workers)
  [20:24:51.995]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:24:51.995]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.995]                   globals = globals, persistent = persistent, 
  [20:24:51.995]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:24:51.995]                   label = label, ...)
  [20:24:51.995]                 if (!future$lazy) 
  [20:24:51.995]                   future <- run(future)
  [20:24:51.995]                 invisible(future)
  [20:24:51.995]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:24:51.995]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [20:24:51.995]                 earlySignal = FALSE, label = NULL, ...) 
  [20:24:51.995]             {
  [20:24:51.995]                 if (substitute) 
  [20:24:51.995]                   expr <- substitute(expr)
  [20:24:51.995]                 local <- as.logical(local)
  [20:24:51.995]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [20:24:51.995]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:24:51.995]                   globals = globals, local = local, earlySignal = earlySignal, 
  [20:24:51.995]                   label = label, ...)
  [20:24:51.995]                 if (!future$lazy) 
  [20:24:51.995]                   future <- run(future)
  [20:24:51.995]                 invisible(future)
  [20:24:51.995]             }), .cleanup = FALSE, .init = FALSE)
  [20:24:51.995]         }
  [20:24:51.995]         base::options(...future.oldOptions)
  [20:24:51.995]     })
  [20:24:51.995]     Sys.time
  [20:24:51.995]     if (base::is.na(TRUE)) {
  [20:24:51.995]     }
  [20:24:51.995]     else {
  [20:24:51.995]         base::sink(type = "output", split = FALSE)
  [20:24:51.995]         if (TRUE) {
  [20:24:51.995]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:24:51.995]         }
  [20:24:51.995]         else {
  [20:24:51.995]             ...future.result["stdout"] <- base::list(NULL)
  [20:24:51.995]         }
  [20:24:51.995]         base::close(...future.stdout)
  [20:24:51.995]         ...future.stdout <- NULL
  [20:24:51.995]     }
  [20:24:51.995]     ...future.result$conditions <- ...future.conditions
  [20:24:51.995]     ...future.result
  [20:24:51.995] }
  [20:24:52.029] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [20:24:52.029] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [20:24:52.046] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [20:24:52.046] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [20:24:52.048] MultisessionFuture started
  [20:24:52.048] Chunk #2 of 2 ... DONE
  [20:24:52.048] Launching 2 futures (chunks) ... DONE
  [20:24:52.048] - resolving futures
  [20:24:52.049]   - gathering results & relaying conditions (except errors)
  [20:24:52.049] resolve() on list ...
  [20:24:52.054]  recursive: 0
  [20:24:52.054]  length: 2
  [20:24:52.055] 
  [20:24:52.245] receiveMessageFromWorker() for ClusterFuture ...
  [20:24:52.245] - Validating connection of MultisessionFuture
  [20:24:52.286] - received message: FutureResult
  [20:24:52.287] - Received FutureResult
  [20:24:52.287] - Erased future from FutureRegistry
  [20:24:52.287] result() for ClusterFuture ...
  [20:24:52.287] - result already collected: FutureResult
  [20:24:52.288] result() for ClusterFuture ... done
  [20:24:52.288] receiveMessageFromWorker() for ClusterFuture ... done
  [20:24:52.288] Future #1
  [20:24:52.288] result() for ClusterFuture ...
  [20:24:52.288] - result already collected: FutureResult
  [20:24:52.289] result() for ClusterFuture ... done
  [20:24:52.289] result() for ClusterFuture ...
  [20:24:52.289] - result already collected: FutureResult
  [20:24:52.290] result() for ClusterFuture ... done
  [20:24:52.290] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [20:24:52.290] - nx: 2
  [20:24:52.290] - relay: TRUE
  [20:24:52.290] - stdout: TRUE
  [20:24:52.291] - signal: TRUE
  [20:24:52.291] - resignal: FALSE
  [20:24:52.291] - force: FALSE
  [20:24:52.291] - relayed: [n=2] FALSE, FALSE
  [20:24:52.291] - queued futures: [n=2] FALSE, FALSE
  [20:24:52.292]  - until=1
  [20:24:52.292]  - relaying element #1
  [20:24:52.292] result() for ClusterFuture ...
  [20:24:52.292] - result already collected: FutureResult
  [20:24:52.293] result() for ClusterFuture ... done
  [20:24:52.293] result() for ClusterFuture ...
  [20:24:52.293] - result already collected: FutureResult
  [20:24:52.293] result() for ClusterFuture ... done
  [20:24:52.294] result() for ClusterFuture ...
  [20:24:52.294] - result already collected: FutureResult
  [20:24:52.294] result() for ClusterFuture ... done
  [20:24:52.295] result() for ClusterFuture ...
  [20:24:52.295] - result already collected: FutureResult
  [20:24:52.295] result() for ClusterFuture ... done
  [20:24:52.295] - relayed: [n=2] TRUE, FALSE
  [20:24:52.296] - queued futures: [n=2] TRUE, FALSE
  [20:24:52.296] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [20:24:52.296]  length: 1 (resolved future 1)
  [20:24:52.426] receiveMessageFromWorker() for ClusterFuture ...
  [20:24:52.427] - Validating connection of MultisessionFuture
  [20:24:52.470] - received message: FutureResult
  [20:24:52.471] - Received FutureResult
  [20:24:52.471] - Erased future from FutureRegistry
  [20:24:52.471] result() for ClusterFuture ...
  [20:24:52.471] - result already collected: FutureResult
  [20:24:52.472] result() for ClusterFuture ... done
  [20:24:52.472] receiveMessageFromWorker() for ClusterFuture ... done
  [20:24:52.472] Future #2
  [20:24:52.472] result() for ClusterFuture ...
  [20:24:52.473] - result already collected: FutureResult
  [20:24:52.473] result() for ClusterFuture ... done
  [20:24:52.473] result() for ClusterFuture ...
  [20:24:52.473] - result already collected: FutureResult
  [20:24:52.474] result() for ClusterFuture ... done
  [20:24:52.474] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [20:24:52.474] - nx: 2
  [20:24:52.475] - relay: TRUE
  [20:24:52.475] - stdout: TRUE
  [20:24:52.475] - signal: TRUE
  [20:24:52.475] - resignal: FALSE
  [20:24:52.475] - force: FALSE
  [20:24:52.476] - relayed: [n=2] TRUE, FALSE
  [20:24:52.476] - queued futures: [n=2] TRUE, FALSE
  [20:24:52.476]  - until=2
  [20:24:52.476]  - relaying element #2
  [20:24:52.477] result() for ClusterFuture ...
  [20:24:52.477] - result already collected: FutureResult
  [20:24:52.477] result() for ClusterFuture ... done
  [20:24:52.478] result() for ClusterFuture ...
  [20:24:52.478] - result already collected: FutureResult
  [20:24:52.478] result() for ClusterFuture ... done
  [20:24:52.478] result() for ClusterFuture ...
  [20:24:52.479] - result already collected: FutureResult
  [20:24:52.479] result() for ClusterFuture ... done
  [20:24:52.479] result() for ClusterFuture ...
  [20:24:52.479] - result already collected: FutureResult
  [20:24:52.480] result() for ClusterFuture ... done
  [20:24:52.480] - relayed: [n=2] TRUE, TRUE
  [20:24:52.480] - queued futures: [n=2] TRUE, TRUE
  [20:24:52.480] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [20:24:52.481]  length: 0 (resolved future 2)
  [20:24:52.481] Relaying remaining futures
  [20:24:52.481] signalConditionsASAP(NULL, pos=0) ...
  [20:24:52.481] - nx: 2
  [20:24:52.482] - relay: TRUE
  [20:24:52.482] - stdout: TRUE
  [20:24:52.482] - signal: TRUE
  [20:24:52.482] - resignal: FALSE
  [20:24:52.483] - force: FALSE
  [20:24:52.483] - relayed: [n=2] TRUE, TRUE
  [20:24:52.483] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:24:52.484] - relayed: [n=2] TRUE, TRUE
  [20:24:52.484] - queued futures: [n=2] TRUE, TRUE
  [20:24:52.484] signalConditionsASAP(NULL, pos=0) ... done
  [20:24:52.484] resolve() on list ... DONE
  [20:24:52.484] - collecting values of futures
  [20:24:52.485] result() for ClusterFuture ...
  [20:24:52.485] - result already collected: FutureResult
  [20:24:52.485] result() for ClusterFuture ... done
  [20:24:52.485] result() for ClusterFuture ...
  [20:24:52.486] - result already collected: FutureResult
  [20:24:52.486] result() for ClusterFuture ... done
  [20:24:52.486] result() for ClusterFuture ...
  [20:24:52.487] - result already collected: FutureResult
  [20:24:52.487] result() for ClusterFuture ... done
  [20:24:52.487] result() for ClusterFuture ...
  [20:24:52.487] - result already collected: FutureResult
  [20:24:52.487] result() for ClusterFuture ... done
  [20:24:52.488] - accumulating results
  [20:24:52.500] - processing errors (handler = 'stop')
  [20:24:52.500] - extracting results
  [20:24:52.500] doFuture() ... DONE
  - plan(list('multisession', 'sequential')) ... DONE
  - plan(list('multisession', 'multicore')) ...
  [20:24:52.501] plan(): Setting new future strategy stack:
  [20:24:52.501] List of future strategies:
  [20:24:52.501] 1. multisession:
  [20:24:52.501]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:52.501]    - tweaked: FALSE
  [20:24:52.501]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:52.501] 2. multicore:
  [20:24:52.501]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:24:52.501]    - tweaked: FALSE
  [20:24:52.501]    - call: plan(list(a = strategy1, b = strategy2))
  [20:24:52.518] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:24:52.519] multisession:
  [20:24:52.519] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:24:52.519] - tweaked: FALSE
  [20:24:52.519] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 30943
  [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/Rtmp1AMrfv/future.parent=2402.9623599ff24.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623599ff24.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=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623599ff24.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=30943 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 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/Rtmp1AMrfv/future.parent=2402.96232af8847.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96232af8847.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96232af8847.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=30943 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [20:25:14.744] getGlobalsAndPackages() ...
  [20:25:14.744] Not searching for globals
  [20:25:14.744] - globals: [0] <none>
  [20:25:14.745] getGlobalsAndPackages() ... DONE
  [20:25:14.748] Packages needed by the future expression (n = 0): <none>
  [20:25:14.748] Packages needed by future strategies (n = 1): 'future'
  [20:25:14.765] {
  [20:25:14.765]     {
  [20:25:14.765]         ...future.startTime <- base::Sys.time()
  [20:25:14.765]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:14.765]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:14.765]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:14.765]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:14.765]             future.resolve.recursive = NULL, width = 80L)
  [20:25:14.765]         {
  [20:25:14.765]             {
  [20:25:14.765]                 {
  [20:25:14.765]                   {
  [20:25:14.765]                     has_future <- base::requireNamespace("future", 
  [20:25:14.765]                       quietly = TRUE)
  [20:25:14.765]                     version <- if (has_future) 
  [20:25:14.765]                       utils::packageVersion("future")
  [20:25:14.765]                     else NULL
  [20:25:14.765]                     if (!has_future || version < "1.8.0") {
  [20:25:14.765]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:14.765]                         "", base::R.version$version.string), 
  [20:25:14.765]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:14.765]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:14.765]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:14.765]                           "release", "version")], collapse = " "), 
  [20:25:14.765]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:14.765]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:14.765]                         info)
  [20:25:14.765]                       info <- base::paste(info, collapse = "; ")
  [20:25:14.765]                       if (!has_future) {
  [20:25:14.765]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:14.765]                           info)
  [20:25:14.765]                       }
  [20:25:14.765]                       else {
  [20:25:14.765]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:14.765]                           info, version)
  [20:25:14.765]                       }
  [20:25:14.765]                       base::stop(msg)
  [20:25:14.765]                     }
  [20:25:14.765]                   }
  [20:25:14.765]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:14.765]                   base::options(mc.cores = 1L)
  [20:25:14.765]                 }
  [20:25:14.765]                 base::local({
  [20:25:14.765]                   for (pkg in "future") {
  [20:25:14.765]                     base::loadNamespace(pkg)
  [20:25:14.765]                     base::library(pkg, character.only = TRUE)
  [20:25:14.765]                   }
  [20:25:14.765]                 })
  [20:25:14.765]             }
  [20:25:14.765]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:14.765]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:14.765]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:14.765]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:14.765]             {
  [20:25:14.765]                 if (substitute) 
  [20:25:14.765]                   expr <- substitute(expr)
  [20:25:14.765]                 if (is.function(workers)) 
  [20:25:14.765]                   workers <- workers()
  [20:25:14.765]                 workers <- as.integer(workers)
  [20:25:14.765]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:14.765]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:14.765]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:14.765]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:14.765]                     local = TRUE, label = label, ...))
  [20:25:14.765]                 }
  [20:25:14.765]                 oopts <- options(mc.cores = workers)
  [20:25:14.765]                 on.exit(options(oopts))
  [20:25:14.765]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:14.765]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:14.765]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:14.765]                   label = label, ...)
  [20:25:14.765]                 if (!future$lazy) 
  [20:25:14.765]                   future <- run(future)
  [20:25:14.765]                 invisible(future)
  [20:25:14.765]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:14.765]         }
  [20:25:14.765]     }
  [20:25:14.765]     if (base::is.na(TRUE)) {
  [20:25:14.765]     }
  [20:25:14.765]     else {
  [20:25:14.765]         if (TRUE) {
  [20:25:14.765]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:14.765]                 open = "w")
  [20:25:14.765]         }
  [20:25:14.765]         else {
  [20:25:14.765]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:14.765]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:14.765]         }
  [20:25:14.765]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:14.765]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:14.765]             base::sink(type = "output", split = FALSE)
  [20:25:14.765]             base::close(...future.stdout)
  [20:25:14.765]         }, add = TRUE)
  [20:25:14.765]     }
  [20:25:14.765]     ...future.frame <- base::sys.nframe()
  [20:25:14.765]     ...future.conditions <- base::list()
  [20:25:14.765]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:14.765]     ...future.result <- base::tryCatch({
  [20:25:14.765]         base::withCallingHandlers({
  [20:25:14.765]             ...future.value <- base::withVisible(base::local({
  [20:25:14.765]                 ...future.sendCondition <- local({
  [20:25:14.765]                   sendCondition <- NULL
  [20:25:14.765]                   function(frame = 1L) {
  [20:25:14.765]                     if (is.function(sendCondition)) 
  [20:25:14.765]                       return(sendCondition)
  [20:25:14.765]                     ns <- getNamespace("parallel")
  [20:25:14.765]                     if (exists("sendData", mode = "function", 
  [20:25:14.765]                       envir = ns)) {
  [20:25:14.765]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:14.765]                         envir = ns)
  [20:25:14.765]                       envir <- sys.frame(frame)
  [20:25:14.765]                       master <- NULL
  [20:25:14.765]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:14.765]                         !identical(envir, emptyenv())) {
  [20:25:14.765]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:14.765]                           inherits = FALSE)) {
  [20:25:14.765]                           master <- get("master", mode = "list", 
  [20:25:14.765]                             envir = envir, inherits = FALSE)
  [20:25:14.765]                           if (inherits(master, "SOCKnode")) {
  [20:25:14.765]                             sendCondition <<- function(cond) {
  [20:25:14.765]                               data <- list(type = "VALUE", value = cond, 
  [20:25:14.765]                                 success = TRUE)
  [20:25:14.765]                               parallel_sendData(master, data)
  [20:25:14.765]                             }
  [20:25:14.765]                             return(sendCondition)
  [20:25:14.765]                           }
  [20:25:14.765]                         }
  [20:25:14.765]                         frame <- frame + 1L
  [20:25:14.765]                         envir <- sys.frame(frame)
  [20:25:14.765]                       }
  [20:25:14.765]                     }
  [20:25:14.765]                     sendCondition <<- function(cond) NULL
  [20:25:14.765]                   }
  [20:25:14.765]                 })
  [20:25:14.765]                 withCallingHandlers({
  [20:25:14.765]                   NA
  [20:25:14.765]                 }, immediateCondition = function(cond) {
  [20:25:14.765]                   sendCondition <- ...future.sendCondition()
  [20:25:14.765]                   sendCondition(cond)
  [20:25:14.765]                   muffleCondition <- function (cond) 
  [20:25:14.765]                   {
  [20:25:14.765]                     inherits <- base::inherits
  [20:25:14.765]                     invokeRestart <- base::invokeRestart
  [20:25:14.765]                     muffled <- FALSE
  [20:25:14.765]                     if (inherits(cond, "message")) {
  [20:25:14.765]                       invokeRestart("muffleMessage")
  [20:25:14.765]                       muffled <- TRUE
  [20:25:14.765]                     }
  [20:25:14.765]                     else if (inherits(cond, "warning")) {
  [20:25:14.765]                       invokeRestart("muffleWarning")
  [20:25:14.765]                       muffled <- TRUE
  [20:25:14.765]                     }
  [20:25:14.765]                     else if (inherits(cond, "condition")) {
  [20:25:14.765]                       computeRestarts <- base::computeRestarts
  [20:25:14.765]                       grepl <- base::grepl
  [20:25:14.765]                       is.null <- base::is.null
  [20:25:14.765]                       restarts <- computeRestarts(cond)
  [20:25:14.765]                       for (restart in restarts) {
  [20:25:14.765]                         name <- restart$name
  [20:25:14.765]                         if (is.null(name)) 
  [20:25:14.765]                           next
  [20:25:14.765]                         if (!grepl("^muffle", name)) 
  [20:25:14.765]                           next
  [20:25:14.765]                         invokeRestart(restart)
  [20:25:14.765]                         muffled <- TRUE
  [20:25:14.765]                         break
  [20:25:14.765]                       }
  [20:25:14.765]                     }
  [20:25:14.765]                     invisible(muffled)
  [20:25:14.765]                   }
  [20:25:14.765]                   muffleCondition(cond)
  [20:25:14.765]                 })
  [20:25:14.765]             }))
  [20:25:14.765]             future::FutureResult(value = ...future.value$value, 
  [20:25:14.765]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:14.765]                   ...future.rng), started = ...future.startTime, 
  [20:25:14.765]                 version = "1.8")
  [20:25:14.765]         }, condition = base::local({
  [20:25:14.765]             c <- base::c
  [20:25:14.765]             inherits <- base::inherits
  [20:25:14.765]             invokeRestart <- base::invokeRestart
  [20:25:14.765]             length <- base::length
  [20:25:14.765]             list <- base::list
  [20:25:14.765]             seq.int <- base::seq.int
  [20:25:14.765]             signalCondition <- base::signalCondition
  [20:25:14.765]             sys.calls <- base::sys.calls
  [20:25:14.765]             Sys.time <- base::Sys.time
  [20:25:14.765]             `[[` <- base::`[[`
  [20:25:14.765]             `+` <- base::`+`
  [20:25:14.765]             `<<-` <- base::`<<-`
  [20:25:14.765]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:14.765]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:14.765]                   3L)]
  [20:25:14.765]             }
  [20:25:14.765]             function(cond) {
  [20:25:14.765]                 if (inherits(cond, "error")) {
  [20:25:14.765]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:14.765]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:14.765]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:14.765]                   signalCondition(cond)
  [20:25:14.765]                 }
  [20:25:14.765]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:14.765]                 ))) {
  [20:25:14.765]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:14.765]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:14.765]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:14.765]                   if (!signal) {
  [20:25:14.765]                     muffleCondition <- function (cond) 
  [20:25:14.765]                     {
  [20:25:14.765]                       inherits <- base::inherits
  [20:25:14.765]                       invokeRestart <- base::invokeRestart
  [20:25:14.765]                       muffled <- FALSE
  [20:25:14.765]                       if (inherits(cond, "message")) {
  [20:25:14.765]                         invokeRestart("muffleMessage")
  [20:25:14.765]                         muffled <- TRUE
  [20:25:14.765]                       }
  [20:25:14.765]                       else if (inherits(cond, "warning")) {
  [20:25:14.765]                         invokeRestart("muffleWarning")
  [20:25:14.765]                         muffled <- TRUE
  [20:25:14.765]                       }
  [20:25:14.765]                       else if (inherits(cond, "condition")) {
  [20:25:14.765]                         computeRestarts <- base::computeRestarts
  [20:25:14.765]                         grepl <- base::grepl
  [20:25:14.765]                         is.null <- base::is.null
  [20:25:14.765]                         restarts <- computeRestarts(cond)
  [20:25:14.765]                         for (restart in restarts) {
  [20:25:14.765]                           name <- restart$name
  [20:25:14.765]                           if (is.null(name)) 
  [20:25:14.765]                             next
  [20:25:14.765]                           if (!grepl("^muffle", name)) 
  [20:25:14.765]                             next
  [20:25:14.765]                           invokeRestart(restart)
  [20:25:14.765]                           muffled <- TRUE
  [20:25:14.765]                           break
  [20:25:14.765]                         }
  [20:25:14.765]                       }
  [20:25:14.765]                       invisible(muffled)
  [20:25:14.765]                     }
  [20:25:14.765]                     muffleCondition(cond)
  [20:25:14.765]                   }
  [20:25:14.765]                 }
  [20:25:14.765]             }
  [20:25:14.765]         }))
  [20:25:14.765]     }, error = function(ex) {
  [20:25:14.765]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:14.765]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:14.765]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:14.765]     }, finally = {
  [20:25:14.765]         {
  [20:25:14.765]             {
  [20:25:14.765]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:14.765]             }
  [20:25:14.765]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:14.765]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:14.765]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:14.765]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:14.765]                 ...) 
  [20:25:14.765]             {
  [20:25:14.765]                 if (substitute) 
  [20:25:14.765]                   expr <- substitute(expr)
  [20:25:14.765]                 if (is.function(workers)) 
  [20:25:14.765]                   workers <- workers()
  [20:25:14.765]                 workers <- as.integer(workers)
  [20:25:14.765]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:14.765]                   workers >= 1)
  [20:25:14.765]                 if (workers == 1L) {
  [20:25:14.765]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:14.765]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:14.765]                     local = TRUE, label = label, ...))
  [20:25:14.765]                 }
  [20:25:14.765]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:14.765]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:14.765]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:14.765]                   globals = globals, persistent = persistent, 
  [20:25:14.765]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:14.765]                   label = label, ...)
  [20:25:14.765]                 if (!future$lazy) 
  [20:25:14.765]                   future <- run(future)
  [20:25:14.765]                 invisible(future)
  [20:25:14.765]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:14.765]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:14.765]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:14.765]             {
  [20:25:14.765]                 if (substitute) 
  [20:25:14.765]                   expr <- substitute(expr)
  [20:25:14.765]                 if (is.function(workers)) 
  [20:25:14.765]                   workers <- workers()
  [20:25:14.765]                 workers <- as.integer(workers)
  [20:25:14.765]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:14.765]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:14.765]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:14.765]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:14.765]                     local = TRUE, label = label, ...))
  [20:25:14.765]                 }
  [20:25:14.765]                 oopts <- options(mc.cores = workers)
  [20:25:14.765]                 on.exit(options(oopts))
  [20:25:14.765]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:14.765]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:14.765]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:14.765]                   label = label, ...)
  [20:25:14.765]                 if (!future$lazy) 
  [20:25:14.765]                   future <- run(future)
  [20:25:14.765]                 invisible(future)
  [20:25:14.765]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:14.765]         }
  [20:25:14.765]         base::options(...future.oldOptions)
  [20:25:14.765]     })
  [20:25:14.765]     Sys.time
  [20:25:14.765]     if (base::is.na(TRUE)) {
  [20:25:14.765]     }
  [20:25:14.765]     else {
  [20:25:14.765]         base::sink(type = "output", split = FALSE)
  [20:25:14.765]         if (TRUE) {
  [20:25:14.765]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:14.765]         }
  [20:25:14.765]         else {
  [20:25:14.765]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:14.765]         }
  [20:25:14.765]         base::close(...future.stdout)
  [20:25:14.765]         ...future.stdout <- NULL
  [20:25:14.765]     }
  [20:25:14.765]     ...future.result$conditions <- ...future.conditions
  [20:25:14.765]     ...future.result
  [20:25:14.765] }
  [20:25:14.787] MultisessionFuture started
  [20:25:14.788] result() for ClusterFuture ...
  [20:25:14.788] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:14.788] - Validating connection of MultisessionFuture
  [20:25:15.116] - received message: FutureResult
  [20:25:15.116] - Received FutureResult
  [20:25:15.116] - Erased future from FutureRegistry
  [20:25:15.117] result() for ClusterFuture ...
  [20:25:15.117] - result already collected: FutureResult
  [20:25:15.117] result() for ClusterFuture ... done
  [20:25:15.118] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:15.118] result() for ClusterFuture ... done
  [20:25:15.118] result() for ClusterFuture ...
  [20:25:15.118] - result already collected: FutureResult
  [20:25:15.119] result() for ClusterFuture ... done
  [20:25:15.119] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:25:15.120] plan(): nbrOfWorkers() = 2
  [20:25:15.121] doFuture() ...
  [20:25:15.124] - dummy globals (as locals): [2] 'a', 'b'
  [20:25:15.125] - R expression:
  [20:25:15.125] {
  [20:25:15.125]     doFuture::registerDoFuture()
  [20:25:15.125]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:15.125]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:15.125]         {
  [20:25:15.125]             a <- NULL
  [20:25:15.125]             b <- NULL
  [20:25:15.125]         }
  [20:25:15.125]         ...future.env <- environment()
  [20:25:15.125]         local({
  [20:25:15.125]             for (name in names(...future.x_jj)) {
  [20:25:15.125]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:25:15.125]                   inherits = FALSE)
  [20:25:15.125]             }
  [20:25:15.125]         })
  [20:25:15.125]         tryCatch({
  [20:25:15.125]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:15.125]                 plan = future::plan("next"))
  [20:25:15.125]         }, error = identity)
  [20:25:15.125]     })
  [20:25:15.125] }
  [20:25:15.126] - identifying globals and packages ...
  [20:25:15.127] getGlobalsAndPackages() ...
  [20:25:15.127] Searching for globals...
  [20:25:15.162] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:25:15.162] Searching for globals ... DONE
  [20:25:15.163] Resolving globals: FALSE
  [20:25:15.164] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:25:15.164] - globals: [1] '...future.x_ii'
  [20:25:15.165] 
  [20:25:15.165] getGlobalsAndPackages() ... DONE
  [20:25:15.165] List of 1
  [20:25:15.165]  $ ...future.x_ii: NULL
  [20:25:15.165]  - attr(*, "where")=List of 1
  [20:25:15.165]   ..$ ...future.x_ii:<environment: 0x55bc21fbc498> 
  [20:25:15.165]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:25:15.165]  - attr(*, "resolved")= logi FALSE
  [20:25:15.165]  - attr(*, "total_size")= num 0
  [20:25:15.171]   - R expression:
  [20:25:15.172] {
  [20:25:15.172]     doFuture::registerDoFuture()
  [20:25:15.172]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:15.172]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:15.172]         {
  [20:25:15.172]             a <- NULL
  [20:25:15.172]             b <- NULL
  [20:25:15.172]         }
  [20:25:15.172]         ...future.env <- environment()
  [20:25:15.172]         local({
  [20:25:15.172]             for (name in names(...future.x_jj)) {
  [20:25:15.172]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:25:15.172]                   inherits = FALSE)
  [20:25:15.172]             }
  [20:25:15.172]         })
  [20:25:15.172]         tryCatch({
  [20:25:15.172]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:15.172]                 plan = future::plan("next"))
  [20:25:15.172]         }, error = identity)
  [20:25:15.172]     })
  [20:25:15.172] }
  [20:25:15.172]   - globals: [1] '...future.x_ii'
  [20:25:15.173] List of 1
  [20:25:15.173]  $ ...future.x_ii: NULL
  [20:25:15.173]  - attr(*, "where")=List of 1
  [20:25:15.173]   ..$ ...future.x_ii:<environment: 0x55bc21fbc498> 
  [20:25:15.173]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:25:15.173]  - attr(*, "resolved")= logi FALSE
  [20:25:15.173]  - attr(*, "total_size")= num 0
  [20:25:15.194]   - packages: [1] 'doFuture'
  [20:25:15.194] - identifying globals and packages ... DONE
  [20:25:15.195] Number of chunks: 2
  [20:25:15.196] Number of futures (= number of chunks): 2
  [20:25:15.196] Launching 2 futures (chunks) ...
  [20:25:15.197] Chunk #1 of 2 ...
  [20:25:15.197]  - Finding globals in 'args_list' chunk #1 ...
  [20:25:15.197] getGlobalsAndPackages() ...
  [20:25:15.197] Searching for globals...
  [20:25:15.198] 
  [20:25:15.198] Searching for globals ... DONE
  [20:25:15.199] - globals: [0] <none>
  [20:25:15.199] getGlobalsAndPackages() ... DONE
  [20:25:15.199] 
  [20:25:15.199] 
  [20:25:15.200]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:25:15.208] getGlobalsAndPackages() ...
  [20:25:15.209] - globals passed as-is: [1] '...future.x_ii'
  [20:25:15.209] Resolving globals: FALSE
  [20:25:15.223] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:25:15.223] - globals: [1] '...future.x_ii'
  [20:25:15.223] 
  [20:25:15.224] getGlobalsAndPackages() ... DONE
  [20:25:15.227] Packages needed by the future expression (n = 1): 'doFuture'
  [20:25:15.227] Packages needed by future strategies (n = 1): 'future'
  [20:25:15.232] {
  [20:25:15.232]     {
  [20:25:15.232]         ...future.startTime <- base::Sys.time()
  [20:25:15.232]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:15.232]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:15.232]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:15.232]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:15.232]             future.resolve.recursive = NULL, width = 80L)
  [20:25:15.232]         {
  [20:25:15.232]             {
  [20:25:15.232]                 {
  [20:25:15.232]                   {
  [20:25:15.232]                     has_future <- base::requireNamespace("future", 
  [20:25:15.232]                       quietly = TRUE)
  [20:25:15.232]                     version <- if (has_future) 
  [20:25:15.232]                       utils::packageVersion("future")
  [20:25:15.232]                     else NULL
  [20:25:15.232]                     if (!has_future || version < "1.8.0") {
  [20:25:15.232]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:15.232]                         "", base::R.version$version.string), 
  [20:25:15.232]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:15.232]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:15.232]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:15.232]                           "release", "version")], collapse = " "), 
  [20:25:15.232]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:15.232]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:15.232]                         info)
  [20:25:15.232]                       info <- base::paste(info, collapse = "; ")
  [20:25:15.232]                       if (!has_future) {
  [20:25:15.232]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:15.232]                           info)
  [20:25:15.232]                       }
  [20:25:15.232]                       else {
  [20:25:15.232]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:15.232]                           info, version)
  [20:25:15.232]                       }
  [20:25:15.232]                       base::stop(msg)
  [20:25:15.232]                     }
  [20:25:15.232]                   }
  [20:25:15.232]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:15.232]                   base::options(mc.cores = 1L)
  [20:25:15.232]                 }
  [20:25:15.232]                 base::local({
  [20:25:15.232]                   for (pkg in c("doFuture", "future")) {
  [20:25:15.232]                     base::loadNamespace(pkg)
  [20:25:15.232]                     base::library(pkg, character.only = TRUE)
  [20:25:15.232]                   }
  [20:25:15.232]                 })
  [20:25:15.232]             }
  [20:25:15.232]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:15.232]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:15.232]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:15.232]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:15.232]             {
  [20:25:15.232]                 if (substitute) 
  [20:25:15.232]                   expr <- substitute(expr)
  [20:25:15.232]                 if (is.function(workers)) 
  [20:25:15.232]                   workers <- workers()
  [20:25:15.232]                 workers <- as.integer(workers)
  [20:25:15.232]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:15.232]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:15.232]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.232]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:15.232]                     local = TRUE, label = label, ...))
  [20:25:15.232]                 }
  [20:25:15.232]                 oopts <- options(mc.cores = workers)
  [20:25:15.232]                 on.exit(options(oopts))
  [20:25:15.232]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:15.232]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.232]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:15.232]                   label = label, ...)
  [20:25:15.232]                 if (!future$lazy) 
  [20:25:15.232]                   future <- run(future)
  [20:25:15.232]                 invisible(future)
  [20:25:15.232]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:15.232]         }
  [20:25:15.232]     }
  [20:25:15.232]     if (base::is.na(TRUE)) {
  [20:25:15.232]     }
  [20:25:15.232]     else {
  [20:25:15.232]         if (TRUE) {
  [20:25:15.232]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:15.232]                 open = "w")
  [20:25:15.232]         }
  [20:25:15.232]         else {
  [20:25:15.232]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:15.232]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:15.232]         }
  [20:25:15.232]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:15.232]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:15.232]             base::sink(type = "output", split = FALSE)
  [20:25:15.232]             base::close(...future.stdout)
  [20:25:15.232]         }, add = TRUE)
  [20:25:15.232]     }
  [20:25:15.232]     ...future.frame <- base::sys.nframe()
  [20:25:15.232]     ...future.conditions <- base::list()
  [20:25:15.232]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:15.232]     ...future.result <- base::tryCatch({
  [20:25:15.232]         base::withCallingHandlers({
  [20:25:15.232]             ...future.value <- base::withVisible(base::local({
  [20:25:15.232]                 ...future.sendCondition <- local({
  [20:25:15.232]                   sendCondition <- NULL
  [20:25:15.232]                   function(frame = 1L) {
  [20:25:15.232]                     if (is.function(sendCondition)) 
  [20:25:15.232]                       return(sendCondition)
  [20:25:15.232]                     ns <- getNamespace("parallel")
  [20:25:15.232]                     if (exists("sendData", mode = "function", 
  [20:25:15.232]                       envir = ns)) {
  [20:25:15.232]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:15.232]                         envir = ns)
  [20:25:15.232]                       envir <- sys.frame(frame)
  [20:25:15.232]                       master <- NULL
  [20:25:15.232]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:15.232]                         !identical(envir, emptyenv())) {
  [20:25:15.232]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:15.232]                           inherits = FALSE)) {
  [20:25:15.232]                           master <- get("master", mode = "list", 
  [20:25:15.232]                             envir = envir, inherits = FALSE)
  [20:25:15.232]                           if (inherits(master, "SOCKnode")) {
  [20:25:15.232]                             sendCondition <<- function(cond) {
  [20:25:15.232]                               data <- list(type = "VALUE", value = cond, 
  [20:25:15.232]                                 success = TRUE)
  [20:25:15.232]                               parallel_sendData(master, data)
  [20:25:15.232]                             }
  [20:25:15.232]                             return(sendCondition)
  [20:25:15.232]                           }
  [20:25:15.232]                         }
  [20:25:15.232]                         frame <- frame + 1L
  [20:25:15.232]                         envir <- sys.frame(frame)
  [20:25:15.232]                       }
  [20:25:15.232]                     }
  [20:25:15.232]                     sendCondition <<- function(cond) NULL
  [20:25:15.232]                   }
  [20:25:15.232]                 })
  [20:25:15.232]                 withCallingHandlers({
  [20:25:15.232]                   {
  [20:25:15.232]                     doFuture::registerDoFuture()
  [20:25:15.232]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:15.232]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:15.232]                       {
  [20:25:15.232]                         a <- NULL
  [20:25:15.232]                         b <- NULL
  [20:25:15.232]                       }
  [20:25:15.232]                       ...future.env <- environment()
  [20:25:15.232]                       local({
  [20:25:15.232]                         for (name in names(...future.x_jj)) {
  [20:25:15.232]                           assign(name, ...future.x_jj[[name]], 
  [20:25:15.232]                             envir = ...future.env, inherits = FALSE)
  [20:25:15.232]                         }
  [20:25:15.232]                       })
  [20:25:15.232]                       tryCatch({
  [20:25:15.232]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:15.232]                           plan = future::plan("next"))
  [20:25:15.232]                       }, error = identity)
  [20:25:15.232]                     })
  [20:25:15.232]                   }
  [20:25:15.232]                 }, immediateCondition = function(cond) {
  [20:25:15.232]                   sendCondition <- ...future.sendCondition()
  [20:25:15.232]                   sendCondition(cond)
  [20:25:15.232]                   muffleCondition <- function (cond) 
  [20:25:15.232]                   {
  [20:25:15.232]                     inherits <- base::inherits
  [20:25:15.232]                     invokeRestart <- base::invokeRestart
  [20:25:15.232]                     muffled <- FALSE
  [20:25:15.232]                     if (inherits(cond, "message")) {
  [20:25:15.232]                       invokeRestart("muffleMessage")
  [20:25:15.232]                       muffled <- TRUE
  [20:25:15.232]                     }
  [20:25:15.232]                     else if (inherits(cond, "warning")) {
  [20:25:15.232]                       invokeRestart("muffleWarning")
  [20:25:15.232]                       muffled <- TRUE
  [20:25:15.232]                     }
  [20:25:15.232]                     else if (inherits(cond, "condition")) {
  [20:25:15.232]                       computeRestarts <- base::computeRestarts
  [20:25:15.232]                       grepl <- base::grepl
  [20:25:15.232]                       is.null <- base::is.null
  [20:25:15.232]                       restarts <- computeRestarts(cond)
  [20:25:15.232]                       for (restart in restarts) {
  [20:25:15.232]                         name <- restart$name
  [20:25:15.232]                         if (is.null(name)) 
  [20:25:15.232]                           next
  [20:25:15.232]                         if (!grepl("^muffle", name)) 
  [20:25:15.232]                           next
  [20:25:15.232]                         invokeRestart(restart)
  [20:25:15.232]                         muffled <- TRUE
  [20:25:15.232]                         break
  [20:25:15.232]                       }
  [20:25:15.232]                     }
  [20:25:15.232]                     invisible(muffled)
  [20:25:15.232]                   }
  [20:25:15.232]                   muffleCondition(cond)
  [20:25:15.232]                 })
  [20:25:15.232]             }))
  [20:25:15.232]             future::FutureResult(value = ...future.value$value, 
  [20:25:15.232]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:15.232]                   ...future.rng), started = ...future.startTime, 
  [20:25:15.232]                 version = "1.8")
  [20:25:15.232]         }, condition = base::local({
  [20:25:15.232]             c <- base::c
  [20:25:15.232]             inherits <- base::inherits
  [20:25:15.232]             invokeRestart <- base::invokeRestart
  [20:25:15.232]             length <- base::length
  [20:25:15.232]             list <- base::list
  [20:25:15.232]             seq.int <- base::seq.int
  [20:25:15.232]             signalCondition <- base::signalCondition
  [20:25:15.232]             sys.calls <- base::sys.calls
  [20:25:15.232]             Sys.time <- base::Sys.time
  [20:25:15.232]             `[[` <- base::`[[`
  [20:25:15.232]             `+` <- base::`+`
  [20:25:15.232]             `<<-` <- base::`<<-`
  [20:25:15.232]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:15.232]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:15.232]                   3L)]
  [20:25:15.232]             }
  [20:25:15.232]             function(cond) {
  [20:25:15.232]                 if (inherits(cond, "error")) {
  [20:25:15.232]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:15.232]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:15.232]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:15.232]                   signalCondition(cond)
  [20:25:15.232]                 }
  [20:25:15.232]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:15.232]                 ))) {
  [20:25:15.232]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:15.232]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:15.232]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:15.232]                   if (!signal) {
  [20:25:15.232]                     muffleCondition <- function (cond) 
  [20:25:15.232]                     {
  [20:25:15.232]                       inherits <- base::inherits
  [20:25:15.232]                       invokeRestart <- base::invokeRestart
  [20:25:15.232]                       muffled <- FALSE
  [20:25:15.232]                       if (inherits(cond, "message")) {
  [20:25:15.232]                         invokeRestart("muffleMessage")
  [20:25:15.232]                         muffled <- TRUE
  [20:25:15.232]                       }
  [20:25:15.232]                       else if (inherits(cond, "warning")) {
  [20:25:15.232]                         invokeRestart("muffleWarning")
  [20:25:15.232]                         muffled <- TRUE
  [20:25:15.232]                       }
  [20:25:15.232]                       else if (inherits(cond, "condition")) {
  [20:25:15.232]                         computeRestarts <- base::computeRestarts
  [20:25:15.232]                         grepl <- base::grepl
  [20:25:15.232]                         is.null <- base::is.null
  [20:25:15.232]                         restarts <- computeRestarts(cond)
  [20:25:15.232]                         for (restart in restarts) {
  [20:25:15.232]                           name <- restart$name
  [20:25:15.232]                           if (is.null(name)) 
  [20:25:15.232]                             next
  [20:25:15.232]                           if (!grepl("^muffle", name)) 
  [20:25:15.232]                             next
  [20:25:15.232]                           invokeRestart(restart)
  [20:25:15.232]                           muffled <- TRUE
  [20:25:15.232]                           break
  [20:25:15.232]                         }
  [20:25:15.232]                       }
  [20:25:15.232]                       invisible(muffled)
  [20:25:15.232]                     }
  [20:25:15.232]                     muffleCondition(cond)
  [20:25:15.232]                   }
  [20:25:15.232]                 }
  [20:25:15.232]             }
  [20:25:15.232]         }))
  [20:25:15.232]     }, error = function(ex) {
  [20:25:15.232]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:15.232]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:15.232]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:15.232]     }, finally = {
  [20:25:15.232]         {
  [20:25:15.232]             {
  [20:25:15.232]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:15.232]             }
  [20:25:15.232]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:15.232]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:15.232]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:15.232]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:15.232]                 ...) 
  [20:25:15.232]             {
  [20:25:15.232]                 if (substitute) 
  [20:25:15.232]                   expr <- substitute(expr)
  [20:25:15.232]                 if (is.function(workers)) 
  [20:25:15.232]                   workers <- workers()
  [20:25:15.232]                 workers <- as.integer(workers)
  [20:25:15.232]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:15.232]                   workers >= 1)
  [20:25:15.232]                 if (workers == 1L) {
  [20:25:15.232]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.232]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:15.232]                     local = TRUE, label = label, ...))
  [20:25:15.232]                 }
  [20:25:15.232]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:15.232]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:15.232]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.232]                   globals = globals, persistent = persistent, 
  [20:25:15.232]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:15.232]                   label = label, ...)
  [20:25:15.232]                 if (!future$lazy) 
  [20:25:15.232]                   future <- run(future)
  [20:25:15.232]                 invisible(future)
  [20:25:15.232]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:15.232]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:15.232]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:15.232]             {
  [20:25:15.232]                 if (substitute) 
  [20:25:15.232]                   expr <- substitute(expr)
  [20:25:15.232]                 if (is.function(workers)) 
  [20:25:15.232]                   workers <- workers()
  [20:25:15.232]                 workers <- as.integer(workers)
  [20:25:15.232]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:15.232]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:15.232]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.232]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:15.232]                     local = TRUE, label = label, ...))
  [20:25:15.232]                 }
  [20:25:15.232]                 oopts <- options(mc.cores = workers)
  [20:25:15.232]                 on.exit(options(oopts))
  [20:25:15.232]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:15.232]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.232]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:15.232]                   label = label, ...)
  [20:25:15.232]                 if (!future$lazy) 
  [20:25:15.232]                   future <- run(future)
  [20:25:15.232]                 invisible(future)
  [20:25:15.232]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:15.232]         }
  [20:25:15.232]         base::options(...future.oldOptions)
  [20:25:15.232]     })
  [20:25:15.232]     Sys.time
  [20:25:15.232]     if (base::is.na(TRUE)) {
  [20:25:15.232]     }
  [20:25:15.232]     else {
  [20:25:15.232]         base::sink(type = "output", split = FALSE)
  [20:25:15.232]         if (TRUE) {
  [20:25:15.232]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:15.232]         }
  [20:25:15.232]         else {
  [20:25:15.232]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:15.232]         }
  [20:25:15.232]         base::close(...future.stdout)
  [20:25:15.232]         ...future.stdout <- NULL
  [20:25:15.232]     }
  [20:25:15.232]     ...future.result$conditions <- ...future.conditions
  [20:25:15.232]     ...future.result
  [20:25:15.232] }
  [20:25:15.246] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [20:25:15.247] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [20:25:15.248] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [20:25:15.248] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [20:25:15.250] MultisessionFuture started
  [20:25:15.250] Chunk #1 of 2 ... DONE
  [20:25:15.250] Chunk #2 of 2 ...
  [20:25:15.250]  - Finding globals in 'args_list' chunk #2 ...
  [20:25:15.251] getGlobalsAndPackages() ...
  [20:25:15.251] Searching for globals...
  [20:25:15.252] 
  [20:25:15.252] Searching for globals ... DONE
  [20:25:15.252] - globals: [0] <none>
  [20:25:15.252] getGlobalsAndPackages() ... DONE
  [20:25:15.253] 
  [20:25:15.253] 
  [20:25:15.253]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:25:15.275] getGlobalsAndPackages() ...
  [20:25:15.276] - globals passed as-is: [1] '...future.x_ii'
  [20:25:15.276] Resolving globals: FALSE
  [20:25:15.297] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:25:15.297] - globals: [1] '...future.x_ii'
  [20:25:15.298] 
  [20:25:15.298] getGlobalsAndPackages() ... DONE
  [20:25:15.301] Packages needed by the future expression (n = 1): 'doFuture'
  [20:25:15.302] Packages needed by future strategies (n = 1): 'future'
  [20:25:15.307] {
  [20:25:15.307]     {
  [20:25:15.307]         ...future.startTime <- base::Sys.time()
  [20:25:15.307]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:15.307]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:15.307]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:15.307]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:15.307]             future.resolve.recursive = NULL, width = 80L)
  [20:25:15.307]         {
  [20:25:15.307]             {
  [20:25:15.307]                 {
  [20:25:15.307]                   {
  [20:25:15.307]                     has_future <- base::requireNamespace("future", 
  [20:25:15.307]                       quietly = TRUE)
  [20:25:15.307]                     version <- if (has_future) 
  [20:25:15.307]                       utils::packageVersion("future")
  [20:25:15.307]                     else NULL
  [20:25:15.307]                     if (!has_future || version < "1.8.0") {
  [20:25:15.307]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:15.307]                         "", base::R.version$version.string), 
  [20:25:15.307]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:15.307]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:15.307]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:15.307]                           "release", "version")], collapse = " "), 
  [20:25:15.307]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:15.307]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:15.307]                         info)
  [20:25:15.307]                       info <- base::paste(info, collapse = "; ")
  [20:25:15.307]                       if (!has_future) {
  [20:25:15.307]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:15.307]                           info)
  [20:25:15.307]                       }
  [20:25:15.307]                       else {
  [20:25:15.307]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:15.307]                           info, version)
  [20:25:15.307]                       }
  [20:25:15.307]                       base::stop(msg)
  [20:25:15.307]                     }
  [20:25:15.307]                   }
  [20:25:15.307]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:15.307]                   base::options(mc.cores = 1L)
  [20:25:15.307]                 }
  [20:25:15.307]                 base::local({
  [20:25:15.307]                   for (pkg in c("doFuture", "future")) {
  [20:25:15.307]                     base::loadNamespace(pkg)
  [20:25:15.307]                     base::library(pkg, character.only = TRUE)
  [20:25:15.307]                   }
  [20:25:15.307]                 })
  [20:25:15.307]             }
  [20:25:15.307]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:15.307]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:15.307]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:15.307]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:15.307]             {
  [20:25:15.307]                 if (substitute) 
  [20:25:15.307]                   expr <- substitute(expr)
  [20:25:15.307]                 if (is.function(workers)) 
  [20:25:15.307]                   workers <- workers()
  [20:25:15.307]                 workers <- as.integer(workers)
  [20:25:15.307]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:15.307]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:15.307]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.307]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:15.307]                     local = TRUE, label = label, ...))
  [20:25:15.307]                 }
  [20:25:15.307]                 oopts <- options(mc.cores = workers)
  [20:25:15.307]                 on.exit(options(oopts))
  [20:25:15.307]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:15.307]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.307]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:15.307]                   label = label, ...)
  [20:25:15.307]                 if (!future$lazy) 
  [20:25:15.307]                   future <- run(future)
  [20:25:15.307]                 invisible(future)
  [20:25:15.307]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:15.307]         }
  [20:25:15.307]     }
  [20:25:15.307]     if (base::is.na(TRUE)) {
  [20:25:15.307]     }
  [20:25:15.307]     else {
  [20:25:15.307]         if (TRUE) {
  [20:25:15.307]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:15.307]                 open = "w")
  [20:25:15.307]         }
  [20:25:15.307]         else {
  [20:25:15.307]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:15.307]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:15.307]         }
  [20:25:15.307]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:15.307]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:15.307]             base::sink(type = "output", split = FALSE)
  [20:25:15.307]             base::close(...future.stdout)
  [20:25:15.307]         }, add = TRUE)
  [20:25:15.307]     }
  [20:25:15.307]     ...future.frame <- base::sys.nframe()
  [20:25:15.307]     ...future.conditions <- base::list()
  [20:25:15.307]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:15.307]     ...future.result <- base::tryCatch({
  [20:25:15.307]         base::withCallingHandlers({
  [20:25:15.307]             ...future.value <- base::withVisible(base::local({
  [20:25:15.307]                 ...future.sendCondition <- local({
  [20:25:15.307]                   sendCondition <- NULL
  [20:25:15.307]                   function(frame = 1L) {
  [20:25:15.307]                     if (is.function(sendCondition)) 
  [20:25:15.307]                       return(sendCondition)
  [20:25:15.307]                     ns <- getNamespace("parallel")
  [20:25:15.307]                     if (exists("sendData", mode = "function", 
  [20:25:15.307]                       envir = ns)) {
  [20:25:15.307]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:15.307]                         envir = ns)
  [20:25:15.307]                       envir <- sys.frame(frame)
  [20:25:15.307]                       master <- NULL
  [20:25:15.307]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:15.307]                         !identical(envir, emptyenv())) {
  [20:25:15.307]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:15.307]                           inherits = FALSE)) {
  [20:25:15.307]                           master <- get("master", mode = "list", 
  [20:25:15.307]                             envir = envir, inherits = FALSE)
  [20:25:15.307]                           if (inherits(master, "SOCKnode")) {
  [20:25:15.307]                             sendCondition <<- function(cond) {
  [20:25:15.307]                               data <- list(type = "VALUE", value = cond, 
  [20:25:15.307]                                 success = TRUE)
  [20:25:15.307]                               parallel_sendData(master, data)
  [20:25:15.307]                             }
  [20:25:15.307]                             return(sendCondition)
  [20:25:15.307]                           }
  [20:25:15.307]                         }
  [20:25:15.307]                         frame <- frame + 1L
  [20:25:15.307]                         envir <- sys.frame(frame)
  [20:25:15.307]                       }
  [20:25:15.307]                     }
  [20:25:15.307]                     sendCondition <<- function(cond) NULL
  [20:25:15.307]                   }
  [20:25:15.307]                 })
  [20:25:15.307]                 withCallingHandlers({
  [20:25:15.307]                   {
  [20:25:15.307]                     doFuture::registerDoFuture()
  [20:25:15.307]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:15.307]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:15.307]                       {
  [20:25:15.307]                         a <- NULL
  [20:25:15.307]                         b <- NULL
  [20:25:15.307]                       }
  [20:25:15.307]                       ...future.env <- environment()
  [20:25:15.307]                       local({
  [20:25:15.307]                         for (name in names(...future.x_jj)) {
  [20:25:15.307]                           assign(name, ...future.x_jj[[name]], 
  [20:25:15.307]                             envir = ...future.env, inherits = FALSE)
  [20:25:15.307]                         }
  [20:25:15.307]                       })
  [20:25:15.307]                       tryCatch({
  [20:25:15.307]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:15.307]                           plan = future::plan("next"))
  [20:25:15.307]                       }, error = identity)
  [20:25:15.307]                     })
  [20:25:15.307]                   }
  [20:25:15.307]                 }, immediateCondition = function(cond) {
  [20:25:15.307]                   sendCondition <- ...future.sendCondition()
  [20:25:15.307]                   sendCondition(cond)
  [20:25:15.307]                   muffleCondition <- function (cond) 
  [20:25:15.307]                   {
  [20:25:15.307]                     inherits <- base::inherits
  [20:25:15.307]                     invokeRestart <- base::invokeRestart
  [20:25:15.307]                     muffled <- FALSE
  [20:25:15.307]                     if (inherits(cond, "message")) {
  [20:25:15.307]                       invokeRestart("muffleMessage")
  [20:25:15.307]                       muffled <- TRUE
  [20:25:15.307]                     }
  [20:25:15.307]                     else if (inherits(cond, "warning")) {
  [20:25:15.307]                       invokeRestart("muffleWarning")
  [20:25:15.307]                       muffled <- TRUE
  [20:25:15.307]                     }
  [20:25:15.307]                     else if (inherits(cond, "condition")) {
  [20:25:15.307]                       computeRestarts <- base::computeRestarts
  [20:25:15.307]                       grepl <- base::grepl
  [20:25:15.307]                       is.null <- base::is.null
  [20:25:15.307]                       restarts <- computeRestarts(cond)
  [20:25:15.307]                       for (restart in restarts) {
  [20:25:15.307]                         name <- restart$name
  [20:25:15.307]                         if (is.null(name)) 
  [20:25:15.307]                           next
  [20:25:15.307]                         if (!grepl("^muffle", name)) 
  [20:25:15.307]                           next
  [20:25:15.307]                         invokeRestart(restart)
  [20:25:15.307]                         muffled <- TRUE
  [20:25:15.307]                         break
  [20:25:15.307]                       }
  [20:25:15.307]                     }
  [20:25:15.307]                     invisible(muffled)
  [20:25:15.307]                   }
  [20:25:15.307]                   muffleCondition(cond)
  [20:25:15.307]                 })
  [20:25:15.307]             }))
  [20:25:15.307]             future::FutureResult(value = ...future.value$value, 
  [20:25:15.307]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:15.307]                   ...future.rng), started = ...future.startTime, 
  [20:25:15.307]                 version = "1.8")
  [20:25:15.307]         }, condition = base::local({
  [20:25:15.307]             c <- base::c
  [20:25:15.307]             inherits <- base::inherits
  [20:25:15.307]             invokeRestart <- base::invokeRestart
  [20:25:15.307]             length <- base::length
  [20:25:15.307]             list <- base::list
  [20:25:15.307]             seq.int <- base::seq.int
  [20:25:15.307]             signalCondition <- base::signalCondition
  [20:25:15.307]             sys.calls <- base::sys.calls
  [20:25:15.307]             Sys.time <- base::Sys.time
  [20:25:15.307]             `[[` <- base::`[[`
  [20:25:15.307]             `+` <- base::`+`
  [20:25:15.307]             `<<-` <- base::`<<-`
  [20:25:15.307]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:15.307]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:15.307]                   3L)]
  [20:25:15.307]             }
  [20:25:15.307]             function(cond) {
  [20:25:15.307]                 if (inherits(cond, "error")) {
  [20:25:15.307]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:15.307]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:15.307]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:15.307]                   signalCondition(cond)
  [20:25:15.307]                 }
  [20:25:15.307]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:15.307]                 ))) {
  [20:25:15.307]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:15.307]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:15.307]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:15.307]                   if (!signal) {
  [20:25:15.307]                     muffleCondition <- function (cond) 
  [20:25:15.307]                     {
  [20:25:15.307]                       inherits <- base::inherits
  [20:25:15.307]                       invokeRestart <- base::invokeRestart
  [20:25:15.307]                       muffled <- FALSE
  [20:25:15.307]                       if (inherits(cond, "message")) {
  [20:25:15.307]                         invokeRestart("muffleMessage")
  [20:25:15.307]                         muffled <- TRUE
  [20:25:15.307]                       }
  [20:25:15.307]                       else if (inherits(cond, "warning")) {
  [20:25:15.307]                         invokeRestart("muffleWarning")
  [20:25:15.307]                         muffled <- TRUE
  [20:25:15.307]                       }
  [20:25:15.307]                       else if (inherits(cond, "condition")) {
  [20:25:15.307]                         computeRestarts <- base::computeRestarts
  [20:25:15.307]                         grepl <- base::grepl
  [20:25:15.307]                         is.null <- base::is.null
  [20:25:15.307]                         restarts <- computeRestarts(cond)
  [20:25:15.307]                         for (restart in restarts) {
  [20:25:15.307]                           name <- restart$name
  [20:25:15.307]                           if (is.null(name)) 
  [20:25:15.307]                             next
  [20:25:15.307]                           if (!grepl("^muffle", name)) 
  [20:25:15.307]                             next
  [20:25:15.307]                           invokeRestart(restart)
  [20:25:15.307]                           muffled <- TRUE
  [20:25:15.307]                           break
  [20:25:15.307]                         }
  [20:25:15.307]                       }
  [20:25:15.307]                       invisible(muffled)
  [20:25:15.307]                     }
  [20:25:15.307]                     muffleCondition(cond)
  [20:25:15.307]                   }
  [20:25:15.307]                 }
  [20:25:15.307]             }
  [20:25:15.307]         }))
  [20:25:15.307]     }, error = function(ex) {
  [20:25:15.307]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:15.307]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:15.307]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:15.307]     }, finally = {
  [20:25:15.307]         {
  [20:25:15.307]             {
  [20:25:15.307]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:15.307]             }
  [20:25:15.307]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:15.307]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:15.307]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:15.307]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:15.307]                 ...) 
  [20:25:15.307]             {
  [20:25:15.307]                 if (substitute) 
  [20:25:15.307]                   expr <- substitute(expr)
  [20:25:15.307]                 if (is.function(workers)) 
  [20:25:15.307]                   workers <- workers()
  [20:25:15.307]                 workers <- as.integer(workers)
  [20:25:15.307]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:15.307]                   workers >= 1)
  [20:25:15.307]                 if (workers == 1L) {
  [20:25:15.307]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.307]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:15.307]                     local = TRUE, label = label, ...))
  [20:25:15.307]                 }
  [20:25:15.307]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:15.307]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:15.307]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.307]                   globals = globals, persistent = persistent, 
  [20:25:15.307]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:15.307]                   label = label, ...)
  [20:25:15.307]                 if (!future$lazy) 
  [20:25:15.307]                   future <- run(future)
  [20:25:15.307]                 invisible(future)
  [20:25:15.307]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:15.307]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [20:25:15.307]                 earlySignal = FALSE, label = NULL, ...) 
  [20:25:15.307]             {
  [20:25:15.307]                 if (substitute) 
  [20:25:15.307]                   expr <- substitute(expr)
  [20:25:15.307]                 if (is.function(workers)) 
  [20:25:15.307]                   workers <- workers()
  [20:25:15.307]                 workers <- as.integer(workers)
  [20:25:15.307]                 stop_if_not(is.finite(workers), workers >= 1L)
  [20:25:15.307]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [20:25:15.307]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:15.307]                     lazy = lazy, seed = seed, globals = globals, 
  [20:25:15.307]                     local = TRUE, label = label, ...))
  [20:25:15.307]                 }
  [20:25:15.307]                 oopts <- options(mc.cores = workers)
  [20:25:15.307]                 on.exit(options(oopts))
  [20:25:15.307]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [20:25:15.307]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:15.307]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [20:25:15.307]                   label = label, ...)
  [20:25:15.307]                 if (!future$lazy) 
  [20:25:15.307]                   future <- run(future)
  [20:25:15.307]                 invisible(future)
  [20:25:15.307]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:15.307]         }
  [20:25:15.307]         base::options(...future.oldOptions)
  [20:25:15.307]     })
  [20:25:15.307]     Sys.time
  [20:25:15.307]     if (base::is.na(TRUE)) {
  [20:25:15.307]     }
  [20:25:15.307]     else {
  [20:25:15.307]         base::sink(type = "output", split = FALSE)
  [20:25:15.307]         if (TRUE) {
  [20:25:15.307]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:15.307]         }
  [20:25:15.307]         else {
  [20:25:15.307]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:15.307]         }
  [20:25:15.307]         base::close(...future.stdout)
  [20:25:15.307]         ...future.stdout <- NULL
  [20:25:15.307]     }
  [20:25:15.307]     ...future.result$conditions <- ...future.conditions
  [20:25:15.307]     ...future.result
  [20:25:15.307] }
  [20:25:15.330] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [20:25:15.330] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [20:25:15.331] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [20:25:15.332] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [20:25:15.333] MultisessionFuture started
  [20:25:15.333] Chunk #2 of 2 ... DONE
  [20:25:15.334] Launching 2 futures (chunks) ... DONE
  [20:25:15.334] - resolving futures
  [20:25:15.334]   - gathering results & relaying conditions (except errors)
  [20:25:15.334] resolve() on list ...
  [20:25:15.335]  recursive: 0
  [20:25:15.335]  length: 2
  [20:25:15.335] 
  [20:25:15.840] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:15.840] - Validating connection of MultisessionFuture
  [20:25:15.841] - received message: FutureResult
  [20:25:15.842] - Received FutureResult
  [20:25:15.842] - Erased future from FutureRegistry
  [20:25:15.842] result() for ClusterFuture ...
  [20:25:15.843] - result already collected: FutureResult
  [20:25:15.843] result() for ClusterFuture ... done
  [20:25:15.843] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:15.843] Future #1
  [20:25:15.844] result() for ClusterFuture ...
  [20:25:15.844] - result already collected: FutureResult
  [20:25:15.844] result() for ClusterFuture ... done
  [20:25:15.845] result() for ClusterFuture ...
  [20:25:15.845] - result already collected: FutureResult
  [20:25:15.845] result() for ClusterFuture ... done
  [20:25:15.845] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [20:25:15.846] - nx: 2
  [20:25:15.846] - relay: TRUE
  [20:25:15.846] - stdout: TRUE
  [20:25:15.846] - signal: TRUE
  [20:25:15.847] - resignal: FALSE
  [20:25:15.847] - force: FALSE
  [20:25:15.847] - relayed: [n=2] FALSE, FALSE
  [20:25:15.847] - queued futures: [n=2] FALSE, FALSE
  [20:25:15.848]  - until=1
  [20:25:15.848]  - relaying element #1
  [20:25:15.848] result() for ClusterFuture ...
  [20:25:15.849] - result already collected: FutureResult
  [20:25:15.849] result() for ClusterFuture ... done
  [20:25:15.849] result() for ClusterFuture ...
  [20:25:15.849] - result already collected: FutureResult
  [20:25:15.850] result() for ClusterFuture ... done
  [20:25:15.850] result() for ClusterFuture ...
  [20:25:15.850] - result already collected: FutureResult
  [20:25:15.851] result() for ClusterFuture ... done
  [20:25:15.851] result() for ClusterFuture ...
  [20:25:15.851] - result already collected: FutureResult
  [20:25:15.852] result() for ClusterFuture ... done
  [20:25:15.852] - relayed: [n=2] TRUE, FALSE
  [20:25:15.852] - queued futures: [n=2] TRUE, FALSE
  [20:25:15.853] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [20:25:15.853]  length: 1 (resolved future 1)
  [20:25:15.879] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:15.880] - Validating connection of MultisessionFuture
  [20:25:15.918] - received message: FutureResult
  [20:25:15.919] - Received FutureResult
  [20:25:15.919] - Erased future from FutureRegistry
  [20:25:15.920] result() for ClusterFuture ...
  [20:25:15.920] - result already collected: FutureResult
  [20:25:15.920] result() for ClusterFuture ... done
  [20:25:15.920] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:15.921] Future #2
  [20:25:15.921] result() for ClusterFuture ...
  [20:25:15.921] - result already collected: FutureResult
  [20:25:15.921] result() for ClusterFuture ... done
  [20:25:15.922] result() for ClusterFuture ...
  [20:25:15.922] - result already collected: FutureResult
  [20:25:15.922] result() for ClusterFuture ... done
  [20:25:15.923] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [20:25:15.923] - nx: 2
  [20:25:15.923] - relay: TRUE
  [20:25:15.923] - stdout: TRUE
  [20:25:15.924] - signal: TRUE
  [20:25:15.924] - resignal: FALSE
  [20:25:15.924] - force: FALSE
  [20:25:15.924] - relayed: [n=2] TRUE, FALSE
  [20:25:15.925] - queued futures: [n=2] TRUE, FALSE
  [20:25:15.925]  - until=2
  [20:25:15.925]  - relaying element #2
  [20:25:15.926] result() for ClusterFuture ...
  [20:25:15.926] - result already collected: FutureResult
  [20:25:15.926] result() for ClusterFuture ... done
  [20:25:15.927] result() for ClusterFuture ...
  [20:25:15.927] - result already collected: FutureResult
  [20:25:15.927] result() for ClusterFuture ... done
  [20:25:15.928] result() for ClusterFuture ...
  [20:25:15.928] - result already collected: FutureResult
  [20:25:15.928] result() for ClusterFuture ... done
  [20:25:15.928] result() for ClusterFuture ...
  [20:25:15.929] - result already collected: FutureResult
  [20:25:15.929] result() for ClusterFuture ... done
  [20:25:15.929] - relayed: [n=2] TRUE, TRUE
  [20:25:15.929] - queued futures: [n=2] TRUE, TRUE
  [20:25:15.930] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [20:25:15.930]  length: 0 (resolved future 2)
  [20:25:15.930] Relaying remaining futures
  [20:25:15.931] signalConditionsASAP(NULL, pos=0) ...
  [20:25:15.931] - nx: 2
  [20:25:15.931] - relay: TRUE
  [20:25:15.931] - stdout: TRUE
  [20:25:15.932] - signal: TRUE
  [20:25:15.932] - resignal: FALSE
  [20:25:15.932] - force: FALSE
  [20:25:15.932] - relayed: [n=2] TRUE, TRUE
  [20:25:15.933] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:25:15.946] - relayed: [n=2] TRUE, TRUE
  [20:25:15.947] - queued futures: [n=2] TRUE, TRUE
  [20:25:15.947] signalConditionsASAP(NULL, pos=0) ... done
  [20:25:15.947] resolve() on list ... DONE
  [20:25:15.947] - collecting values of futures
  [20:25:15.948] result() for ClusterFuture ...
  [20:25:15.954] - result already collected: FutureResult
  [20:25:15.954] result() for ClusterFuture ... done
  [20:25:15.955] result() for ClusterFuture ...
  [20:25:15.955] - result already collected: FutureResult
  [20:25:15.955] result() for ClusterFuture ... done
  [20:25:15.956] result() for ClusterFuture ...
  [20:25:15.956] - result already collected: FutureResult
  [20:25:15.956] result() for ClusterFuture ... done
  [20:25:15.957] result() for ClusterFuture ...
  [20:25:15.957] - result already collected: FutureResult
  [20:25:15.957] result() for ClusterFuture ... done
  [20:25:15.958] - accumulating results
  [20:25:15.960] - processing errors (handler = 'stop')
  [20:25:15.961] - extracting results
  [20:25:15.961] doFuture() ... DONE
  - plan(list('multisession', 'multicore')) ... DONE
  - plan(list('multisession', 'multisession')) ...
  [20:25:15.978] plan(): Setting new future strategy stack:
  [20:25:15.979] List of future strategies:
  [20:25:15.979] 1. multisession:
  [20:25:15.979]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:15.979]    - tweaked: FALSE
  [20:25:15.979]    - call: plan(list(a = strategy1, b = strategy2))
  [20:25:15.979] 2. multisession:
  [20:25:15.979]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:15.979]    - tweaked: FALSE
  [20:25:15.979]    - call: plan(list(a = strategy1, b = strategy2))
  [20:25:15.981] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:25:15.981] multisession:
  [20:25:15.981] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:15.981] - tweaked: FALSE
  [20:25:15.981] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 39165
  [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/Rtmp1AMrfv/future.parent=2402.96243f41445.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96243f41445.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=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.96243f41445.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=39165 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 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/Rtmp1AMrfv/future.parent=2402.9623403220e.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623403220e.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9623403220e.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=39165 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [20:25:35.146] getGlobalsAndPackages() ...
  [20:25:35.147] Not searching for globals
  [20:25:35.162] - globals: [0] <none>
  [20:25:35.162] getGlobalsAndPackages() ... DONE
  [20:25:35.166] Packages needed by the future expression (n = 0): <none>
  [20:25:35.167] Packages needed by future strategies (n = 1): 'future'
  [20:25:35.172] {
  [20:25:35.172]     {
  [20:25:35.172]         ...future.startTime <- base::Sys.time()
  [20:25:35.172]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:35.172]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:35.172]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:35.172]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:35.172]             future.resolve.recursive = NULL, width = 80L)
  [20:25:35.172]         {
  [20:25:35.172]             {
  [20:25:35.172]                 {
  [20:25:35.172]                   {
  [20:25:35.172]                     has_future <- base::requireNamespace("future", 
  [20:25:35.172]                       quietly = TRUE)
  [20:25:35.172]                     version <- if (has_future) 
  [20:25:35.172]                       utils::packageVersion("future")
  [20:25:35.172]                     else NULL
  [20:25:35.172]                     if (!has_future || version < "1.8.0") {
  [20:25:35.172]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:35.172]                         "", base::R.version$version.string), 
  [20:25:35.172]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:35.172]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:35.172]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:35.172]                           "release", "version")], collapse = " "), 
  [20:25:35.172]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:35.172]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:35.172]                         info)
  [20:25:35.172]                       info <- base::paste(info, collapse = "; ")
  [20:25:35.172]                       if (!has_future) {
  [20:25:35.172]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:35.172]                           info)
  [20:25:35.172]                       }
  [20:25:35.172]                       else {
  [20:25:35.172]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:35.172]                           info, version)
  [20:25:35.172]                       }
  [20:25:35.172]                       base::stop(msg)
  [20:25:35.172]                     }
  [20:25:35.172]                   }
  [20:25:35.172]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:35.172]                   base::options(mc.cores = 1L)
  [20:25:35.172]                 }
  [20:25:35.172]                 base::local({
  [20:25:35.172]                   for (pkg in "future") {
  [20:25:35.172]                     base::loadNamespace(pkg)
  [20:25:35.172]                     base::library(pkg, character.only = TRUE)
  [20:25:35.172]                   }
  [20:25:35.172]                 })
  [20:25:35.172]             }
  [20:25:35.172]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:35.172]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.172]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.172]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.172]                 ...) 
  [20:25:35.172]             {
  [20:25:35.172]                 if (substitute) 
  [20:25:35.172]                   expr <- substitute(expr)
  [20:25:35.172]                 if (is.function(workers)) 
  [20:25:35.172]                   workers <- workers()
  [20:25:35.172]                 workers <- as.integer(workers)
  [20:25:35.172]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.172]                   workers >= 1)
  [20:25:35.172]                 if (workers == 1L) {
  [20:25:35.172]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.172]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.172]                     local = TRUE, label = label, ...))
  [20:25:35.172]                 }
  [20:25:35.172]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.172]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.172]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.172]                   globals = globals, persistent = persistent, 
  [20:25:35.172]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.172]                   label = label, ...)
  [20:25:35.172]                 if (!future$lazy) 
  [20:25:35.172]                   future <- run(future)
  [20:25:35.172]                 invisible(future)
  [20:25:35.172]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.172]         }
  [20:25:35.172]     }
  [20:25:35.172]     if (base::is.na(TRUE)) {
  [20:25:35.172]     }
  [20:25:35.172]     else {
  [20:25:35.172]         if (TRUE) {
  [20:25:35.172]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:35.172]                 open = "w")
  [20:25:35.172]         }
  [20:25:35.172]         else {
  [20:25:35.172]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:35.172]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:35.172]         }
  [20:25:35.172]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:35.172]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:35.172]             base::sink(type = "output", split = FALSE)
  [20:25:35.172]             base::close(...future.stdout)
  [20:25:35.172]         }, add = TRUE)
  [20:25:35.172]     }
  [20:25:35.172]     ...future.frame <- base::sys.nframe()
  [20:25:35.172]     ...future.conditions <- base::list()
  [20:25:35.172]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:35.172]     ...future.result <- base::tryCatch({
  [20:25:35.172]         base::withCallingHandlers({
  [20:25:35.172]             ...future.value <- base::withVisible(base::local({
  [20:25:35.172]                 ...future.sendCondition <- local({
  [20:25:35.172]                   sendCondition <- NULL
  [20:25:35.172]                   function(frame = 1L) {
  [20:25:35.172]                     if (is.function(sendCondition)) 
  [20:25:35.172]                       return(sendCondition)
  [20:25:35.172]                     ns <- getNamespace("parallel")
  [20:25:35.172]                     if (exists("sendData", mode = "function", 
  [20:25:35.172]                       envir = ns)) {
  [20:25:35.172]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:35.172]                         envir = ns)
  [20:25:35.172]                       envir <- sys.frame(frame)
  [20:25:35.172]                       master <- NULL
  [20:25:35.172]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:35.172]                         !identical(envir, emptyenv())) {
  [20:25:35.172]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:35.172]                           inherits = FALSE)) {
  [20:25:35.172]                           master <- get("master", mode = "list", 
  [20:25:35.172]                             envir = envir, inherits = FALSE)
  [20:25:35.172]                           if (inherits(master, "SOCKnode")) {
  [20:25:35.172]                             sendCondition <<- function(cond) {
  [20:25:35.172]                               data <- list(type = "VALUE", value = cond, 
  [20:25:35.172]                                 success = TRUE)
  [20:25:35.172]                               parallel_sendData(master, data)
  [20:25:35.172]                             }
  [20:25:35.172]                             return(sendCondition)
  [20:25:35.172]                           }
  [20:25:35.172]                         }
  [20:25:35.172]                         frame <- frame + 1L
  [20:25:35.172]                         envir <- sys.frame(frame)
  [20:25:35.172]                       }
  [20:25:35.172]                     }
  [20:25:35.172]                     sendCondition <<- function(cond) NULL
  [20:25:35.172]                   }
  [20:25:35.172]                 })
  [20:25:35.172]                 withCallingHandlers({
  [20:25:35.172]                   NA
  [20:25:35.172]                 }, immediateCondition = function(cond) {
  [20:25:35.172]                   sendCondition <- ...future.sendCondition()
  [20:25:35.172]                   sendCondition(cond)
  [20:25:35.172]                   muffleCondition <- function (cond) 
  [20:25:35.172]                   {
  [20:25:35.172]                     inherits <- base::inherits
  [20:25:35.172]                     invokeRestart <- base::invokeRestart
  [20:25:35.172]                     muffled <- FALSE
  [20:25:35.172]                     if (inherits(cond, "message")) {
  [20:25:35.172]                       invokeRestart("muffleMessage")
  [20:25:35.172]                       muffled <- TRUE
  [20:25:35.172]                     }
  [20:25:35.172]                     else if (inherits(cond, "warning")) {
  [20:25:35.172]                       invokeRestart("muffleWarning")
  [20:25:35.172]                       muffled <- TRUE
  [20:25:35.172]                     }
  [20:25:35.172]                     else if (inherits(cond, "condition")) {
  [20:25:35.172]                       computeRestarts <- base::computeRestarts
  [20:25:35.172]                       grepl <- base::grepl
  [20:25:35.172]                       is.null <- base::is.null
  [20:25:35.172]                       restarts <- computeRestarts(cond)
  [20:25:35.172]                       for (restart in restarts) {
  [20:25:35.172]                         name <- restart$name
  [20:25:35.172]                         if (is.null(name)) 
  [20:25:35.172]                           next
  [20:25:35.172]                         if (!grepl("^muffle", name)) 
  [20:25:35.172]                           next
  [20:25:35.172]                         invokeRestart(restart)
  [20:25:35.172]                         muffled <- TRUE
  [20:25:35.172]                         break
  [20:25:35.172]                       }
  [20:25:35.172]                     }
  [20:25:35.172]                     invisible(muffled)
  [20:25:35.172]                   }
  [20:25:35.172]                   muffleCondition(cond)
  [20:25:35.172]                 })
  [20:25:35.172]             }))
  [20:25:35.172]             future::FutureResult(value = ...future.value$value, 
  [20:25:35.172]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.172]                   ...future.rng), started = ...future.startTime, 
  [20:25:35.172]                 version = "1.8")
  [20:25:35.172]         }, condition = base::local({
  [20:25:35.172]             c <- base::c
  [20:25:35.172]             inherits <- base::inherits
  [20:25:35.172]             invokeRestart <- base::invokeRestart
  [20:25:35.172]             length <- base::length
  [20:25:35.172]             list <- base::list
  [20:25:35.172]             seq.int <- base::seq.int
  [20:25:35.172]             signalCondition <- base::signalCondition
  [20:25:35.172]             sys.calls <- base::sys.calls
  [20:25:35.172]             Sys.time <- base::Sys.time
  [20:25:35.172]             `[[` <- base::`[[`
  [20:25:35.172]             `+` <- base::`+`
  [20:25:35.172]             `<<-` <- base::`<<-`
  [20:25:35.172]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:35.172]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:35.172]                   3L)]
  [20:25:35.172]             }
  [20:25:35.172]             function(cond) {
  [20:25:35.172]                 if (inherits(cond, "error")) {
  [20:25:35.172]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.172]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:35.172]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:35.172]                   signalCondition(cond)
  [20:25:35.172]                 }
  [20:25:35.172]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:35.172]                 ))) {
  [20:25:35.172]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:35.172]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.172]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:35.172]                   if (!signal) {
  [20:25:35.172]                     muffleCondition <- function (cond) 
  [20:25:35.172]                     {
  [20:25:35.172]                       inherits <- base::inherits
  [20:25:35.172]                       invokeRestart <- base::invokeRestart
  [20:25:35.172]                       muffled <- FALSE
  [20:25:35.172]                       if (inherits(cond, "message")) {
  [20:25:35.172]                         invokeRestart("muffleMessage")
  [20:25:35.172]                         muffled <- TRUE
  [20:25:35.172]                       }
  [20:25:35.172]                       else if (inherits(cond, "warning")) {
  [20:25:35.172]                         invokeRestart("muffleWarning")
  [20:25:35.172]                         muffled <- TRUE
  [20:25:35.172]                       }
  [20:25:35.172]                       else if (inherits(cond, "condition")) {
  [20:25:35.172]                         computeRestarts <- base::computeRestarts
  [20:25:35.172]                         grepl <- base::grepl
  [20:25:35.172]                         is.null <- base::is.null
  [20:25:35.172]                         restarts <- computeRestarts(cond)
  [20:25:35.172]                         for (restart in restarts) {
  [20:25:35.172]                           name <- restart$name
  [20:25:35.172]                           if (is.null(name)) 
  [20:25:35.172]                             next
  [20:25:35.172]                           if (!grepl("^muffle", name)) 
  [20:25:35.172]                             next
  [20:25:35.172]                           invokeRestart(restart)
  [20:25:35.172]                           muffled <- TRUE
  [20:25:35.172]                           break
  [20:25:35.172]                         }
  [20:25:35.172]                       }
  [20:25:35.172]                       invisible(muffled)
  [20:25:35.172]                     }
  [20:25:35.172]                     muffleCondition(cond)
  [20:25:35.172]                   }
  [20:25:35.172]                 }
  [20:25:35.172]             }
  [20:25:35.172]         }))
  [20:25:35.172]     }, error = function(ex) {
  [20:25:35.172]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:35.172]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.172]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:35.172]     }, finally = {
  [20:25:35.172]         {
  [20:25:35.172]             {
  [20:25:35.172]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:35.172]             }
  [20:25:35.172]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:35.172]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.172]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.172]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.172]                 ...) 
  [20:25:35.172]             {
  [20:25:35.172]                 if (substitute) 
  [20:25:35.172]                   expr <- substitute(expr)
  [20:25:35.172]                 if (is.function(workers)) 
  [20:25:35.172]                   workers <- workers()
  [20:25:35.172]                 workers <- as.integer(workers)
  [20:25:35.172]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.172]                   workers >= 1)
  [20:25:35.172]                 if (workers == 1L) {
  [20:25:35.172]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.172]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.172]                     local = TRUE, label = label, ...))
  [20:25:35.172]                 }
  [20:25:35.172]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.172]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.172]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.172]                   globals = globals, persistent = persistent, 
  [20:25:35.172]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.172]                   label = label, ...)
  [20:25:35.172]                 if (!future$lazy) 
  [20:25:35.172]                   future <- run(future)
  [20:25:35.172]                 invisible(future)
  [20:25:35.172]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:35.172]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:25:35.172]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:25:35.172]                 label = NULL, ...) 
  [20:25:35.172]             {
  [20:25:35.172]                 if (substitute) 
  [20:25:35.172]                   expr <- substitute(expr)
  [20:25:35.172]                 if (is.function(workers)) 
  [20:25:35.172]                   workers <- workers()
  [20:25:35.172]                 workers <- as.integer(workers)
  [20:25:35.172]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.172]                   workers >= 1)
  [20:25:35.172]                 if (workers == 1L) {
  [20:25:35.172]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.172]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.172]                     local = TRUE, label = label, ...))
  [20:25:35.172]                 }
  [20:25:35.172]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.172]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.172]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.172]                   globals = globals, persistent = persistent, 
  [20:25:35.172]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.172]                   label = label, ...)
  [20:25:35.172]                 if (!future$lazy) 
  [20:25:35.172]                   future <- run(future)
  [20:25:35.172]                 invisible(future)
  [20:25:35.172]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.172]         }
  [20:25:35.172]         base::options(...future.oldOptions)
  [20:25:35.172]     })
  [20:25:35.172]     Sys.time
  [20:25:35.172]     if (base::is.na(TRUE)) {
  [20:25:35.172]     }
  [20:25:35.172]     else {
  [20:25:35.172]         base::sink(type = "output", split = FALSE)
  [20:25:35.172]         if (TRUE) {
  [20:25:35.172]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:35.172]         }
  [20:25:35.172]         else {
  [20:25:35.172]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:35.172]         }
  [20:25:35.172]         base::close(...future.stdout)
  [20:25:35.172]         ...future.stdout <- NULL
  [20:25:35.172]     }
  [20:25:35.172]     ...future.result$conditions <- ...future.conditions
  [20:25:35.172]     ...future.result
  [20:25:35.172] }
  [20:25:35.198] MultisessionFuture started
  [20:25:35.198] result() for ClusterFuture ...
  [20:25:35.198] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:35.199] - Validating connection of MultisessionFuture
  [20:25:35.504] - received message: FutureResult
  [20:25:35.504] - Received FutureResult
  [20:25:35.504] - Erased future from FutureRegistry
  [20:25:35.505] result() for ClusterFuture ...
  [20:25:35.505] - result already collected: FutureResult
  [20:25:35.505] result() for ClusterFuture ... done
  [20:25:35.506] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:35.506] result() for ClusterFuture ... done
  [20:25:35.507] result() for ClusterFuture ...
  [20:25:35.507] - result already collected: FutureResult
  [20:25:35.507] result() for ClusterFuture ... done
  [20:25:35.508] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:25:35.509] plan(): nbrOfWorkers() = 2
  [20:25:35.509] doFuture() ...
  [20:25:35.514] - dummy globals (as locals): [2] 'a', 'b'
  [20:25:35.515] - R expression:
  [20:25:35.515] {
  [20:25:35.515]     doFuture::registerDoFuture()
  [20:25:35.515]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:35.515]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:35.515]         {
  [20:25:35.515]             a <- NULL
  [20:25:35.515]             b <- NULL
  [20:25:35.515]         }
  [20:25:35.515]         ...future.env <- environment()
  [20:25:35.515]         local({
  [20:25:35.515]             for (name in names(...future.x_jj)) {
  [20:25:35.515]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:25:35.515]                   inherits = FALSE)
  [20:25:35.515]             }
  [20:25:35.515]         })
  [20:25:35.515]         tryCatch({
  [20:25:35.515]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:35.515]                 plan = future::plan("next"))
  [20:25:35.515]         }, error = identity)
  [20:25:35.515]     })
  [20:25:35.515] }
  [20:25:35.516] - identifying globals and packages ...
  [20:25:35.517] getGlobalsAndPackages() ...
  [20:25:35.517] Searching for globals...
  [20:25:35.559] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [20:25:35.560] Searching for globals ... DONE
  [20:25:35.560] Resolving globals: FALSE
  [20:25:35.562] The total size of the 1 globals is 0 bytes (0 bytes)
  [20:25:35.583] - globals: [1] '...future.x_ii'
  [20:25:35.584] 
  [20:25:35.585] getGlobalsAndPackages() ... DONE
  [20:25:35.586] List of 1
  [20:25:35.586]  $ ...future.x_ii: NULL
  [20:25:35.586]  - attr(*, "where")=List of 1
  [20:25:35.586]   ..$ ...future.x_ii:<environment: 0x55bc2355ab88> 
  [20:25:35.586]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:25:35.586]  - attr(*, "resolved")= logi FALSE
  [20:25:35.586]  - attr(*, "total_size")= num 0
  [20:25:35.613]   - R expression:
  [20:25:35.614] {
  [20:25:35.614]     doFuture::registerDoFuture()
  [20:25:35.614]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:35.614]         ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:35.614]         {
  [20:25:35.614]             a <- NULL
  [20:25:35.614]             b <- NULL
  [20:25:35.614]         }
  [20:25:35.614]         ...future.env <- environment()
  [20:25:35.614]         local({
  [20:25:35.614]             for (name in names(...future.x_jj)) {
  [20:25:35.614]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [20:25:35.614]                   inherits = FALSE)
  [20:25:35.614]             }
  [20:25:35.614]         })
  [20:25:35.614]         tryCatch({
  [20:25:35.614]             list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:35.614]                 plan = future::plan("next"))
  [20:25:35.614]         }, error = identity)
  [20:25:35.614]     })
  [20:25:35.614] }
  [20:25:35.615]   - globals: [1] '...future.x_ii'
  [20:25:35.615] List of 1
  [20:25:35.615]  $ ...future.x_ii: NULL
  [20:25:35.615]  - attr(*, "where")=List of 1
  [20:25:35.615]   ..$ ...future.x_ii:<environment: 0x55bc2355ab88> 
  [20:25:35.615]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [20:25:35.615]  - attr(*, "resolved")= logi FALSE
  [20:25:35.615]  - attr(*, "total_size")= num 0
  [20:25:35.624]   - packages: [1] 'doFuture'
  [20:25:35.624] - identifying globals and packages ... DONE
  [20:25:35.628] Number of chunks: 2
  [20:25:35.628] Number of futures (= number of chunks): 2
  [20:25:35.630] Launching 2 futures (chunks) ...
  [20:25:35.630] Chunk #1 of 2 ...
  [20:25:35.631]  - Finding globals in 'args_list' chunk #1 ...
  [20:25:35.631] getGlobalsAndPackages() ...
  [20:25:35.631] Searching for globals...
  [20:25:35.633] 
  [20:25:35.633] Searching for globals ... DONE
  [20:25:35.634] - globals: [0] <none>
  [20:25:35.634] getGlobalsAndPackages() ... DONE
  [20:25:35.634] 
  [20:25:35.635] 
  [20:25:35.635]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [20:25:35.648] getGlobalsAndPackages() ...
  [20:25:35.649] - globals passed as-is: [1] '...future.x_ii'
  [20:25:35.649] Resolving globals: FALSE
  [20:25:35.651] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:25:35.651] - globals: [1] '...future.x_ii'
  [20:25:35.651] 
  [20:25:35.652] getGlobalsAndPackages() ... DONE
  [20:25:35.657] Packages needed by the future expression (n = 1): 'doFuture'
  [20:25:35.658] Packages needed by future strategies (n = 1): 'future'
  [20:25:35.681] {
  [20:25:35.681]     {
  [20:25:35.681]         ...future.startTime <- base::Sys.time()
  [20:25:35.681]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:35.681]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:35.681]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:35.681]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:35.681]             future.resolve.recursive = NULL, width = 80L)
  [20:25:35.681]         {
  [20:25:35.681]             {
  [20:25:35.681]                 {
  [20:25:35.681]                   {
  [20:25:35.681]                     has_future <- base::requireNamespace("future", 
  [20:25:35.681]                       quietly = TRUE)
  [20:25:35.681]                     version <- if (has_future) 
  [20:25:35.681]                       utils::packageVersion("future")
  [20:25:35.681]                     else NULL
  [20:25:35.681]                     if (!has_future || version < "1.8.0") {
  [20:25:35.681]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:35.681]                         "", base::R.version$version.string), 
  [20:25:35.681]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:35.681]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:35.681]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:35.681]                           "release", "version")], collapse = " "), 
  [20:25:35.681]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:35.681]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:35.681]                         info)
  [20:25:35.681]                       info <- base::paste(info, collapse = "; ")
  [20:25:35.681]                       if (!has_future) {
  [20:25:35.681]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:35.681]                           info)
  [20:25:35.681]                       }
  [20:25:35.681]                       else {
  [20:25:35.681]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:35.681]                           info, version)
  [20:25:35.681]                       }
  [20:25:35.681]                       base::stop(msg)
  [20:25:35.681]                     }
  [20:25:35.681]                   }
  [20:25:35.681]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:35.681]                   base::options(mc.cores = 1L)
  [20:25:35.681]                 }
  [20:25:35.681]                 base::local({
  [20:25:35.681]                   for (pkg in c("doFuture", "future")) {
  [20:25:35.681]                     base::loadNamespace(pkg)
  [20:25:35.681]                     base::library(pkg, character.only = TRUE)
  [20:25:35.681]                   }
  [20:25:35.681]                 })
  [20:25:35.681]             }
  [20:25:35.681]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:35.681]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.681]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.681]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.681]                 ...) 
  [20:25:35.681]             {
  [20:25:35.681]                 if (substitute) 
  [20:25:35.681]                   expr <- substitute(expr)
  [20:25:35.681]                 if (is.function(workers)) 
  [20:25:35.681]                   workers <- workers()
  [20:25:35.681]                 workers <- as.integer(workers)
  [20:25:35.681]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.681]                   workers >= 1)
  [20:25:35.681]                 if (workers == 1L) {
  [20:25:35.681]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.681]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.681]                     local = TRUE, label = label, ...))
  [20:25:35.681]                 }
  [20:25:35.681]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.681]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.681]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.681]                   globals = globals, persistent = persistent, 
  [20:25:35.681]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.681]                   label = label, ...)
  [20:25:35.681]                 if (!future$lazy) 
  [20:25:35.681]                   future <- run(future)
  [20:25:35.681]                 invisible(future)
  [20:25:35.681]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.681]         }
  [20:25:35.681]     }
  [20:25:35.681]     if (base::is.na(TRUE)) {
  [20:25:35.681]     }
  [20:25:35.681]     else {
  [20:25:35.681]         if (TRUE) {
  [20:25:35.681]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:35.681]                 open = "w")
  [20:25:35.681]         }
  [20:25:35.681]         else {
  [20:25:35.681]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:35.681]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:35.681]         }
  [20:25:35.681]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:35.681]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:35.681]             base::sink(type = "output", split = FALSE)
  [20:25:35.681]             base::close(...future.stdout)
  [20:25:35.681]         }, add = TRUE)
  [20:25:35.681]     }
  [20:25:35.681]     ...future.frame <- base::sys.nframe()
  [20:25:35.681]     ...future.conditions <- base::list()
  [20:25:35.681]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:35.681]     ...future.result <- base::tryCatch({
  [20:25:35.681]         base::withCallingHandlers({
  [20:25:35.681]             ...future.value <- base::withVisible(base::local({
  [20:25:35.681]                 ...future.sendCondition <- local({
  [20:25:35.681]                   sendCondition <- NULL
  [20:25:35.681]                   function(frame = 1L) {
  [20:25:35.681]                     if (is.function(sendCondition)) 
  [20:25:35.681]                       return(sendCondition)
  [20:25:35.681]                     ns <- getNamespace("parallel")
  [20:25:35.681]                     if (exists("sendData", mode = "function", 
  [20:25:35.681]                       envir = ns)) {
  [20:25:35.681]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:35.681]                         envir = ns)
  [20:25:35.681]                       envir <- sys.frame(frame)
  [20:25:35.681]                       master <- NULL
  [20:25:35.681]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:35.681]                         !identical(envir, emptyenv())) {
  [20:25:35.681]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:35.681]                           inherits = FALSE)) {
  [20:25:35.681]                           master <- get("master", mode = "list", 
  [20:25:35.681]                             envir = envir, inherits = FALSE)
  [20:25:35.681]                           if (inherits(master, "SOCKnode")) {
  [20:25:35.681]                             sendCondition <<- function(cond) {
  [20:25:35.681]                               data <- list(type = "VALUE", value = cond, 
  [20:25:35.681]                                 success = TRUE)
  [20:25:35.681]                               parallel_sendData(master, data)
  [20:25:35.681]                             }
  [20:25:35.681]                             return(sendCondition)
  [20:25:35.681]                           }
  [20:25:35.681]                         }
  [20:25:35.681]                         frame <- frame + 1L
  [20:25:35.681]                         envir <- sys.frame(frame)
  [20:25:35.681]                       }
  [20:25:35.681]                     }
  [20:25:35.681]                     sendCondition <<- function(cond) NULL
  [20:25:35.681]                   }
  [20:25:35.681]                 })
  [20:25:35.681]                 withCallingHandlers({
  [20:25:35.681]                   {
  [20:25:35.681]                     doFuture::registerDoFuture()
  [20:25:35.681]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:35.681]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:35.681]                       {
  [20:25:35.681]                         a <- NULL
  [20:25:35.681]                         b <- NULL
  [20:25:35.681]                       }
  [20:25:35.681]                       ...future.env <- environment()
  [20:25:35.681]                       local({
  [20:25:35.681]                         for (name in names(...future.x_jj)) {
  [20:25:35.681]                           assign(name, ...future.x_jj[[name]], 
  [20:25:35.681]                             envir = ...future.env, inherits = FALSE)
  [20:25:35.681]                         }
  [20:25:35.681]                       })
  [20:25:35.681]                       tryCatch({
  [20:25:35.681]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:35.681]                           plan = future::plan("next"))
  [20:25:35.681]                       }, error = identity)
  [20:25:35.681]                     })
  [20:25:35.681]                   }
  [20:25:35.681]                 }, immediateCondition = function(cond) {
  [20:25:35.681]                   sendCondition <- ...future.sendCondition()
  [20:25:35.681]                   sendCondition(cond)
  [20:25:35.681]                   muffleCondition <- function (cond) 
  [20:25:35.681]                   {
  [20:25:35.681]                     inherits <- base::inherits
  [20:25:35.681]                     invokeRestart <- base::invokeRestart
  [20:25:35.681]                     muffled <- FALSE
  [20:25:35.681]                     if (inherits(cond, "message")) {
  [20:25:35.681]                       invokeRestart("muffleMessage")
  [20:25:35.681]                       muffled <- TRUE
  [20:25:35.681]                     }
  [20:25:35.681]                     else if (inherits(cond, "warning")) {
  [20:25:35.681]                       invokeRestart("muffleWarning")
  [20:25:35.681]                       muffled <- TRUE
  [20:25:35.681]                     }
  [20:25:35.681]                     else if (inherits(cond, "condition")) {
  [20:25:35.681]                       computeRestarts <- base::computeRestarts
  [20:25:35.681]                       grepl <- base::grepl
  [20:25:35.681]                       is.null <- base::is.null
  [20:25:35.681]                       restarts <- computeRestarts(cond)
  [20:25:35.681]                       for (restart in restarts) {
  [20:25:35.681]                         name <- restart$name
  [20:25:35.681]                         if (is.null(name)) 
  [20:25:35.681]                           next
  [20:25:35.681]                         if (!grepl("^muffle", name)) 
  [20:25:35.681]                           next
  [20:25:35.681]                         invokeRestart(restart)
  [20:25:35.681]                         muffled <- TRUE
  [20:25:35.681]                         break
  [20:25:35.681]                       }
  [20:25:35.681]                     }
  [20:25:35.681]                     invisible(muffled)
  [20:25:35.681]                   }
  [20:25:35.681]                   muffleCondition(cond)
  [20:25:35.681]                 })
  [20:25:35.681]             }))
  [20:25:35.681]             future::FutureResult(value = ...future.value$value, 
  [20:25:35.681]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.681]                   ...future.rng), started = ...future.startTime, 
  [20:25:35.681]                 version = "1.8")
  [20:25:35.681]         }, condition = base::local({
  [20:25:35.681]             c <- base::c
  [20:25:35.681]             inherits <- base::inherits
  [20:25:35.681]             invokeRestart <- base::invokeRestart
  [20:25:35.681]             length <- base::length
  [20:25:35.681]             list <- base::list
  [20:25:35.681]             seq.int <- base::seq.int
  [20:25:35.681]             signalCondition <- base::signalCondition
  [20:25:35.681]             sys.calls <- base::sys.calls
  [20:25:35.681]             Sys.time <- base::Sys.time
  [20:25:35.681]             `[[` <- base::`[[`
  [20:25:35.681]             `+` <- base::`+`
  [20:25:35.681]             `<<-` <- base::`<<-`
  [20:25:35.681]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:35.681]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:35.681]                   3L)]
  [20:25:35.681]             }
  [20:25:35.681]             function(cond) {
  [20:25:35.681]                 if (inherits(cond, "error")) {
  [20:25:35.681]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.681]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:35.681]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:35.681]                   signalCondition(cond)
  [20:25:35.681]                 }
  [20:25:35.681]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:35.681]                 ))) {
  [20:25:35.681]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:35.681]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.681]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:35.681]                   if (!signal) {
  [20:25:35.681]                     muffleCondition <- function (cond) 
  [20:25:35.681]                     {
  [20:25:35.681]                       inherits <- base::inherits
  [20:25:35.681]                       invokeRestart <- base::invokeRestart
  [20:25:35.681]                       muffled <- FALSE
  [20:25:35.681]                       if (inherits(cond, "message")) {
  [20:25:35.681]                         invokeRestart("muffleMessage")
  [20:25:35.681]                         muffled <- TRUE
  [20:25:35.681]                       }
  [20:25:35.681]                       else if (inherits(cond, "warning")) {
  [20:25:35.681]                         invokeRestart("muffleWarning")
  [20:25:35.681]                         muffled <- TRUE
  [20:25:35.681]                       }
  [20:25:35.681]                       else if (inherits(cond, "condition")) {
  [20:25:35.681]                         computeRestarts <- base::computeRestarts
  [20:25:35.681]                         grepl <- base::grepl
  [20:25:35.681]                         is.null <- base::is.null
  [20:25:35.681]                         restarts <- computeRestarts(cond)
  [20:25:35.681]                         for (restart in restarts) {
  [20:25:35.681]                           name <- restart$name
  [20:25:35.681]                           if (is.null(name)) 
  [20:25:35.681]                             next
  [20:25:35.681]                           if (!grepl("^muffle", name)) 
  [20:25:35.681]                             next
  [20:25:35.681]                           invokeRestart(restart)
  [20:25:35.681]                           muffled <- TRUE
  [20:25:35.681]                           break
  [20:25:35.681]                         }
  [20:25:35.681]                       }
  [20:25:35.681]                       invisible(muffled)
  [20:25:35.681]                     }
  [20:25:35.681]                     muffleCondition(cond)
  [20:25:35.681]                   }
  [20:25:35.681]                 }
  [20:25:35.681]             }
  [20:25:35.681]         }))
  [20:25:35.681]     }, error = function(ex) {
  [20:25:35.681]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:35.681]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.681]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:35.681]     }, finally = {
  [20:25:35.681]         {
  [20:25:35.681]             {
  [20:25:35.681]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:35.681]             }
  [20:25:35.681]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:35.681]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.681]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.681]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.681]                 ...) 
  [20:25:35.681]             {
  [20:25:35.681]                 if (substitute) 
  [20:25:35.681]                   expr <- substitute(expr)
  [20:25:35.681]                 if (is.function(workers)) 
  [20:25:35.681]                   workers <- workers()
  [20:25:35.681]                 workers <- as.integer(workers)
  [20:25:35.681]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.681]                   workers >= 1)
  [20:25:35.681]                 if (workers == 1L) {
  [20:25:35.681]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.681]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.681]                     local = TRUE, label = label, ...))
  [20:25:35.681]                 }
  [20:25:35.681]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.681]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.681]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.681]                   globals = globals, persistent = persistent, 
  [20:25:35.681]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.681]                   label = label, ...)
  [20:25:35.681]                 if (!future$lazy) 
  [20:25:35.681]                   future <- run(future)
  [20:25:35.681]                 invisible(future)
  [20:25:35.681]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:35.681]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:25:35.681]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:25:35.681]                 label = NULL, ...) 
  [20:25:35.681]             {
  [20:25:35.681]                 if (substitute) 
  [20:25:35.681]                   expr <- substitute(expr)
  [20:25:35.681]                 if (is.function(workers)) 
  [20:25:35.681]                   workers <- workers()
  [20:25:35.681]                 workers <- as.integer(workers)
  [20:25:35.681]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.681]                   workers >= 1)
  [20:25:35.681]                 if (workers == 1L) {
  [20:25:35.681]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.681]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.681]                     local = TRUE, label = label, ...))
  [20:25:35.681]                 }
  [20:25:35.681]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.681]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.681]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.681]                   globals = globals, persistent = persistent, 
  [20:25:35.681]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.681]                   label = label, ...)
  [20:25:35.681]                 if (!future$lazy) 
  [20:25:35.681]                   future <- run(future)
  [20:25:35.681]                 invisible(future)
  [20:25:35.681]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.681]         }
  [20:25:35.681]         base::options(...future.oldOptions)
  [20:25:35.681]     })
  [20:25:35.681]     Sys.time
  [20:25:35.681]     if (base::is.na(TRUE)) {
  [20:25:35.681]     }
  [20:25:35.681]     else {
  [20:25:35.681]         base::sink(type = "output", split = FALSE)
  [20:25:35.681]         if (TRUE) {
  [20:25:35.681]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:35.681]         }
  [20:25:35.681]         else {
  [20:25:35.681]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:35.681]         }
  [20:25:35.681]         base::close(...future.stdout)
  [20:25:35.681]         ...future.stdout <- NULL
  [20:25:35.681]     }
  [20:25:35.681]     ...future.result$conditions <- ...future.conditions
  [20:25:35.681]     ...future.result
  [20:25:35.681] }
  [20:25:35.702] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [20:25:35.703] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [20:25:35.704] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [20:25:35.704] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [20:25:35.706] MultisessionFuture started
  [20:25:35.706] Chunk #1 of 2 ... DONE
  [20:25:35.706] Chunk #2 of 2 ...
  [20:25:35.707]  - Finding globals in 'args_list' chunk #2 ...
  [20:25:35.707] getGlobalsAndPackages() ...
  [20:25:35.707] Searching for globals...
  [20:25:35.708] 
  [20:25:35.708] Searching for globals ... DONE
  [20:25:35.709] - globals: [0] <none>
  [20:25:35.709] getGlobalsAndPackages() ... DONE
  [20:25:35.709] 
  [20:25:35.709] 
  [20:25:35.710]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [20:25:35.719] getGlobalsAndPackages() ...
  [20:25:35.719] - globals passed as-is: [1] '...future.x_ii'
  [20:25:35.720] Resolving globals: FALSE
  [20:25:35.721] The total size of the 1 globals is 336 bytes (336 bytes)
  [20:25:35.721] - globals: [1] '...future.x_ii'
  [20:25:35.721] 
  [20:25:35.722] getGlobalsAndPackages() ... DONE
  [20:25:35.725] Packages needed by the future expression (n = 1): 'doFuture'
  [20:25:35.726] Packages needed by future strategies (n = 1): 'future'
  [20:25:35.731] {
  [20:25:35.731]     {
  [20:25:35.731]         ...future.startTime <- base::Sys.time()
  [20:25:35.731]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [20:25:35.731]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:25:35.731]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:25:35.731]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:25:35.731]             future.resolve.recursive = NULL, width = 80L)
  [20:25:35.731]         {
  [20:25:35.731]             {
  [20:25:35.731]                 {
  [20:25:35.731]                   {
  [20:25:35.731]                     has_future <- base::requireNamespace("future", 
  [20:25:35.731]                       quietly = TRUE)
  [20:25:35.731]                     version <- if (has_future) 
  [20:25:35.731]                       utils::packageVersion("future")
  [20:25:35.731]                     else NULL
  [20:25:35.731]                     if (!has_future || version < "1.8.0") {
  [20:25:35.731]                       info <- base::c(r_version = base::gsub("R version ", 
  [20:25:35.731]                         "", base::R.version$version.string), 
  [20:25:35.731]                         platform = base::sprintf("%s (%s-bit)", 
  [20:25:35.731]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [20:25:35.731]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [20:25:35.731]                           "release", "version")], collapse = " "), 
  [20:25:35.731]                         hostname = base::Sys.info()[["nodename"]])
  [20:25:35.731]                       info <- base::sprintf("%s: %s", base::names(info), 
  [20:25:35.731]                         info)
  [20:25:35.731]                       info <- base::paste(info, collapse = "; ")
  [20:25:35.731]                       if (!has_future) {
  [20:25:35.731]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [20:25:35.731]                           info)
  [20:25:35.731]                       }
  [20:25:35.731]                       else {
  [20:25:35.731]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:25:35.731]                           info, version)
  [20:25:35.731]                       }
  [20:25:35.731]                       base::stop(msg)
  [20:25:35.731]                     }
  [20:25:35.731]                   }
  [20:25:35.731]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [20:25:35.731]                   base::options(mc.cores = 1L)
  [20:25:35.731]                 }
  [20:25:35.731]                 base::local({
  [20:25:35.731]                   for (pkg in c("doFuture", "future")) {
  [20:25:35.731]                     base::loadNamespace(pkg)
  [20:25:35.731]                     base::library(pkg, character.only = TRUE)
  [20:25:35.731]                   }
  [20:25:35.731]                 })
  [20:25:35.731]             }
  [20:25:35.731]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [20:25:35.731]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.731]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.731]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.731]                 ...) 
  [20:25:35.731]             {
  [20:25:35.731]                 if (substitute) 
  [20:25:35.731]                   expr <- substitute(expr)
  [20:25:35.731]                 if (is.function(workers)) 
  [20:25:35.731]                   workers <- workers()
  [20:25:35.731]                 workers <- as.integer(workers)
  [20:25:35.731]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.731]                   workers >= 1)
  [20:25:35.731]                 if (workers == 1L) {
  [20:25:35.731]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.731]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.731]                     local = TRUE, label = label, ...))
  [20:25:35.731]                 }
  [20:25:35.731]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.731]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.731]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.731]                   globals = globals, persistent = persistent, 
  [20:25:35.731]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.731]                   label = label, ...)
  [20:25:35.731]                 if (!future$lazy) 
  [20:25:35.731]                   future <- run(future)
  [20:25:35.731]                 invisible(future)
  [20:25:35.731]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.731]         }
  [20:25:35.731]     }
  [20:25:35.731]     if (base::is.na(TRUE)) {
  [20:25:35.731]     }
  [20:25:35.731]     else {
  [20:25:35.731]         if (TRUE) {
  [20:25:35.731]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [20:25:35.731]                 open = "w")
  [20:25:35.731]         }
  [20:25:35.731]         else {
  [20:25:35.731]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [20:25:35.731]                 windows = "NUL", "/dev/null"), open = "w")
  [20:25:35.731]         }
  [20:25:35.731]         base::sink(...future.stdout, type = "output", split = FALSE)
  [20:25:35.731]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [20:25:35.731]             base::sink(type = "output", split = FALSE)
  [20:25:35.731]             base::close(...future.stdout)
  [20:25:35.731]         }, add = TRUE)
  [20:25:35.731]     }
  [20:25:35.731]     ...future.frame <- base::sys.nframe()
  [20:25:35.731]     ...future.conditions <- base::list()
  [20:25:35.731]     ...future.rng <- base::globalenv()$.Random.seed
  [20:25:35.731]     ...future.result <- base::tryCatch({
  [20:25:35.731]         base::withCallingHandlers({
  [20:25:35.731]             ...future.value <- base::withVisible(base::local({
  [20:25:35.731]                 ...future.sendCondition <- local({
  [20:25:35.731]                   sendCondition <- NULL
  [20:25:35.731]                   function(frame = 1L) {
  [20:25:35.731]                     if (is.function(sendCondition)) 
  [20:25:35.731]                       return(sendCondition)
  [20:25:35.731]                     ns <- getNamespace("parallel")
  [20:25:35.731]                     if (exists("sendData", mode = "function", 
  [20:25:35.731]                       envir = ns)) {
  [20:25:35.731]                       parallel_sendData <- get("sendData", mode = "function", 
  [20:25:35.731]                         envir = ns)
  [20:25:35.731]                       envir <- sys.frame(frame)
  [20:25:35.731]                       master <- NULL
  [20:25:35.731]                       while (!identical(envir, .GlobalEnv) && 
  [20:25:35.731]                         !identical(envir, emptyenv())) {
  [20:25:35.731]                         if (exists("master", mode = "list", envir = envir, 
  [20:25:35.731]                           inherits = FALSE)) {
  [20:25:35.731]                           master <- get("master", mode = "list", 
  [20:25:35.731]                             envir = envir, inherits = FALSE)
  [20:25:35.731]                           if (inherits(master, "SOCKnode")) {
  [20:25:35.731]                             sendCondition <<- function(cond) {
  [20:25:35.731]                               data <- list(type = "VALUE", value = cond, 
  [20:25:35.731]                                 success = TRUE)
  [20:25:35.731]                               parallel_sendData(master, data)
  [20:25:35.731]                             }
  [20:25:35.731]                             return(sendCondition)
  [20:25:35.731]                           }
  [20:25:35.731]                         }
  [20:25:35.731]                         frame <- frame + 1L
  [20:25:35.731]                         envir <- sys.frame(frame)
  [20:25:35.731]                       }
  [20:25:35.731]                     }
  [20:25:35.731]                     sendCondition <<- function(cond) NULL
  [20:25:35.731]                   }
  [20:25:35.731]                 })
  [20:25:35.731]                 withCallingHandlers({
  [20:25:35.731]                   {
  [20:25:35.731]                     doFuture::registerDoFuture()
  [20:25:35.731]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [20:25:35.731]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [20:25:35.731]                       {
  [20:25:35.731]                         a <- NULL
  [20:25:35.731]                         b <- NULL
  [20:25:35.731]                       }
  [20:25:35.731]                       ...future.env <- environment()
  [20:25:35.731]                       local({
  [20:25:35.731]                         for (name in names(...future.x_jj)) {
  [20:25:35.731]                           assign(name, ...future.x_jj[[name]], 
  [20:25:35.731]                             envir = ...future.env, inherits = FALSE)
  [20:25:35.731]                         }
  [20:25:35.731]                       })
  [20:25:35.731]                       tryCatch({
  [20:25:35.731]                         list(a = a, b = b, plan_b = future::plan("list"), 
  [20:25:35.731]                           plan = future::plan("next"))
  [20:25:35.731]                       }, error = identity)
  [20:25:35.731]                     })
  [20:25:35.731]                   }
  [20:25:35.731]                 }, immediateCondition = function(cond) {
  [20:25:35.731]                   sendCondition <- ...future.sendCondition()
  [20:25:35.731]                   sendCondition(cond)
  [20:25:35.731]                   muffleCondition <- function (cond) 
  [20:25:35.731]                   {
  [20:25:35.731]                     inherits <- base::inherits
  [20:25:35.731]                     invokeRestart <- base::invokeRestart
  [20:25:35.731]                     muffled <- FALSE
  [20:25:35.731]                     if (inherits(cond, "message")) {
  [20:25:35.731]                       invokeRestart("muffleMessage")
  [20:25:35.731]                       muffled <- TRUE
  [20:25:35.731]                     }
  [20:25:35.731]                     else if (inherits(cond, "warning")) {
  [20:25:35.731]                       invokeRestart("muffleWarning")
  [20:25:35.731]                       muffled <- TRUE
  [20:25:35.731]                     }
  [20:25:35.731]                     else if (inherits(cond, "condition")) {
  [20:25:35.731]                       computeRestarts <- base::computeRestarts
  [20:25:35.731]                       grepl <- base::grepl
  [20:25:35.731]                       is.null <- base::is.null
  [20:25:35.731]                       restarts <- computeRestarts(cond)
  [20:25:35.731]                       for (restart in restarts) {
  [20:25:35.731]                         name <- restart$name
  [20:25:35.731]                         if (is.null(name)) 
  [20:25:35.731]                           next
  [20:25:35.731]                         if (!grepl("^muffle", name)) 
  [20:25:35.731]                           next
  [20:25:35.731]                         invokeRestart(restart)
  [20:25:35.731]                         muffled <- TRUE
  [20:25:35.731]                         break
  [20:25:35.731]                       }
  [20:25:35.731]                     }
  [20:25:35.731]                     invisible(muffled)
  [20:25:35.731]                   }
  [20:25:35.731]                   muffleCondition(cond)
  [20:25:35.731]                 })
  [20:25:35.731]             }))
  [20:25:35.731]             future::FutureResult(value = ...future.value$value, 
  [20:25:35.731]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.731]                   ...future.rng), started = ...future.startTime, 
  [20:25:35.731]                 version = "1.8")
  [20:25:35.731]         }, condition = base::local({
  [20:25:35.731]             c <- base::c
  [20:25:35.731]             inherits <- base::inherits
  [20:25:35.731]             invokeRestart <- base::invokeRestart
  [20:25:35.731]             length <- base::length
  [20:25:35.731]             list <- base::list
  [20:25:35.731]             seq.int <- base::seq.int
  [20:25:35.731]             signalCondition <- base::signalCondition
  [20:25:35.731]             sys.calls <- base::sys.calls
  [20:25:35.731]             Sys.time <- base::Sys.time
  [20:25:35.731]             `[[` <- base::`[[`
  [20:25:35.731]             `+` <- base::`+`
  [20:25:35.731]             `<<-` <- base::`<<-`
  [20:25:35.731]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:25:35.731]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:25:35.731]                   3L)]
  [20:25:35.731]             }
  [20:25:35.731]             function(cond) {
  [20:25:35.731]                 if (inherits(cond, "error")) {
  [20:25:35.731]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.731]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:25:35.731]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [20:25:35.731]                   signalCondition(cond)
  [20:25:35.731]                 }
  [20:25:35.731]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:25:35.731]                 ))) {
  [20:25:35.731]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:25:35.731]                   ...future.conditions[[length(...future.conditions) + 
  [20:25:35.731]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [20:25:35.731]                   if (!signal) {
  [20:25:35.731]                     muffleCondition <- function (cond) 
  [20:25:35.731]                     {
  [20:25:35.731]                       inherits <- base::inherits
  [20:25:35.731]                       invokeRestart <- base::invokeRestart
  [20:25:35.731]                       muffled <- FALSE
  [20:25:35.731]                       if (inherits(cond, "message")) {
  [20:25:35.731]                         invokeRestart("muffleMessage")
  [20:25:35.731]                         muffled <- TRUE
  [20:25:35.731]                       }
  [20:25:35.731]                       else if (inherits(cond, "warning")) {
  [20:25:35.731]                         invokeRestart("muffleWarning")
  [20:25:35.731]                         muffled <- TRUE
  [20:25:35.731]                       }
  [20:25:35.731]                       else if (inherits(cond, "condition")) {
  [20:25:35.731]                         computeRestarts <- base::computeRestarts
  [20:25:35.731]                         grepl <- base::grepl
  [20:25:35.731]                         is.null <- base::is.null
  [20:25:35.731]                         restarts <- computeRestarts(cond)
  [20:25:35.731]                         for (restart in restarts) {
  [20:25:35.731]                           name <- restart$name
  [20:25:35.731]                           if (is.null(name)) 
  [20:25:35.731]                             next
  [20:25:35.731]                           if (!grepl("^muffle", name)) 
  [20:25:35.731]                             next
  [20:25:35.731]                           invokeRestart(restart)
  [20:25:35.731]                           muffled <- TRUE
  [20:25:35.731]                           break
  [20:25:35.731]                         }
  [20:25:35.731]                       }
  [20:25:35.731]                       invisible(muffled)
  [20:25:35.731]                     }
  [20:25:35.731]                     muffleCondition(cond)
  [20:25:35.731]                   }
  [20:25:35.731]                 }
  [20:25:35.731]             }
  [20:25:35.731]         }))
  [20:25:35.731]     }, error = function(ex) {
  [20:25:35.731]         base::structure(base::list(value = NULL, visible = NULL, 
  [20:25:35.731]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [20:25:35.731]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [20:25:35.731]     }, finally = {
  [20:25:35.731]         {
  [20:25:35.731]             {
  [20:25:35.731]                 base::options(mc.cores = ...future.mc.cores.old)
  [20:25:35.731]             }
  [20:25:35.731]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [20:25:35.731]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:25:35.731]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:25:35.731]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:25:35.731]                 ...) 
  [20:25:35.731]             {
  [20:25:35.731]                 if (substitute) 
  [20:25:35.731]                   expr <- substitute(expr)
  [20:25:35.731]                 if (is.function(workers)) 
  [20:25:35.731]                   workers <- workers()
  [20:25:35.731]                 workers <- as.integer(workers)
  [20:25:35.731]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.731]                   workers >= 1)
  [20:25:35.731]                 if (workers == 1L) {
  [20:25:35.731]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.731]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.731]                     local = TRUE, label = label, ...))
  [20:25:35.731]                 }
  [20:25:35.731]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.731]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.731]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.731]                   globals = globals, persistent = persistent, 
  [20:25:35.731]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.731]                   label = label, ...)
  [20:25:35.731]                 if (!future$lazy) 
  [20:25:35.731]                   future <- run(future)
  [20:25:35.731]                 invisible(future)
  [20:25:35.731]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [20:25:35.731]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [20:25:35.731]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [20:25:35.731]                 label = NULL, ...) 
  [20:25:35.731]             {
  [20:25:35.731]                 if (substitute) 
  [20:25:35.731]                   expr <- substitute(expr)
  [20:25:35.731]                 if (is.function(workers)) 
  [20:25:35.731]                   workers <- workers()
  [20:25:35.731]                 workers <- as.integer(workers)
  [20:25:35.731]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:25:35.731]                   workers >= 1)
  [20:25:35.731]                 if (workers == 1L) {
  [20:25:35.731]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:25:35.731]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:25:35.731]                     local = TRUE, label = label, ...))
  [20:25:35.731]                 }
  [20:25:35.731]                 workers <- ClusterRegistry("start", workers = workers)
  [20:25:35.731]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:25:35.731]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:25:35.731]                   globals = globals, persistent = persistent, 
  [20:25:35.731]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:25:35.731]                   label = label, ...)
  [20:25:35.731]                 if (!future$lazy) 
  [20:25:35.731]                   future <- run(future)
  [20:25:35.731]                 invisible(future)
  [20:25:35.731]             }), .cleanup = FALSE, .init = FALSE)
  [20:25:35.731]         }
  [20:25:35.731]         base::options(...future.oldOptions)
  [20:25:35.731]     })
  [20:25:35.731]     Sys.time
  [20:25:35.731]     if (base::is.na(TRUE)) {
  [20:25:35.731]     }
  [20:25:35.731]     else {
  [20:25:35.731]         base::sink(type = "output", split = FALSE)
  [20:25:35.731]         if (TRUE) {
  [20:25:35.731]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [20:25:35.731]         }
  [20:25:35.731]         else {
  [20:25:35.731]             ...future.result["stdout"] <- base::list(NULL)
  [20:25:35.731]         }
  [20:25:35.731]         base::close(...future.stdout)
  [20:25:35.731]         ...future.stdout <- NULL
  [20:25:35.731]     }
  [20:25:35.731]     ...future.result$conditions <- ...future.conditions
  [20:25:35.731]     ...future.result
  [20:25:35.731] }
  [20:25:35.739] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [20:25:35.739] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [20:25:35.740] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [20:25:35.741] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [20:25:35.742] MultisessionFuture started
  [20:25:35.742] Chunk #2 of 2 ... DONE
  [20:25:35.743] Launching 2 futures (chunks) ... DONE
  [20:25:35.743] - resolving futures
  [20:25:35.743]   - gathering results & relaying conditions (except errors)
  [20:25:35.743] resolve() on list ...
  [20:25:35.744]  recursive: 0
  [20:25:35.744]  length: 2
  [20:25:35.744] 
  [20:25:36.265] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:36.266] - Validating connection of MultisessionFuture
  [20:25:36.267] - received message: FutureResult
  [20:25:36.267] - Received FutureResult
  [20:25:36.268] - Erased future from FutureRegistry
  [20:25:36.268] result() for ClusterFuture ...
  [20:25:36.268] - result already collected: FutureResult
  [20:25:36.269] result() for ClusterFuture ... done
  [20:25:36.269] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:36.269] Future #1
  [20:25:36.270] result() for ClusterFuture ...
  [20:25:36.270] - result already collected: FutureResult
  [20:25:36.270] result() for ClusterFuture ... done
  [20:25:36.271] result() for ClusterFuture ...
  [20:25:36.271] - result already collected: FutureResult
  [20:25:36.271] result() for ClusterFuture ... done
  [20:25:36.271] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [20:25:36.272] - nx: 2
  [20:25:36.272] - relay: TRUE
  [20:25:36.272] - stdout: TRUE
  [20:25:36.272] - signal: TRUE
  [20:25:36.273] - resignal: FALSE
  [20:25:36.273] - force: FALSE
  [20:25:36.273] - relayed: [n=2] FALSE, FALSE
  [20:25:36.273] - queued futures: [n=2] FALSE, FALSE
  [20:25:36.274]  - until=1
  [20:25:36.274]  - relaying element #1
  [20:25:36.274] result() for ClusterFuture ...
  [20:25:36.275] - result already collected: FutureResult
  [20:25:36.275] result() for ClusterFuture ... done
  [20:25:36.275] result() for ClusterFuture ...
  [20:25:36.276] - result already collected: FutureResult
  [20:25:36.276] result() for ClusterFuture ... done
  [20:25:36.276] result() for ClusterFuture ...
  [20:25:36.276] - result already collected: FutureResult
  [20:25:36.277] result() for ClusterFuture ... done
  [20:25:36.277] result() for ClusterFuture ...
  [20:25:36.277] - result already collected: FutureResult
  [20:25:36.278] result() for ClusterFuture ... done
  [20:25:36.278] - relayed: [n=2] TRUE, FALSE
  [20:25:36.294] - queued futures: [n=2] TRUE, FALSE
  [20:25:36.295] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [20:25:36.295]  length: 1 (resolved future 1)
  [20:25:36.297] receiveMessageFromWorker() for ClusterFuture ...
  [20:25:36.297] - Validating connection of MultisessionFuture
  [20:25:36.299] - received message: FutureResult
  [20:25:36.299] - Received FutureResult
  [20:25:36.299] - Erased future from FutureRegistry
  [20:25:36.300] result() for ClusterFuture ...
  [20:25:36.300] - result already collected: FutureResult
  [20:25:36.300] result() for ClusterFuture ... done
  [20:25:36.300] receiveMessageFromWorker() for ClusterFuture ... done
  [20:25:36.301] Future #2
  [20:25:36.301] result() for ClusterFuture ...
  [20:25:36.301] - result already collected: FutureResult
  [20:25:36.302] result() for ClusterFuture ... done
  [20:25:36.302] result() for ClusterFuture ...
  [20:25:36.302] - result already collected: FutureResult
  [20:25:36.303] result() for ClusterFuture ... done
  [20:25:36.303] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [20:25:36.303] - nx: 2
  [20:25:36.304] - relay: TRUE
  [20:25:36.304] - stdout: TRUE
  [20:25:36.304] - signal: TRUE
  [20:25:36.304] - resignal: FALSE
  [20:25:36.305] - force: FALSE
  [20:25:36.305] - relayed: [n=2] TRUE, FALSE
  [20:25:36.305] - queued futures: [n=2] TRUE, FALSE
  [20:25:36.305]  - until=2
  [20:25:36.322]  - relaying element #2
  [20:25:36.322] result() for ClusterFuture ...
  [20:25:36.323] - result already collected: FutureResult
  [20:25:36.323] result() for ClusterFuture ... done
  [20:25:36.323] result() for ClusterFuture ...
  [20:25:36.323] - result already collected: FutureResult
  [20:25:36.324] result() for ClusterFuture ... done
  [20:25:36.324] result() for ClusterFuture ...
  [20:25:36.324] - result already collected: FutureResult
  [20:25:36.325] result() for ClusterFuture ... done
  [20:25:36.325] result() for ClusterFuture ...
  [20:25:36.325] - result already collected: FutureResult
  [20:25:36.325] result() for ClusterFuture ... done
  [20:25:36.326] - relayed: [n=2] TRUE, TRUE
  [20:25:36.326] - queued futures: [n=2] TRUE, TRUE
  [20:25:36.326] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [20:25:36.327]  length: 0 (resolved future 2)
  [20:25:36.327] Relaying remaining futures
  [20:25:36.327] signalConditionsASAP(NULL, pos=0) ...
  [20:25:36.327] - nx: 2
  [20:25:36.328] - relay: TRUE
  [20:25:36.328] - stdout: TRUE
  [20:25:36.328] - signal: TRUE
  [20:25:36.328] - resignal: FALSE
  [20:25:36.329] - force: FALSE
  [20:25:36.329] - relayed: [n=2] TRUE, TRUE
  [20:25:36.329] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [20:25:36.330] - relayed: [n=2] TRUE, TRUE
  [20:25:36.330] - queued futures: [n=2] TRUE, TRUE
  [20:25:36.330] signalConditionsASAP(NULL, pos=0) ... done
  [20:25:36.330] resolve() on list ... DONE
  [20:25:36.331] - collecting values of futures
  [20:25:36.331] result() for ClusterFuture ...
  [20:25:36.331] - result already collected: FutureResult
  [20:25:36.331] result() for ClusterFuture ... done
  [20:25:36.332] result() for ClusterFuture ...
  [20:25:36.332] - result already collected: FutureResult
  [20:25:36.332] result() for ClusterFuture ... done
  [20:25:36.333] result() for ClusterFuture ...
  [20:25:36.333] - result already collected: FutureResult
  [20:25:36.333] result() for ClusterFuture ... done
  [20:25:36.333] result() for ClusterFuture ...
  [20:25:36.334] - result already collected: FutureResult
  [20:25:36.334] result() for ClusterFuture ... done
  [20:25:36.334] - accumulating results
  [20:25:36.337] - processing errors (handler = 'stop')
  [20:25:36.337] - extracting results
  [20:25:36.337] doFuture() ... DONE
  - plan(list('multisession', 'multisession')) ... DONE
  - plan(list('multisession', 'cluster')) ...
  [20:25:36.339] plan(): Setting new future strategy stack:
  [20:25:36.339] List of future strategies:
  [20:25:36.339] 1. multisession:
  [20:25:36.339]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:36.339]    - tweaked: FALSE
  [20:25:36.339]    - call: plan(list(a = strategy1, b = strategy2))
  [20:25:36.339] 2. cluster:
  [20:25:36.339]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:36.339]    - tweaked: FALSE
  [20:25:36.339]    - call: plan(list(a = strategy1, b = strategy2))
  [20:25:36.352] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:25:36.352] multisession:
  [20:25:36.352] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:25:36.352] - tweaked: FALSE
  [20:25:36.352] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 38008
  [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/Rtmp1AMrfv/future.parent=2402.9627d986102.pid")), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9627d986102.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=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9627d986102.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38008 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 38008 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 38008 cannot be opened
  Killing worker process (PID 1950) if still alive
  [20:25:38.560] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(2402, signal = 0L)
  [1] TRUE
  Call: tools::pskill(2402, signal = 0L)
  [1] TRUE
  [20:25:38.560] - success
  [20:25:38.561] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 1950) 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 38008 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 38008 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=foreach,nested.R:2402:gimli2:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp1AMrfv/future.parent=2402.9627d986102.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38008 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 1950) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted