Running ‘DEPRECATED.R’ [1s/1s]
  Running ‘cluster-missing-doFuture-pkg.R’ [1s/3s]
  Running ‘doRNG,dopar.R’ [3s/35s]
  Running ‘doRNG,dorng.R’ [6s/39s]
  Running ‘foreach,errors.R’ [7s/103s]
  Running ‘foreach,globals.R’ [8s/104s]
  Running ‘foreach,nested.R’ [5s/72s]
  Running ‘foreach,nested_dopar.R’ [17s/235s]
  Running ‘foreach.R’ [11s/51s]
  Running ‘future.BatchJobs.R’ [28s/35s]
  Running ‘future.batchtools.R’ [35s/37s]
  Running ‘options.R’ [3s/21s]
  Running ‘registerDoFuture.R’ [2s/32s]
  Running ‘times.R’ [3s/34s]
  Running ‘zzz_opt-in,NMF.R’ [0s/1s]
  Running ‘zzz_opt-in,TSP.R’ [0s/1s]
  Running ‘zzz_opt-in,caret.R’ [0s/0s]
  Running ‘zzz_opt-in,foreach.R’ [0s/1s]
  Running ‘zzz_opt-in,glmnet.R’ [0s/0s]
  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
  [13:33:51.462] plan(): Setting new future strategy stack:
  [13:33:51.463] List of future strategies:
  [13:33:51.463] 1. sequential:
  [13:33:51.463]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.463]    - tweaked: FALSE
  [13:33:51.463]    - call: future::plan(future::sequential)
  [13:33:51.465] 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())
  +     }
  + 
  +     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')) ...
  [13:33:51.548] plan(): Setting new future strategy stack:
  [13:33:51.548] List of future strategies:
  [13:33:51.548] 1. sequential:
  [13:33:51.548]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.548]    - tweaked: FALSE
  [13:33:51.548]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.548] 2. sequential:
  [13:33:51.548]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.548]    - tweaked: FALSE
  [13:33:51.548]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.578] plan(): nbrOfWorkers() = 1
  [13:33:51.579] doFuture() ...
  [13:33:51.585] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:51.587] - R expression:
  [13:33:51.587] {
  [13:33:51.587]     doFuture::registerDoFuture()
  [13:33:51.587]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.587]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.587]         {
  [13:33:51.587]             a <- NULL
  [13:33:51.587]             b <- NULL
  [13:33:51.587]         }
  [13:33:51.587]         ...future.env <- environment()
  [13:33:51.587]         local({
  [13:33:51.587]             for (name in names(...future.x_jj)) {
  [13:33:51.587]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.587]                   inherits = FALSE)
  [13:33:51.587]             }
  [13:33:51.587]         })
  [13:33:51.587]         tryCatch({
  [13:33:51.587]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.587]                 plan = future::plan())
  [13:33:51.587]         }, error = identity)
  [13:33:51.587]     })
  [13:33:51.587] }
  [13:33:51.588] - identifying globals and packages ...
  [13:33:51.590] getGlobalsAndPackages() ...
  [13:33:51.591] Searching for globals...
  [13:33:51.623] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:51.624] Searching for globals ... DONE
  [13:33:51.624] Resolving globals: FALSE
  [13:33:51.627] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:51.627] - globals: [1] '...future.x_ii'
  [13:33:51.628] 
  [13:33:51.628] getGlobalsAndPackages() ... DONE
  [13:33:51.628] List of 1
  [13:33:51.628]  $ ...future.x_ii: NULL
  [13:33:51.628]  - attr(*, "where")=List of 1
  [13:33:51.628]   ..$ ...future.x_ii:<environment: 0x563b86ab8e38> 
  [13:33:51.628]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.628]  - attr(*, "resolved")= logi FALSE
  [13:33:51.628]  - attr(*, "total_size")= num 0
  [13:33:51.640]   - R expression:
  [13:33:51.640] {
  [13:33:51.640]     doFuture::registerDoFuture()
  [13:33:51.640]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.640]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.640]         {
  [13:33:51.640]             a <- NULL
  [13:33:51.640]             b <- NULL
  [13:33:51.640]         }
  [13:33:51.640]         ...future.env <- environment()
  [13:33:51.640]         local({
  [13:33:51.640]             for (name in names(...future.x_jj)) {
  [13:33:51.640]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.640]                   inherits = FALSE)
  [13:33:51.640]             }
  [13:33:51.640]         })
  [13:33:51.640]         tryCatch({
  [13:33:51.640]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.640]                 plan = future::plan())
  [13:33:51.640]         }, error = identity)
  [13:33:51.640]     })
  [13:33:51.640] }
  [13:33:51.641]   - globals: [1] '...future.x_ii'
  [13:33:51.641] List of 1
  [13:33:51.641]  $ ...future.x_ii: NULL
  [13:33:51.641]  - attr(*, "where")=List of 1
  [13:33:51.641]   ..$ ...future.x_ii:<environment: 0x563b86ab8e38> 
  [13:33:51.641]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.641]  - attr(*, "resolved")= logi FALSE
  [13:33:51.641]  - attr(*, "total_size")= num 0
  [13:33:51.648]   - packages: [1] 'doFuture'
  [13:33:51.648] - identifying globals and packages ... DONE
  [13:33:51.649] Number of chunks: 1
  [13:33:51.649] Number of futures (= number of chunks): 1
  [13:33:51.650] Launching 1 futures (chunks) ...
  [13:33:51.650] Chunk #1 of 1 ...
  [13:33:51.650]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:51.651] getGlobalsAndPackages() ...
  [13:33:51.651] Searching for globals...
  [13:33:51.652] 
  [13:33:51.653] Searching for globals ... DONE
  [13:33:51.653] - globals: [0] <none>
  [13:33:51.653] getGlobalsAndPackages() ... DONE
  [13:33:51.654] 
  [13:33:51.654] 
  [13:33:51.654]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:51.655] getGlobalsAndPackages() ...
  [13:33:51.656] - globals passed as-is: [1] '...future.x_ii'
  [13:33:51.656] Resolving globals: FALSE
  [13:33:51.657] The total size of the 1 globals is 672 bytes (672 bytes)
  [13:33:51.658] - globals: [1] '...future.x_ii'
  [13:33:51.658] 
  [13:33:51.658] getGlobalsAndPackages() ... DONE
  [13:33:51.661] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:51.661] Packages needed by future strategies (n = 1): 'future'
  [13:33:51.666] {
  [13:33:51.666]     {
  [13:33:51.666]         ...future.startTime <- Sys.time()
  [13:33:51.666]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:51.666]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:51.666]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [13:33:51.666]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:51.666]             future.resolve.recursive = NULL, width = 80L)
  [13:33:51.666]         {
  [13:33:51.666]             {
  [13:33:51.666]                 {
  [13:33:51.666]                   has_future <- requireNamespace("future", quietly = TRUE)
  [13:33:51.666]                   version <- if (has_future) 
  [13:33:51.666]                     packageVersion("future")
  [13:33:51.666]                   else NULL
  [13:33:51.666]                   if (!has_future || version < "1.8.0") {
  [13:33:51.666]                     info <- c(r_version = gsub("R version ", 
  [13:33:51.666]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:51.666]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:51.666]                       os = paste(Sys.info()[c("sysname", "release", 
  [13:33:51.666]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:51.666]                     info <- sprintf("%s: %s", names(info), info)
  [13:33:51.666]                     info <- paste(info, collapse = "; ")
  [13:33:51.666]                     if (!has_future) {
  [13:33:51.666]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:51.666]                         info)
  [13:33:51.666]                     }
  [13:33:51.666]                     else {
  [13:33:51.666]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:51.666]                         info, version)
  [13:33:51.666]                     }
  [13:33:51.666]                     stop(msg)
  [13:33:51.666]                   }
  [13:33:51.666]                 }
  [13:33:51.666]                 local({
  [13:33:51.666]                   for (pkg in c("doFuture", "future")) {
  [13:33:51.666]                     loadNamespace(pkg)
  [13:33:51.666]                     library(pkg, character.only = TRUE)
  [13:33:51.666]                   }
  [13:33:51.666]                 })
  [13:33:51.666]             }
  [13:33:51.666]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:51.666]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.666]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:51.666]                 label = NULL, ...) 
  [13:33:51.666]             {
  [13:33:51.666]                 if (substitute) 
  [13:33:51.666]                   expr <- substitute(expr)
  [13:33:51.666]                 local <- as.logical(local)
  [13:33:51.666]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.666]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.666]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.666]                   label = label, ...)
  [13:33:51.666]                 if (!future$lazy) 
  [13:33:51.666]                   future <- run(future)
  [13:33:51.666]                 invisible(future)
  [13:33:51.666]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.666]         }
  [13:33:51.666]     }
  [13:33:51.666]     if (is.na(TRUE)) {
  [13:33:51.666]     }
  [13:33:51.666]     else {
  [13:33:51.666]         if (TRUE) {
  [13:33:51.666]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:51.666]         }
  [13:33:51.666]         else {
  [13:33:51.666]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:51.666]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:51.666]         }
  [13:33:51.666]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:51.666]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:51.666]             sink(type = "output", split = FALSE)
  [13:33:51.666]             close(...future.stdout)
  [13:33:51.666]         }, add = TRUE)
  [13:33:51.666]     }
  [13:33:51.666]     ...future.frame <- sys.nframe()
  [13:33:51.666]     ...future.conditions <- list()
  [13:33:51.666]     ...future.result <- tryCatch({
  [13:33:51.666]         withCallingHandlers({
  [13:33:51.666]             ...future.value <- withVisible(local({
  [13:33:51.666]                 doFuture::registerDoFuture()
  [13:33:51.666]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.666]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.666]                   {
  [13:33:51.666]                     a <- NULL
  [13:33:51.666]                     b <- NULL
  [13:33:51.666]                   }
  [13:33:51.666]                   ...future.env <- environment()
  [13:33:51.666]                   local({
  [13:33:51.666]                     for (name in names(...future.x_jj)) {
  [13:33:51.666]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.666]                         inherits = FALSE)
  [13:33:51.666]                     }
  [13:33:51.666]                   })
  [13:33:51.666]                   tryCatch({
  [13:33:51.666]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.666]                       plan = future::plan())
  [13:33:51.666]                   }, error = identity)
  [13:33:51.666]                 })
  [13:33:51.666]             }))
  [13:33:51.666]             future::FutureResult(value = ...future.value$value, 
  [13:33:51.666]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:51.666]                 version = "1.8")
  [13:33:51.666]         }, condition = local({
  [13:33:51.666]             inherits <- base::inherits
  [13:33:51.666]             invokeRestart <- base::invokeRestart
  [13:33:51.666]             length <- base::length
  [13:33:51.666]             seq.int <- base::seq.int
  [13:33:51.666]             sys.calls <- base::sys.calls
  [13:33:51.666]             `[[` <- base::`[[`
  [13:33:51.666]             `+` <- base::`+`
  [13:33:51.666]             `<<-` <- base::`<<-`
  [13:33:51.666]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:51.666]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:51.666]                   3L)]
  [13:33:51.666]             }
  [13:33:51.666]             function(cond) {
  [13:33:51.666]                 if (inherits(cond, "error")) {
  [13:33:51.666]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.666]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:51.666]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:51.666]                     signaled = 0L)
  [13:33:51.666]                   signalCondition(cond)
  [13:33:51.666]                 }
  [13:33:51.666]                 else if (inherits(cond, c("condition", "immediateCondition"
  [13:33:51.666]                 ))) {
  [13:33:51.666]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [13:33:51.666]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.666]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:51.666]                   if (!signal) {
  [13:33:51.666]                     muffleCondition <- function (cond) 
  [13:33:51.666]                     {
  [13:33:51.666]                       inherits <- base::inherits
  [13:33:51.666]                       invokeRestart <- base::invokeRestart
  [13:33:51.666]                       muffled <- FALSE
  [13:33:51.666]                       if (inherits(cond, "message")) {
  [13:33:51.666]                         invokeRestart("muffleMessage")
  [13:33:51.666]                         muffled <- TRUE
  [13:33:51.666]                       }
  [13:33:51.666]                       else if (inherits(cond, "warning")) {
  [13:33:51.666]                         invokeRestart("muffleWarning")
  [13:33:51.666]                         muffled <- TRUE
  [13:33:51.666]                       }
  [13:33:51.666]                       else if (inherits(cond, "condition")) {
  [13:33:51.666]                         computeRestarts <- base::computeRestarts
  [13:33:51.666]                         grepl <- base::grepl
  [13:33:51.666]                         is.null <- base::is.null
  [13:33:51.666]                         restarts <- computeRestarts(cond)
  [13:33:51.666]                         for (restart in restarts) {
  [13:33:51.666]                           name <- restart$name
  [13:33:51.666]                           if (is.null(name)) 
  [13:33:51.666]                             next
  [13:33:51.666]                           if (!grepl("^muffle", name)) 
  [13:33:51.666]                             next
  [13:33:51.666]                           invokeRestart(restart)
  [13:33:51.666]                           muffled <- TRUE
  [13:33:51.666]                           break
  [13:33:51.666]                         }
  [13:33:51.666]                       }
  [13:33:51.666]                       invisible(muffled)
  [13:33:51.666]                     }
  [13:33:51.666]                     muffleCondition(cond)
  [13:33:51.666]                   }
  [13:33:51.666]                 }
  [13:33:51.666]             }
  [13:33:51.666]         }))
  [13:33:51.666]     }, error = function(ex) {
  [13:33:51.666]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:51.666]             version = "1.8"), class = "FutureResult")
  [13:33:51.666]     }, finally = {
  [13:33:51.666]         {
  [13:33:51.666]             NULL
  [13:33:51.666]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:51.666]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.666]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:51.666]                 label = NULL, ...) 
  [13:33:51.666]             {
  [13:33:51.666]                 if (substitute) 
  [13:33:51.666]                   expr <- substitute(expr)
  [13:33:51.666]                 local <- as.logical(local)
  [13:33:51.666]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.666]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.666]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.666]                   label = label, ...)
  [13:33:51.666]                 if (!future$lazy) 
  [13:33:51.666]                   future <- run(future)
  [13:33:51.666]                 invisible(future)
  [13:33:51.666]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:51.666]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:33:51.666]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:51.666]             {
  [13:33:51.666]                 if (substitute) 
  [13:33:51.666]                   expr <- substitute(expr)
  [13:33:51.666]                 local <- as.logical(local)
  [13:33:51.666]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.666]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.666]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.666]                   label = label, ...)
  [13:33:51.666]                 if (!future$lazy) 
  [13:33:51.666]                   future <- run(future)
  [13:33:51.666]                 invisible(future)
  [13:33:51.666]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.666]         }
  [13:33:51.666]         options(...future.oldOptions)
  [13:33:51.666]     })
  [13:33:51.666]     if (is.na(TRUE)) {
  [13:33:51.666]     }
  [13:33:51.666]     else {
  [13:33:51.666]         sink(type = "output", split = FALSE)
  [13:33:51.666]         if (TRUE) {
  [13:33:51.666]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:51.666]         }
  [13:33:51.666]         else {
  [13:33:51.666]             ...future.result["stdout"] <- list(NULL)
  [13:33:51.666]         }
  [13:33:51.666]         close(...future.stdout)
  [13:33:51.666]         ...future.stdout <- NULL
  [13:33:51.666]     }
  [13:33:51.666]     ...future.result$conditions <- ...future.conditions
  [13:33:51.666]     ...future.result
  [13:33:51.666] }
  [13:33:51.673] plan(): Setting new future strategy stack:
  [13:33:51.673] List of future strategies:
  [13:33:51.673] 1. sequential:
  [13:33:51.673]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.673]    - tweaked: FALSE
  [13:33:51.673]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.674] plan(): nbrOfWorkers() = 1
  [13:33:51.698] plan(): Setting new future strategy stack:
  [13:33:51.699] List of future strategies:
  [13:33:51.699] 1. sequential:
  [13:33:51.699]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.699]    - tweaked: FALSE
  [13:33:51.699]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.699] 2. sequential:
  [13:33:51.699]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.699]    - tweaked: FALSE
  [13:33:51.699]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.700] plan(): nbrOfWorkers() = 1
  [13:33:51.701] SequentialFuture started (and completed)
  [13:33:51.702] Chunk #1 of 1 ... DONE
  [13:33:51.702] Launching 1 futures (chunks) ... DONE
  [13:33:51.703] - resolving futures
  [13:33:51.703]   - gathering results & relaying conditions (except errors)
  [13:33:51.704] resolve() on list ...
  [13:33:51.704]  recursive: 0
  [13:33:51.705]  length: 1
  [13:33:51.705] 
  [13:33:51.706] Future #1
  [13:33:51.706] signalConditionsASAP(SequentialFuture, pos=1) ...
  [13:33:51.707] - nx: 1
  [13:33:51.707] - relay: TRUE
  [13:33:51.707] - stdout: TRUE
  [13:33:51.707] - signal: TRUE
  [13:33:51.708] - resignal: FALSE
  [13:33:51.708] - force: FALSE
  [13:33:51.708] - relayed: [n=1] FALSE
  [13:33:51.708] - queued futures: [n=1] FALSE
  [13:33:51.709]  - until=1
  [13:33:51.709]  - relaying element #1
  [13:33:51.709] - relayed: [n=1] TRUE
  [13:33:51.710] - queued futures: [n=1] TRUE
  [13:33:51.710] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [13:33:51.711]  length: 0 (resolved future 1)
  [13:33:51.711] Relaying remaining futures
  [13:33:51.711] signalConditionsASAP(NULL, pos=0) ...
  [13:33:51.712] - nx: 1
  [13:33:51.712] - relay: TRUE
  [13:33:51.712] - stdout: TRUE
  [13:33:51.713] - signal: TRUE
  [13:33:51.713] - resignal: FALSE
  [13:33:51.713] - force: FALSE
  [13:33:51.713] - relayed: [n=1] TRUE
  [13:33:51.714] - queued futures: [n=1] TRUE
   - flush all
  [13:33:51.714] - relayed: [n=1] TRUE
  [13:33:51.715] - queued futures: [n=1] TRUE
  [13:33:51.715] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:51.715] resolve() on list ... DONE
  [13:33:51.715] - collecting values of futures
  [13:33:51.716] - accumulating results
  [13:33:51.720] - processing errors (handler = 'stop')
  [13:33:51.721] - extracting results
  [13:33:51.721] doFuture() ... DONE
  - plan(list('sequential', 'sequential')) ... DONE
  - plan(list('sequential', 'multicore')) ...
  [13:33:51.723] plan(): Setting new future strategy stack:
  [13:33:51.723] List of future strategies:
  [13:33:51.723] 1. sequential:
  [13:33:51.723]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.723]    - tweaked: FALSE
  [13:33:51.723]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.723] 2. multicore:
  [13:33:51.723]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:51.723]    - tweaked: FALSE
  [13:33:51.723]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.725] plan(): nbrOfWorkers() = 1
  [13:33:51.725] doFuture() ...
  [13:33:51.730] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:51.731] - R expression:
  [13:33:51.731] {
  [13:33:51.731]     doFuture::registerDoFuture()
  [13:33:51.731]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.731]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.731]         {
  [13:33:51.731]             a <- NULL
  [13:33:51.731]             b <- NULL
  [13:33:51.731]         }
  [13:33:51.731]         ...future.env <- environment()
  [13:33:51.731]         local({
  [13:33:51.731]             for (name in names(...future.x_jj)) {
  [13:33:51.731]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.731]                   inherits = FALSE)
  [13:33:51.731]             }
  [13:33:51.731]         })
  [13:33:51.731]         tryCatch({
  [13:33:51.731]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.731]                 plan = future::plan())
  [13:33:51.731]         }, error = identity)
  [13:33:51.731]     })
  [13:33:51.731] }
  [13:33:51.732] - identifying globals and packages ...
  [13:33:51.733] getGlobalsAndPackages() ...
  [13:33:51.733] Searching for globals...
  [13:33:51.749] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:51.750] Searching for globals ... DONE
  [13:33:51.750] Resolving globals: FALSE
  [13:33:51.752] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:51.752] - globals: [1] '...future.x_ii'
  [13:33:51.753] 
  [13:33:51.753] getGlobalsAndPackages() ... DONE
  [13:33:51.753] List of 1
  [13:33:51.753]  $ ...future.x_ii: NULL
  [13:33:51.753]  - attr(*, "where")=List of 1
  [13:33:51.753]   ..$ ...future.x_ii:<environment: 0x563b861fca68> 
  [13:33:51.753]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.753]  - attr(*, "resolved")= logi FALSE
  [13:33:51.753]  - attr(*, "total_size")= num 0
  [13:33:51.764]   - R expression:
  [13:33:51.765] {
  [13:33:51.765]     doFuture::registerDoFuture()
  [13:33:51.765]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.765]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.765]         {
  [13:33:51.765]             a <- NULL
  [13:33:51.765]             b <- NULL
  [13:33:51.765]         }
  [13:33:51.765]         ...future.env <- environment()
  [13:33:51.765]         local({
  [13:33:51.765]             for (name in names(...future.x_jj)) {
  [13:33:51.765]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.765]                   inherits = FALSE)
  [13:33:51.765]             }
  [13:33:51.765]         })
  [13:33:51.765]         tryCatch({
  [13:33:51.765]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.765]                 plan = future::plan())
  [13:33:51.765]         }, error = identity)
  [13:33:51.765]     })
  [13:33:51.765] }
  [13:33:51.765]   - globals: [1] '...future.x_ii'
  [13:33:51.766] List of 1
  [13:33:51.766]  $ ...future.x_ii: NULL
  [13:33:51.766]  - attr(*, "where")=List of 1
  [13:33:51.766]   ..$ ...future.x_ii:<environment: 0x563b861fca68> 
  [13:33:51.766]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.766]  - attr(*, "resolved")= logi FALSE
  [13:33:51.766]  - attr(*, "total_size")= num 0
  [13:33:51.772]   - packages: [1] 'doFuture'
  [13:33:51.773] - identifying globals and packages ... DONE
  [13:33:51.773] Number of chunks: 1
  [13:33:51.773] Number of futures (= number of chunks): 1
  [13:33:51.774] Launching 1 futures (chunks) ...
  [13:33:51.774] Chunk #1 of 1 ...
  [13:33:51.774]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:51.775] getGlobalsAndPackages() ...
  [13:33:51.775] Searching for globals...
  [13:33:51.776] 
  [13:33:51.777] Searching for globals ... DONE
  [13:33:51.777] - globals: [0] <none>
  [13:33:51.777] getGlobalsAndPackages() ... DONE
  [13:33:51.778] 
  [13:33:51.778] 
  [13:33:51.778]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:51.779] getGlobalsAndPackages() ...
  [13:33:51.779] - globals passed as-is: [1] '...future.x_ii'
  [13:33:51.779] Resolving globals: FALSE
  [13:33:51.781] The total size of the 1 globals is 672 bytes (672 bytes)
  [13:33:51.781] - globals: [1] '...future.x_ii'
  [13:33:51.782] 
  [13:33:51.782] getGlobalsAndPackages() ... DONE
  [13:33:51.784] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:51.784] Packages needed by future strategies (n = 1): 'future'
  [13:33:51.789] {
  [13:33:51.789]     {
  [13:33:51.789]         ...future.startTime <- Sys.time()
  [13:33:51.789]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:51.789]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:51.789]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:51.789]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:51.789]             future.resolve.recursive = NULL, width = 80L)
  [13:33:51.789]         {
  [13:33:51.789]             {
  [13:33:51.789]                 {
  [13:33:51.789]                   has_future <- requireNamespace("future", quietly = TRUE)
  [13:33:51.789]                   version <- if (has_future) 
  [13:33:51.789]                     packageVersion("future")
  [13:33:51.789]                   else NULL
  [13:33:51.789]                   if (!has_future || version < "1.8.0") {
  [13:33:51.789]                     info <- c(r_version = gsub("R version ", 
  [13:33:51.789]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:51.789]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:51.789]                       os = paste(Sys.info()[c("sysname", "release", 
  [13:33:51.789]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:51.789]                     info <- sprintf("%s: %s", names(info), info)
  [13:33:51.789]                     info <- paste(info, collapse = "; ")
  [13:33:51.789]                     if (!has_future) {
  [13:33:51.789]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:51.789]                         info)
  [13:33:51.789]                     }
  [13:33:51.789]                     else {
  [13:33:51.789]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:51.789]                         info, version)
  [13:33:51.789]                     }
  [13:33:51.789]                     stop(msg)
  [13:33:51.789]                   }
  [13:33:51.789]                 }
  [13:33:51.789]                 local({
  [13:33:51.789]                   for (pkg in c("doFuture", "future")) {
  [13:33:51.789]                     loadNamespace(pkg)
  [13:33:51.789]                     library(pkg, character.only = TRUE)
  [13:33:51.789]                   }
  [13:33:51.789]                 })
  [13:33:51.789]             }
  [13:33:51.789]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:51.789]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.789]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:51.789]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:51.789]             {
  [13:33:51.789]                 if (substitute) 
  [13:33:51.789]                   expr <- substitute(expr)
  [13:33:51.789]                 if (is.function(workers)) 
  [13:33:51.789]                   workers <- workers()
  [13:33:51.789]                 workers <- as.integer(workers)
  [13:33:51.789]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:51.789]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:51.789]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:51.789]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:51.789]                     local = TRUE, label = label, ...))
  [13:33:51.789]                 }
  [13:33:51.789]                 oopts <- options(mc.cores = workers)
  [13:33:51.789]                 on.exit(options(oopts))
  [13:33:51.789]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:51.789]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.789]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:51.789]                   label = label, ...)
  [13:33:51.789]                 if (!future$lazy) 
  [13:33:51.789]                   future <- run(future)
  [13:33:51.789]                 invisible(future)
  [13:33:51.789]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.789]         }
  [13:33:51.789]     }
  [13:33:51.789]     if (is.na(TRUE)) {
  [13:33:51.789]     }
  [13:33:51.789]     else {
  [13:33:51.789]         if (TRUE) {
  [13:33:51.789]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:51.789]         }
  [13:33:51.789]         else {
  [13:33:51.789]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:51.789]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:51.789]         }
  [13:33:51.789]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:51.789]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:51.789]             sink(type = "output", split = FALSE)
  [13:33:51.789]             close(...future.stdout)
  [13:33:51.789]         }, add = TRUE)
  [13:33:51.789]     }
  [13:33:51.789]     ...future.frame <- sys.nframe()
  [13:33:51.789]     ...future.conditions <- list()
  [13:33:51.789]     ...future.result <- tryCatch({
  [13:33:51.789]         withCallingHandlers({
  [13:33:51.789]             ...future.value <- withVisible(local({
  [13:33:51.789]                 doFuture::registerDoFuture()
  [13:33:51.789]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.789]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.789]                   {
  [13:33:51.789]                     a <- NULL
  [13:33:51.789]                     b <- NULL
  [13:33:51.789]                   }
  [13:33:51.789]                   ...future.env <- environment()
  [13:33:51.789]                   local({
  [13:33:51.789]                     for (name in names(...future.x_jj)) {
  [13:33:51.789]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.789]                         inherits = FALSE)
  [13:33:51.789]                     }
  [13:33:51.789]                   })
  [13:33:51.789]                   tryCatch({
  [13:33:51.789]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.789]                       plan = future::plan())
  [13:33:51.789]                   }, error = identity)
  [13:33:51.789]                 })
  [13:33:51.789]             }))
  [13:33:51.789]             future::FutureResult(value = ...future.value$value, 
  [13:33:51.789]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:51.789]                 version = "1.8")
  [13:33:51.789]         }, condition = local({
  [13:33:51.789]             inherits <- base::inherits
  [13:33:51.789]             invokeRestart <- base::invokeRestart
  [13:33:51.789]             length <- base::length
  [13:33:51.789]             seq.int <- base::seq.int
  [13:33:51.789]             sys.calls <- base::sys.calls
  [13:33:51.789]             `[[` <- base::`[[`
  [13:33:51.789]             `+` <- base::`+`
  [13:33:51.789]             `<<-` <- base::`<<-`
  [13:33:51.789]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:51.789]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:51.789]                   3L)]
  [13:33:51.789]             }
  [13:33:51.789]             function(cond) {
  [13:33:51.789]                 if (inherits(cond, "error")) {
  [13:33:51.789]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.789]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:51.789]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:51.789]                     signaled = 0L)
  [13:33:51.789]                   signalCondition(cond)
  [13:33:51.789]                 }
  [13:33:51.789]                 else if (inherits(cond, c("condition", "immediateCondition"
  [13:33:51.789]                 ))) {
  [13:33:51.789]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [13:33:51.789]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.789]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:51.789]                   if (!signal) {
  [13:33:51.789]                     muffleCondition <- function (cond) 
  [13:33:51.789]                     {
  [13:33:51.789]                       inherits <- base::inherits
  [13:33:51.789]                       invokeRestart <- base::invokeRestart
  [13:33:51.789]                       muffled <- FALSE
  [13:33:51.789]                       if (inherits(cond, "message")) {
  [13:33:51.789]                         invokeRestart("muffleMessage")
  [13:33:51.789]                         muffled <- TRUE
  [13:33:51.789]                       }
  [13:33:51.789]                       else if (inherits(cond, "warning")) {
  [13:33:51.789]                         invokeRestart("muffleWarning")
  [13:33:51.789]                         muffled <- TRUE
  [13:33:51.789]                       }
  [13:33:51.789]                       else if (inherits(cond, "condition")) {
  [13:33:51.789]                         computeRestarts <- base::computeRestarts
  [13:33:51.789]                         grepl <- base::grepl
  [13:33:51.789]                         is.null <- base::is.null
  [13:33:51.789]                         restarts <- computeRestarts(cond)
  [13:33:51.789]                         for (restart in restarts) {
  [13:33:51.789]                           name <- restart$name
  [13:33:51.789]                           if (is.null(name)) 
  [13:33:51.789]                             next
  [13:33:51.789]                           if (!grepl("^muffle", name)) 
  [13:33:51.789]                             next
  [13:33:51.789]                           invokeRestart(restart)
  [13:33:51.789]                           muffled <- TRUE
  [13:33:51.789]                           break
  [13:33:51.789]                         }
  [13:33:51.789]                       }
  [13:33:51.789]                       invisible(muffled)
  [13:33:51.789]                     }
  [13:33:51.789]                     muffleCondition(cond)
  [13:33:51.789]                   }
  [13:33:51.789]                 }
  [13:33:51.789]             }
  [13:33:51.789]         }))
  [13:33:51.789]     }, error = function(ex) {
  [13:33:51.789]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:51.789]             version = "1.8"), class = "FutureResult")
  [13:33:51.789]     }, finally = {
  [13:33:51.789]         {
  [13:33:51.789]             NULL
  [13:33:51.789]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:51.789]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.789]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:51.789]                 label = NULL, ...) 
  [13:33:51.789]             {
  [13:33:51.789]                 if (substitute) 
  [13:33:51.789]                   expr <- substitute(expr)
  [13:33:51.789]                 local <- as.logical(local)
  [13:33:51.789]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.789]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.789]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.789]                   label = label, ...)
  [13:33:51.789]                 if (!future$lazy) 
  [13:33:51.789]                   future <- run(future)
  [13:33:51.789]                 invisible(future)
  [13:33:51.789]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:51.789]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:51.789]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:51.789]             {
  [13:33:51.789]                 if (substitute) 
  [13:33:51.789]                   expr <- substitute(expr)
  [13:33:51.789]                 if (is.function(workers)) 
  [13:33:51.789]                   workers <- workers()
  [13:33:51.789]                 workers <- as.integer(workers)
  [13:33:51.789]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:51.789]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:51.789]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:51.789]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:51.789]                     local = TRUE, label = label, ...))
  [13:33:51.789]                 }
  [13:33:51.789]                 oopts <- options(mc.cores = workers)
  [13:33:51.789]                 on.exit(options(oopts))
  [13:33:51.789]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:51.789]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.789]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:51.789]                   label = label, ...)
  [13:33:51.789]                 if (!future$lazy) 
  [13:33:51.789]                   future <- run(future)
  [13:33:51.789]                 invisible(future)
  [13:33:51.789]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.789]         }
  [13:33:51.789]         options(...future.oldOptions)
  [13:33:51.789]     })
  [13:33:51.789]     if (is.na(TRUE)) {
  [13:33:51.789]     }
  [13:33:51.789]     else {
  [13:33:51.789]         sink(type = "output", split = FALSE)
  [13:33:51.789]         if (TRUE) {
  [13:33:51.789]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:51.789]         }
  [13:33:51.789]         else {
  [13:33:51.789]             ...future.result["stdout"] <- list(NULL)
  [13:33:51.789]         }
  [13:33:51.789]         close(...future.stdout)
  [13:33:51.789]         ...future.stdout <- NULL
  [13:33:51.789]     }
  [13:33:51.789]     ...future.result$conditions <- ...future.conditions
  [13:33:51.789]     ...future.result
  [13:33:51.789] }
  [13:33:51.795] plan(): Setting new future strategy stack:
  [13:33:51.796] List of future strategies:
  [13:33:51.796] 1. multicore:
  [13:33:51.796]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:51.796]    - tweaked: FALSE
  [13:33:51.796]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.808] plan(): nbrOfWorkers() = 2
  [13:33:51.810] plan(): Setting new future strategy stack:
  [13:33:51.810] List of future strategies:
  [13:33:51.810] 1. sequential:
  [13:33:51.810]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.810]    - tweaked: FALSE
  [13:33:51.810]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.810] 2. multicore:
  [13:33:51.810]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:51.810]    - tweaked: FALSE
  [13:33:51.810]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.812] plan(): nbrOfWorkers() = 1
  [13:33:51.812] SequentialFuture started (and completed)
  [13:33:51.813] Chunk #1 of 1 ... DONE
  [13:33:51.813] Launching 1 futures (chunks) ... DONE
  [13:33:51.813] - resolving futures
  [13:33:51.814]   - gathering results & relaying conditions (except errors)
  [13:33:51.814] resolve() on list ...
  [13:33:51.814]  recursive: 0
  [13:33:51.815]  length: 1
  [13:33:51.815] 
  [13:33:51.815] Future #1
  [13:33:51.816] signalConditionsASAP(SequentialFuture, pos=1) ...
  [13:33:51.816] - nx: 1
  [13:33:51.816] - relay: TRUE
  [13:33:51.816] - stdout: TRUE
  [13:33:51.817] - signal: TRUE
  [13:33:51.817] - resignal: FALSE
  [13:33:51.817] - force: FALSE
  [13:33:51.818] - relayed: [n=1] FALSE
  [13:33:51.818] - queued futures: [n=1] FALSE
  [13:33:51.818]  - until=1
  [13:33:51.819]  - relaying element #1
  [13:33:51.819] - relayed: [n=1] TRUE
  [13:33:51.819] - queued futures: [n=1] TRUE
  [13:33:51.820] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [13:33:51.820]  length: 0 (resolved future 1)
  [13:33:51.820] Relaying remaining futures
  [13:33:51.821] signalConditionsASAP(NULL, pos=0) ...
  [13:33:51.821] - nx: 1
  [13:33:51.821] - relay: TRUE
  [13:33:51.821] - stdout: TRUE
  [13:33:51.822] - signal: TRUE
  [13:33:51.822] - resignal: FALSE
  [13:33:51.822] - force: FALSE
  [13:33:51.823] - relayed: [n=1] TRUE
  [13:33:51.823] - queued futures: [n=1] TRUE
   - flush all
  [13:33:51.823] - relayed: [n=1] TRUE
  [13:33:51.824] - queued futures: [n=1] TRUE
  [13:33:51.824] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:51.824] resolve() on list ... DONE
  [13:33:51.824] - collecting values of futures
  [13:33:51.825] - accumulating results
  [13:33:51.827] - processing errors (handler = 'stop')
  [13:33:51.828] - extracting results
  [13:33:51.828] doFuture() ... DONE
  - plan(list('sequential', 'multicore')) ... DONE
  - plan(list('sequential', 'multisession')) ...
  [13:33:51.830] plan(): Setting new future strategy stack:
  [13:33:51.830] List of future strategies:
  [13:33:51.830] 1. sequential:
  [13:33:51.830]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.830]    - tweaked: FALSE
  [13:33:51.830]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.830] 2. multisession:
  [13:33:51.830]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.830]    - tweaked: FALSE
  [13:33:51.830]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.832] plan(): nbrOfWorkers() = 1
  [13:33:51.832] doFuture() ...
  [13:33:51.837] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:51.838] - R expression:
  [13:33:51.838] {
  [13:33:51.838]     doFuture::registerDoFuture()
  [13:33:51.838]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.838]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.838]         {
  [13:33:51.838]             a <- NULL
  [13:33:51.838]             b <- NULL
  [13:33:51.838]         }
  [13:33:51.838]         ...future.env <- environment()
  [13:33:51.838]         local({
  [13:33:51.838]             for (name in names(...future.x_jj)) {
  [13:33:51.838]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.838]                   inherits = FALSE)
  [13:33:51.838]             }
  [13:33:51.838]         })
  [13:33:51.838]         tryCatch({
  [13:33:51.838]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.838]                 plan = future::plan())
  [13:33:51.838]         }, error = identity)
  [13:33:51.838]     })
  [13:33:51.838] }
  [13:33:51.839] - identifying globals and packages ...
  [13:33:51.839] getGlobalsAndPackages() ...
  [13:33:51.840] Searching for globals...
  [13:33:51.859] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:51.860] Searching for globals ... DONE
  [13:33:51.860] Resolving globals: FALSE
  [13:33:51.862] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:51.862] - globals: [1] '...future.x_ii'
  [13:33:51.863] 
  [13:33:51.863] getGlobalsAndPackages() ... DONE
  [13:33:51.863] List of 1
  [13:33:51.863]  $ ...future.x_ii: NULL
  [13:33:51.863]  - attr(*, "where")=List of 1
  [13:33:51.863]   ..$ ...future.x_ii:<environment: 0x563b865c51e0> 
  [13:33:51.863]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.863]  - attr(*, "resolved")= logi FALSE
  [13:33:51.863]  - attr(*, "total_size")= num 0
  [13:33:51.870]   - R expression:
  [13:33:51.870] {
  [13:33:51.870]     doFuture::registerDoFuture()
  [13:33:51.870]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.870]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.870]         {
  [13:33:51.870]             a <- NULL
  [13:33:51.870]             b <- NULL
  [13:33:51.870]         }
  [13:33:51.870]         ...future.env <- environment()
  [13:33:51.870]         local({
  [13:33:51.870]             for (name in names(...future.x_jj)) {
  [13:33:51.870]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.870]                   inherits = FALSE)
  [13:33:51.870]             }
  [13:33:51.870]         })
  [13:33:51.870]         tryCatch({
  [13:33:51.870]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.870]                 plan = future::plan())
  [13:33:51.870]         }, error = identity)
  [13:33:51.870]     })
  [13:33:51.870] }
  [13:33:51.871]   - globals: [1] '...future.x_ii'
  [13:33:51.871] List of 1
  [13:33:51.871]  $ ...future.x_ii: NULL
  [13:33:51.871]  - attr(*, "where")=List of 1
  [13:33:51.871]   ..$ ...future.x_ii:<environment: 0x563b865c51e0> 
  [13:33:51.871]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.871]  - attr(*, "resolved")= logi FALSE
  [13:33:51.871]  - attr(*, "total_size")= num 0
  [13:33:51.877]   - packages: [1] 'doFuture'
  [13:33:51.878] - identifying globals and packages ... DONE
  [13:33:51.878] Number of chunks: 1
  [13:33:51.878] Number of futures (= number of chunks): 1
  [13:33:51.879] Launching 1 futures (chunks) ...
  [13:33:51.879] Chunk #1 of 1 ...
  [13:33:51.879]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:51.880] getGlobalsAndPackages() ...
  [13:33:51.880] Searching for globals...
  [13:33:51.881] 
  [13:33:51.881] Searching for globals ... DONE
  [13:33:51.882] - globals: [0] <none>
  [13:33:51.882] getGlobalsAndPackages() ... DONE
  [13:33:51.882] 
  [13:33:51.883] 
  [13:33:51.883]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:51.883] getGlobalsAndPackages() ...
  [13:33:51.884] - globals passed as-is: [1] '...future.x_ii'
  [13:33:51.884] Resolving globals: FALSE
  [13:33:51.885] The total size of the 1 globals is 672 bytes (672 bytes)
  [13:33:51.886] - globals: [1] '...future.x_ii'
  [13:33:51.886] 
  [13:33:51.886] getGlobalsAndPackages() ... DONE
  [13:33:51.888] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:51.889] Packages needed by future strategies (n = 1): 'future'
  [13:33:51.893] {
  [13:33:51.893]     {
  [13:33:51.893]         ...future.startTime <- Sys.time()
  [13:33:51.893]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:51.893]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:51.893]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:51.893]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:51.893]             future.resolve.recursive = NULL, width = 80L)
  [13:33:51.893]         {
  [13:33:51.893]             {
  [13:33:51.893]                 {
  [13:33:51.893]                   has_future <- requireNamespace("future", quietly = TRUE)
  [13:33:51.893]                   version <- if (has_future) 
  [13:33:51.893]                     packageVersion("future")
  [13:33:51.893]                   else NULL
  [13:33:51.893]                   if (!has_future || version < "1.8.0") {
  [13:33:51.893]                     info <- c(r_version = gsub("R version ", 
  [13:33:51.893]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:51.893]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:51.893]                       os = paste(Sys.info()[c("sysname", "release", 
  [13:33:51.893]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:51.893]                     info <- sprintf("%s: %s", names(info), info)
  [13:33:51.893]                     info <- paste(info, collapse = "; ")
  [13:33:51.893]                     if (!has_future) {
  [13:33:51.893]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:51.893]                         info)
  [13:33:51.893]                     }
  [13:33:51.893]                     else {
  [13:33:51.893]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:51.893]                         info, version)
  [13:33:51.893]                     }
  [13:33:51.893]                     stop(msg)
  [13:33:51.893]                   }
  [13:33:51.893]                 }
  [13:33:51.893]                 local({
  [13:33:51.893]                   for (pkg in c("doFuture", "future")) {
  [13:33:51.893]                     loadNamespace(pkg)
  [13:33:51.893]                     library(pkg, character.only = TRUE)
  [13:33:51.893]                   }
  [13:33:51.893]                 })
  [13:33:51.893]             }
  [13:33:51.893]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:51.893]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.893]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:33:51.893]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:51.893]                 ...) 
  [13:33:51.893]             {
  [13:33:51.893]                 if (substitute) 
  [13:33:51.893]                   expr <- substitute(expr)
  [13:33:51.893]                 if (is.function(workers)) 
  [13:33:51.893]                   workers <- workers()
  [13:33:51.893]                 workers <- as.integer(workers)
  [13:33:51.893]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:51.893]                   workers >= 1)
  [13:33:51.893]                 if (workers == 1L) {
  [13:33:51.893]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:51.893]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:51.893]                     local = TRUE, label = label, ...))
  [13:33:51.893]                 }
  [13:33:51.893]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:51.893]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:51.893]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.893]                   globals = globals, persistent = persistent, 
  [13:33:51.893]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:51.893]                   label = label, ...)
  [13:33:51.893]                 if (!future$lazy) 
  [13:33:51.893]                   future <- run(future)
  [13:33:51.893]                 invisible(future)
  [13:33:51.893]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.893]         }
  [13:33:51.893]     }
  [13:33:51.893]     if (is.na(TRUE)) {
  [13:33:51.893]     }
  [13:33:51.893]     else {
  [13:33:51.893]         if (TRUE) {
  [13:33:51.893]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:51.893]         }
  [13:33:51.893]         else {
  [13:33:51.893]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:51.893]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:51.893]         }
  [13:33:51.893]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:51.893]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:51.893]             sink(type = "output", split = FALSE)
  [13:33:51.893]             close(...future.stdout)
  [13:33:51.893]         }, add = TRUE)
  [13:33:51.893]     }
  [13:33:51.893]     ...future.frame <- sys.nframe()
  [13:33:51.893]     ...future.conditions <- list()
  [13:33:51.893]     ...future.result <- tryCatch({
  [13:33:51.893]         withCallingHandlers({
  [13:33:51.893]             ...future.value <- withVisible(local({
  [13:33:51.893]                 doFuture::registerDoFuture()
  [13:33:51.893]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.893]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.893]                   {
  [13:33:51.893]                     a <- NULL
  [13:33:51.893]                     b <- NULL
  [13:33:51.893]                   }
  [13:33:51.893]                   ...future.env <- environment()
  [13:33:51.893]                   local({
  [13:33:51.893]                     for (name in names(...future.x_jj)) {
  [13:33:51.893]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.893]                         inherits = FALSE)
  [13:33:51.893]                     }
  [13:33:51.893]                   })
  [13:33:51.893]                   tryCatch({
  [13:33:51.893]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.893]                       plan = future::plan())
  [13:33:51.893]                   }, error = identity)
  [13:33:51.893]                 })
  [13:33:51.893]             }))
  [13:33:51.893]             future::FutureResult(value = ...future.value$value, 
  [13:33:51.893]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:51.893]                 version = "1.8")
  [13:33:51.893]         }, condition = local({
  [13:33:51.893]             inherits <- base::inherits
  [13:33:51.893]             invokeRestart <- base::invokeRestart
  [13:33:51.893]             length <- base::length
  [13:33:51.893]             seq.int <- base::seq.int
  [13:33:51.893]             sys.calls <- base::sys.calls
  [13:33:51.893]             `[[` <- base::`[[`
  [13:33:51.893]             `+` <- base::`+`
  [13:33:51.893]             `<<-` <- base::`<<-`
  [13:33:51.893]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:51.893]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:51.893]                   3L)]
  [13:33:51.893]             }
  [13:33:51.893]             function(cond) {
  [13:33:51.893]                 if (inherits(cond, "error")) {
  [13:33:51.893]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.893]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:51.893]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:51.893]                     signaled = 0L)
  [13:33:51.893]                   signalCondition(cond)
  [13:33:51.893]                 }
  [13:33:51.893]                 else if (inherits(cond, c("condition", "immediateCondition"
  [13:33:51.893]                 ))) {
  [13:33:51.893]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [13:33:51.893]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.893]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:51.893]                   if (!signal) {
  [13:33:51.893]                     muffleCondition <- function (cond) 
  [13:33:51.893]                     {
  [13:33:51.893]                       inherits <- base::inherits
  [13:33:51.893]                       invokeRestart <- base::invokeRestart
  [13:33:51.893]                       muffled <- FALSE
  [13:33:51.893]                       if (inherits(cond, "message")) {
  [13:33:51.893]                         invokeRestart("muffleMessage")
  [13:33:51.893]                         muffled <- TRUE
  [13:33:51.893]                       }
  [13:33:51.893]                       else if (inherits(cond, "warning")) {
  [13:33:51.893]                         invokeRestart("muffleWarning")
  [13:33:51.893]                         muffled <- TRUE
  [13:33:51.893]                       }
  [13:33:51.893]                       else if (inherits(cond, "condition")) {
  [13:33:51.893]                         computeRestarts <- base::computeRestarts
  [13:33:51.893]                         grepl <- base::grepl
  [13:33:51.893]                         is.null <- base::is.null
  [13:33:51.893]                         restarts <- computeRestarts(cond)
  [13:33:51.893]                         for (restart in restarts) {
  [13:33:51.893]                           name <- restart$name
  [13:33:51.893]                           if (is.null(name)) 
  [13:33:51.893]                             next
  [13:33:51.893]                           if (!grepl("^muffle", name)) 
  [13:33:51.893]                             next
  [13:33:51.893]                           invokeRestart(restart)
  [13:33:51.893]                           muffled <- TRUE
  [13:33:51.893]                           break
  [13:33:51.893]                         }
  [13:33:51.893]                       }
  [13:33:51.893]                       invisible(muffled)
  [13:33:51.893]                     }
  [13:33:51.893]                     muffleCondition(cond)
  [13:33:51.893]                   }
  [13:33:51.893]                 }
  [13:33:51.893]             }
  [13:33:51.893]         }))
  [13:33:51.893]     }, error = function(ex) {
  [13:33:51.893]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:51.893]             version = "1.8"), class = "FutureResult")
  [13:33:51.893]     }, finally = {
  [13:33:51.893]         {
  [13:33:51.893]             NULL
  [13:33:51.893]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:51.893]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.893]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:51.893]                 label = NULL, ...) 
  [13:33:51.893]             {
  [13:33:51.893]                 if (substitute) 
  [13:33:51.893]                   expr <- substitute(expr)
  [13:33:51.893]                 local <- as.logical(local)
  [13:33:51.893]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.893]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.893]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.893]                   label = label, ...)
  [13:33:51.893]                 if (!future$lazy) 
  [13:33:51.893]                   future <- run(future)
  [13:33:51.893]                 invisible(future)
  [13:33:51.893]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:51.893]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:51.893]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:33:51.893]                 label = NULL, ...) 
  [13:33:51.893]             {
  [13:33:51.893]                 if (substitute) 
  [13:33:51.893]                   expr <- substitute(expr)
  [13:33:51.893]                 if (is.function(workers)) 
  [13:33:51.893]                   workers <- workers()
  [13:33:51.893]                 workers <- as.integer(workers)
  [13:33:51.893]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:51.893]                   workers >= 1)
  [13:33:51.893]                 if (workers == 1L) {
  [13:33:51.893]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:51.893]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:51.893]                     local = TRUE, label = label, ...))
  [13:33:51.893]                 }
  [13:33:51.893]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:51.893]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:51.893]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.893]                   globals = globals, persistent = persistent, 
  [13:33:51.893]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:51.893]                   label = label, ...)
  [13:33:51.893]                 if (!future$lazy) 
  [13:33:51.893]                   future <- run(future)
  [13:33:51.893]                 invisible(future)
  [13:33:51.893]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.893]         }
  [13:33:51.893]         options(...future.oldOptions)
  [13:33:51.893]     })
  [13:33:51.893]     if (is.na(TRUE)) {
  [13:33:51.893]     }
  [13:33:51.893]     else {
  [13:33:51.893]         sink(type = "output", split = FALSE)
  [13:33:51.893]         if (TRUE) {
  [13:33:51.893]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:51.893]         }
  [13:33:51.893]         else {
  [13:33:51.893]             ...future.result["stdout"] <- list(NULL)
  [13:33:51.893]         }
  [13:33:51.893]         close(...future.stdout)
  [13:33:51.893]         ...future.stdout <- NULL
  [13:33:51.893]     }
  [13:33:51.893]     ...future.result$conditions <- ...future.conditions
  [13:33:51.893]     ...future.result
  [13:33:51.893] }
  [13:33:51.900] plan(): Setting new future strategy stack:
  [13:33:51.900] List of future strategies:
  [13:33:51.900] 1. multisession:
  [13:33:51.900]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.900]    - tweaked: FALSE
  [13:33:51.900]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.902] plan(): nbrOfWorkers() = 2
  [13:33:51.904] plan(): Setting new future strategy stack:
  [13:33:51.904] List of future strategies:
  [13:33:51.904] 1. sequential:
  [13:33:51.904]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.904]    - tweaked: FALSE
  [13:33:51.904]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.904] 2. multisession:
  [13:33:51.904]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.904]    - tweaked: FALSE
  [13:33:51.904]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.906] plan(): nbrOfWorkers() = 1
  [13:33:51.906] SequentialFuture started (and completed)
  [13:33:51.907] Chunk #1 of 1 ... DONE
  [13:33:51.907] Launching 1 futures (chunks) ... DONE
  [13:33:51.907] - resolving futures
  [13:33:51.908]   - gathering results & relaying conditions (except errors)
  [13:33:51.908] resolve() on list ...
  [13:33:51.908]  recursive: 0
  [13:33:51.909]  length: 1
  [13:33:51.909] 
  [13:33:51.909] Future #1
  [13:33:51.910] signalConditionsASAP(SequentialFuture, pos=1) ...
  [13:33:51.910] - nx: 1
  [13:33:51.910] - relay: TRUE
  [13:33:51.911] - stdout: TRUE
  [13:33:51.911] - signal: TRUE
  [13:33:51.911] - resignal: FALSE
  [13:33:51.911] - force: FALSE
  [13:33:51.912] - relayed: [n=1] FALSE
  [13:33:51.912] - queued futures: [n=1] FALSE
  [13:33:51.912]  - until=1
  [13:33:51.913]  - relaying element #1
  [13:33:51.913] - relayed: [n=1] TRUE
  [13:33:51.913] - queued futures: [n=1] TRUE
  [13:33:51.914] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [13:33:51.914]  length: 0 (resolved future 1)
  [13:33:51.914] Relaying remaining futures
  [13:33:51.915] signalConditionsASAP(NULL, pos=0) ...
  [13:33:51.915] - nx: 1
  [13:33:51.915] - relay: TRUE
  [13:33:51.916] - stdout: TRUE
  [13:33:51.916] - signal: TRUE
  [13:33:51.916] - resignal: FALSE
  [13:33:51.916] - force: FALSE
  [13:33:51.917] - relayed: [n=1] TRUE
  [13:33:51.917] - queued futures: [n=1] TRUE
   - flush all
  [13:33:51.918] - relayed: [n=1] TRUE
  [13:33:51.918] - queued futures: [n=1] TRUE
  [13:33:51.918] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:51.918] resolve() on list ... DONE
  [13:33:51.919] - collecting values of futures
  [13:33:51.919] - accumulating results
  [13:33:51.927] - processing errors (handler = 'stop')
  [13:33:51.927] - extracting results
  [13:33:51.928] doFuture() ... DONE
  - plan(list('sequential', 'multisession')) ... DONE
  - plan(list('sequential', 'cluster')) ...
  [13:33:51.929] plan(): Setting new future strategy stack:
  [13:33:51.929] List of future strategies:
  [13:33:51.929] 1. sequential:
  [13:33:51.929]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:51.929]    - tweaked: FALSE
  [13:33:51.929]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.929] 2. cluster:
  [13:33:51.929]    - 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, ...)
  [13:33:51.929]    - tweaked: FALSE
  [13:33:51.929]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:51.931] plan(): nbrOfWorkers() = 1
  [13:33:51.932] doFuture() ...
  [13:33:51.936] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:51.937] - R expression:
  [13:33:51.937] {
  [13:33:51.937]     doFuture::registerDoFuture()
  [13:33:51.937]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.937]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.937]         {
  [13:33:51.937]             a <- NULL
  [13:33:51.937]             b <- NULL
  [13:33:51.937]         }
  [13:33:51.937]         ...future.env <- environment()
  [13:33:51.937]         local({
  [13:33:51.937]             for (name in names(...future.x_jj)) {
  [13:33:51.937]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.937]                   inherits = FALSE)
  [13:33:51.937]             }
  [13:33:51.937]         })
  [13:33:51.937]         tryCatch({
  [13:33:51.937]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.937]                 plan = future::plan())
  [13:33:51.937]         }, error = identity)
  [13:33:51.937]     })
  [13:33:51.937] }
  [13:33:51.938] - identifying globals and packages ...
  [13:33:51.939] getGlobalsAndPackages() ...
  [13:33:51.939] Searching for globals...
  [13:33:51.954] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:51.955] Searching for globals ... DONE
  [13:33:51.955] Resolving globals: FALSE
  [13:33:51.957] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:51.957] - globals: [1] '...future.x_ii'
  [13:33:51.957] 
  [13:33:51.958] getGlobalsAndPackages() ... DONE
  [13:33:51.958] List of 1
  [13:33:51.958]  $ ...future.x_ii: NULL
  [13:33:51.958]  - attr(*, "where")=List of 1
  [13:33:51.958]   ..$ ...future.x_ii:<environment: 0x563b84374748> 
  [13:33:51.958]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.958]  - attr(*, "resolved")= logi FALSE
  [13:33:51.958]  - attr(*, "total_size")= num 0
  [13:33:51.964]   - R expression:
  [13:33:51.965] {
  [13:33:51.965]     doFuture::registerDoFuture()
  [13:33:51.965]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.965]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.965]         {
  [13:33:51.965]             a <- NULL
  [13:33:51.965]             b <- NULL
  [13:33:51.965]         }
  [13:33:51.965]         ...future.env <- environment()
  [13:33:51.965]         local({
  [13:33:51.965]             for (name in names(...future.x_jj)) {
  [13:33:51.965]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.965]                   inherits = FALSE)
  [13:33:51.965]             }
  [13:33:51.965]         })
  [13:33:51.965]         tryCatch({
  [13:33:51.965]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.965]                 plan = future::plan())
  [13:33:51.965]         }, error = identity)
  [13:33:51.965]     })
  [13:33:51.965] }
  [13:33:51.965]   - globals: [1] '...future.x_ii'
  [13:33:51.966] List of 1
  [13:33:51.966]  $ ...future.x_ii: NULL
  [13:33:51.966]  - attr(*, "where")=List of 1
  [13:33:51.966]   ..$ ...future.x_ii:<environment: 0x563b84374748> 
  [13:33:51.966]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:51.966]  - attr(*, "resolved")= logi FALSE
  [13:33:51.966]  - attr(*, "total_size")= num 0
  [13:33:51.972]   - packages: [1] 'doFuture'
  [13:33:51.972] - identifying globals and packages ... DONE
  [13:33:51.973] Number of chunks: 1
  [13:33:51.973] Number of futures (= number of chunks): 1
  [13:33:51.973] Launching 1 futures (chunks) ...
  [13:33:51.974] Chunk #1 of 1 ...
  [13:33:51.974]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:51.974] getGlobalsAndPackages() ...
  [13:33:51.974] Searching for globals...
  [13:33:51.976] 
  [13:33:51.976] Searching for globals ... DONE
  [13:33:51.976] - globals: [0] <none>
  [13:33:51.977] getGlobalsAndPackages() ... DONE
  [13:33:51.977] 
  [13:33:51.977] 
  [13:33:51.978]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:51.978] getGlobalsAndPackages() ...
  [13:33:51.978] - globals passed as-is: [1] '...future.x_ii'
  [13:33:51.979] Resolving globals: FALSE
  [13:33:51.980] The total size of the 1 globals is 672 bytes (672 bytes)
  [13:33:51.980] - globals: [1] '...future.x_ii'
  [13:33:51.981] 
  [13:33:51.981] getGlobalsAndPackages() ... DONE
  [13:33:51.982] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:51.983] Packages needed by future strategies (n = 1): 'future'
  [13:33:51.991] {
  [13:33:51.991]     {
  [13:33:51.991]         ...future.startTime <- Sys.time()
  [13:33:51.991]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:51.991]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:51.991]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:51.991]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:51.991]             future.resolve.recursive = NULL, width = 80L)
  [13:33:51.991]         {
  [13:33:51.991]             {
  [13:33:51.991]                 {
  [13:33:51.991]                   has_future <- requireNamespace("future", quietly = TRUE)
  [13:33:51.991]                   version <- if (has_future) 
  [13:33:51.991]                     packageVersion("future")
  [13:33:51.991]                   else NULL
  [13:33:51.991]                   if (!has_future || version < "1.8.0") {
  [13:33:51.991]                     info <- c(r_version = gsub("R version ", 
  [13:33:51.991]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:51.991]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:51.991]                       os = paste(Sys.info()[c("sysname", "release", 
  [13:33:51.991]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:51.991]                     info <- sprintf("%s: %s", names(info), info)
  [13:33:51.991]                     info <- paste(info, collapse = "; ")
  [13:33:51.991]                     if (!has_future) {
  [13:33:51.991]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:51.991]                         info)
  [13:33:51.991]                     }
  [13:33:51.991]                     else {
  [13:33:51.991]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:51.991]                         info, version)
  [13:33:51.991]                     }
  [13:33:51.991]                     stop(msg)
  [13:33:51.991]                   }
  [13:33:51.991]                 }
  [13:33:51.991]                 local({
  [13:33:51.991]                   for (pkg in c("doFuture", "future")) {
  [13:33:51.991]                     loadNamespace(pkg)
  [13:33:51.991]                     library(pkg, character.only = TRUE)
  [13:33:51.991]                   }
  [13:33:51.991]                 })
  [13:33:51.991]             }
  [13:33:51.991]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:51.991]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.991]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:33:51.991]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:33:51.991]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:51.991]                 ...) 
  [13:33:51.991]             {
  [13:33:51.991]                 if (substitute) 
  [13:33:51.991]                   expr <- substitute(expr)
  [13:33:51.991]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:51.991]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.991]                   globals = globals, persistent = persistent, 
  [13:33:51.991]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:51.991]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:51.991]                   label = label, ...)
  [13:33:51.991]                 if (!future$lazy) 
  [13:33:51.991]                   future <- run(future)
  [13:33:51.991]                 invisible(future)
  [13:33:51.991]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.991]         }
  [13:33:51.991]     }
  [13:33:51.991]     if (is.na(TRUE)) {
  [13:33:51.991]     }
  [13:33:51.991]     else {
  [13:33:51.991]         if (TRUE) {
  [13:33:51.991]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:51.991]         }
  [13:33:51.991]         else {
  [13:33:51.991]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:51.991]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:51.991]         }
  [13:33:51.991]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:51.991]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:51.991]             sink(type = "output", split = FALSE)
  [13:33:51.991]             close(...future.stdout)
  [13:33:51.991]         }, add = TRUE)
  [13:33:51.991]     }
  [13:33:51.991]     ...future.frame <- sys.nframe()
  [13:33:51.991]     ...future.conditions <- list()
  [13:33:51.991]     ...future.result <- tryCatch({
  [13:33:51.991]         withCallingHandlers({
  [13:33:51.991]             ...future.value <- withVisible(local({
  [13:33:51.991]                 doFuture::registerDoFuture()
  [13:33:51.991]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:51.991]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:51.991]                   {
  [13:33:51.991]                     a <- NULL
  [13:33:51.991]                     b <- NULL
  [13:33:51.991]                   }
  [13:33:51.991]                   ...future.env <- environment()
  [13:33:51.991]                   local({
  [13:33:51.991]                     for (name in names(...future.x_jj)) {
  [13:33:51.991]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:51.991]                         inherits = FALSE)
  [13:33:51.991]                     }
  [13:33:51.991]                   })
  [13:33:51.991]                   tryCatch({
  [13:33:51.991]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:51.991]                       plan = future::plan())
  [13:33:51.991]                   }, error = identity)
  [13:33:51.991]                 })
  [13:33:51.991]             }))
  [13:33:51.991]             future::FutureResult(value = ...future.value$value, 
  [13:33:51.991]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:51.991]                 version = "1.8")
  [13:33:51.991]         }, condition = local({
  [13:33:51.991]             inherits <- base::inherits
  [13:33:51.991]             invokeRestart <- base::invokeRestart
  [13:33:51.991]             length <- base::length
  [13:33:51.991]             seq.int <- base::seq.int
  [13:33:51.991]             sys.calls <- base::sys.calls
  [13:33:51.991]             `[[` <- base::`[[`
  [13:33:51.991]             `+` <- base::`+`
  [13:33:51.991]             `<<-` <- base::`<<-`
  [13:33:51.991]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:51.991]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:51.991]                   3L)]
  [13:33:51.991]             }
  [13:33:51.991]             function(cond) {
  [13:33:51.991]                 if (inherits(cond, "error")) {
  [13:33:51.991]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.991]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:51.991]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:51.991]                     signaled = 0L)
  [13:33:51.991]                   signalCondition(cond)
  [13:33:51.991]                 }
  [13:33:51.991]                 else if (inherits(cond, c("condition", "immediateCondition"
  [13:33:51.991]                 ))) {
  [13:33:51.991]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [13:33:51.991]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:51.991]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:51.991]                   if (!signal) {
  [13:33:51.991]                     muffleCondition <- function (cond) 
  [13:33:51.991]                     {
  [13:33:51.991]                       inherits <- base::inherits
  [13:33:51.991]                       invokeRestart <- base::invokeRestart
  [13:33:51.991]                       muffled <- FALSE
  [13:33:51.991]                       if (inherits(cond, "message")) {
  [13:33:51.991]                         invokeRestart("muffleMessage")
  [13:33:51.991]                         muffled <- TRUE
  [13:33:51.991]                       }
  [13:33:51.991]                       else if (inherits(cond, "warning")) {
  [13:33:51.991]                         invokeRestart("muffleWarning")
  [13:33:51.991]                         muffled <- TRUE
  [13:33:51.991]                       }
  [13:33:51.991]                       else if (inherits(cond, "condition")) {
  [13:33:51.991]                         computeRestarts <- base::computeRestarts
  [13:33:51.991]                         grepl <- base::grepl
  [13:33:51.991]                         is.null <- base::is.null
  [13:33:51.991]                         restarts <- computeRestarts(cond)
  [13:33:51.991]                         for (restart in restarts) {
  [13:33:51.991]                           name <- restart$name
  [13:33:51.991]                           if (is.null(name)) 
  [13:33:51.991]                             next
  [13:33:51.991]                           if (!grepl("^muffle", name)) 
  [13:33:51.991]                             next
  [13:33:51.991]                           invokeRestart(restart)
  [13:33:51.991]                           muffled <- TRUE
  [13:33:51.991]                           break
  [13:33:51.991]                         }
  [13:33:51.991]                       }
  [13:33:51.991]                       invisible(muffled)
  [13:33:51.991]                     }
  [13:33:51.991]                     muffleCondition(cond)
  [13:33:51.991]                   }
  [13:33:51.991]                 }
  [13:33:51.991]             }
  [13:33:51.991]         }))
  [13:33:51.991]     }, error = function(ex) {
  [13:33:51.991]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:51.991]             version = "1.8"), class = "FutureResult")
  [13:33:51.991]     }, finally = {
  [13:33:51.991]         {
  [13:33:51.991]             NULL
  [13:33:51.991]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:51.991]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:51.991]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:51.991]                 label = NULL, ...) 
  [13:33:51.991]             {
  [13:33:51.991]                 if (substitute) 
  [13:33:51.991]                   expr <- substitute(expr)
  [13:33:51.991]                 local <- as.logical(local)
  [13:33:51.991]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:51.991]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.991]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:51.991]                   label = label, ...)
  [13:33:51.991]                 if (!future$lazy) 
  [13:33:51.991]                   future <- run(future)
  [13:33:51.991]                 invisible(future)
  [13:33:51.991]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:51.991]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:51.991]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:33:51.991]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:33:51.991]                 label = NULL, ...) 
  [13:33:51.991]             {
  [13:33:51.991]                 if (substitute) 
  [13:33:51.991]                   expr <- substitute(expr)
  [13:33:51.991]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:51.991]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:51.991]                   globals = globals, persistent = persistent, 
  [13:33:51.991]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:51.991]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:51.991]                   label = label, ...)
  [13:33:51.991]                 if (!future$lazy) 
  [13:33:51.991]                   future <- run(future)
  [13:33:51.991]                 invisible(future)
  [13:33:51.991]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:51.991]         }
  [13:33:51.991]         options(...future.oldOptions)
  [13:33:51.991]     })
  [13:33:51.991]     if (is.na(TRUE)) {
  [13:33:51.991]     }
  [13:33:51.991]     else {
  [13:33:51.991]         sink(type = "output", split = FALSE)
  [13:33:51.991]         if (TRUE) {
  [13:33:51.991]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:51.991]         }
  [13:33:51.991]         else {
  [13:33:51.991]             ...future.result["stdout"] <- list(NULL)
  [13:33:51.991]         }
  [13:33:51.991]         close(...future.stdout)
  [13:33:51.991]         ...future.stdout <- NULL
  [13:33:51.991]     }
  [13:33:51.991]     ...future.result$conditions <- ...future.conditions
  [13:33:51.991]     ...future.result
  [13:33:51.991] }
  [13:33:51.998] plan(): Setting new future strategy stack:
  [13:33:51.998] List of future strategies:
  [13:33:51.998] 1. cluster:
  [13:33:51.998]    - 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, ...)
  [13:33:51.998]    - tweaked: FALSE
  [13:33:51.998]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.001] plan(): nbrOfWorkers() = 2
  [13:33:52.004] plan(): Setting new future strategy stack:
  [13:33:52.004] List of future strategies:
  [13:33:52.004] 1. sequential:
  [13:33:52.004]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.004]    - tweaked: FALSE
  [13:33:52.004]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.004] 2. cluster:
  [13:33:52.004]    - 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, ...)
  [13:33:52.004]    - tweaked: FALSE
  [13:33:52.004]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.006] plan(): nbrOfWorkers() = 1
  [13:33:52.006] SequentialFuture started (and completed)
  [13:33:52.007] Chunk #1 of 1 ... DONE
  [13:33:52.007] Launching 1 futures (chunks) ... DONE
  [13:33:52.007] - resolving futures
  [13:33:52.007]   - gathering results & relaying conditions (except errors)
  [13:33:52.008] resolve() on list ...
  [13:33:52.008]  recursive: 0
  [13:33:52.008]  length: 1
  [13:33:52.008] 
  [13:33:52.009] Future #1
  [13:33:52.009] signalConditionsASAP(SequentialFuture, pos=1) ...
  [13:33:52.010] - nx: 1
  [13:33:52.010] - relay: TRUE
  [13:33:52.010] - stdout: TRUE
  [13:33:52.010] - signal: TRUE
  [13:33:52.011] - resignal: FALSE
  [13:33:52.011] - force: FALSE
  [13:33:52.011] - relayed: [n=1] FALSE
  [13:33:52.011] - queued futures: [n=1] FALSE
  [13:33:52.012]  - until=1
  [13:33:52.012]  - relaying element #1
  [13:33:52.013] - relayed: [n=1] TRUE
  [13:33:52.013] - queued futures: [n=1] TRUE
  [13:33:52.013] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [13:33:52.014]  length: 0 (resolved future 1)
  [13:33:52.014] Relaying remaining futures
  [13:33:52.014] signalConditionsASAP(NULL, pos=0) ...
  [13:33:52.014] - nx: 1
  [13:33:52.015] - relay: TRUE
  [13:33:52.015] - stdout: TRUE
  [13:33:52.015] - signal: TRUE
  [13:33:52.016] - resignal: FALSE
  [13:33:52.016] - force: FALSE
  [13:33:52.016] - relayed: [n=1] TRUE
  [13:33:52.016] - queued futures: [n=1] TRUE
   - flush all
  [13:33:52.017] - relayed: [n=1] TRUE
  [13:33:52.017] - queued futures: [n=1] TRUE
  [13:33:52.017] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:52.018] resolve() on list ... DONE
  [13:33:52.018] - collecting values of futures
  [13:33:52.019] - accumulating results
  [13:33:52.021] - processing errors (handler = 'stop')
  [13:33:52.021] - extracting results
  [13:33:52.022] doFuture() ... DONE
  - plan(list('sequential', 'cluster')) ... DONE
  - plan(list('multicore', 'sequential')) ...
  [13:33:52.023] plan(): Setting new future strategy stack:
  [13:33:52.023] List of future strategies:
  [13:33:52.023] 1. multicore:
  [13:33:52.023]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.023]    - tweaked: FALSE
  [13:33:52.023]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.023] 2. sequential:
  [13:33:52.023]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.023]    - tweaked: FALSE
  [13:33:52.023]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.025] plan(): nbrOfWorkers() = 2
  [13:33:52.026] doFuture() ...
  [13:33:52.030] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:52.031] - R expression:
  [13:33:52.031] {
  [13:33:52.031]     doFuture::registerDoFuture()
  [13:33:52.031]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.031]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.031]         {
  [13:33:52.031]             a <- NULL
  [13:33:52.031]             b <- NULL
  [13:33:52.031]         }
  [13:33:52.031]         ...future.env <- environment()
  [13:33:52.031]         local({
  [13:33:52.031]             for (name in names(...future.x_jj)) {
  [13:33:52.031]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.031]                   inherits = FALSE)
  [13:33:52.031]             }
  [13:33:52.031]         })
  [13:33:52.031]         tryCatch({
  [13:33:52.031]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.031]                 plan = future::plan())
  [13:33:52.031]         }, error = identity)
  [13:33:52.031]     })
  [13:33:52.031] }
  [13:33:52.032] - identifying globals and packages ...
  [13:33:52.033] getGlobalsAndPackages() ...
  [13:33:52.033] Searching for globals...
  [13:33:52.048] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:52.049] Searching for globals ... DONE
  [13:33:52.049] Resolving globals: FALSE
  [13:33:52.051] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:52.051] - globals: [1] '...future.x_ii'
  [13:33:52.051] 
  [13:33:52.052] getGlobalsAndPackages() ... DONE
  [13:33:52.052] List of 1
  [13:33:52.052]  $ ...future.x_ii: NULL
  [13:33:52.052]  - attr(*, "where")=List of 1
  [13:33:52.052]   ..$ ...future.x_ii:<environment: 0x563b8602f8c8> 
  [13:33:52.052]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.052]  - attr(*, "resolved")= logi FALSE
  [13:33:52.052]  - attr(*, "total_size")= num 0
  [13:33:52.058]   - R expression:
  [13:33:52.059] {
  [13:33:52.059]     doFuture::registerDoFuture()
  [13:33:52.059]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.059]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.059]         {
  [13:33:52.059]             a <- NULL
  [13:33:52.059]             b <- NULL
  [13:33:52.059]         }
  [13:33:52.059]         ...future.env <- environment()
  [13:33:52.059]         local({
  [13:33:52.059]             for (name in names(...future.x_jj)) {
  [13:33:52.059]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.059]                   inherits = FALSE)
  [13:33:52.059]             }
  [13:33:52.059]         })
  [13:33:52.059]         tryCatch({
  [13:33:52.059]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.059]                 plan = future::plan())
  [13:33:52.059]         }, error = identity)
  [13:33:52.059]     })
  [13:33:52.059] }
  [13:33:52.060]   - globals: [1] '...future.x_ii'
  [13:33:52.060] List of 1
  [13:33:52.060]  $ ...future.x_ii: NULL
  [13:33:52.060]  - attr(*, "where")=List of 1
  [13:33:52.060]   ..$ ...future.x_ii:<environment: 0x563b8602f8c8> 
  [13:33:52.060]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.060]  - attr(*, "resolved")= logi FALSE
  [13:33:52.060]  - attr(*, "total_size")= num 0
  [13:33:52.070]   - packages: [1] 'doFuture'
  [13:33:52.070] - identifying globals and packages ... DONE
  [13:33:52.074] Number of chunks: 2
  [13:33:52.074] Number of futures (= number of chunks): 2
  [13:33:52.074] Launching 2 futures (chunks) ...
  [13:33:52.075] Chunk #1 of 2 ...
  [13:33:52.075]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:52.075] getGlobalsAndPackages() ...
  [13:33:52.076] Searching for globals...
  [13:33:52.077] 
  [13:33:52.077] Searching for globals ... DONE
  [13:33:52.077] - globals: [0] <none>
  [13:33:52.078] getGlobalsAndPackages() ... DONE
  [13:33:52.078] 
  [13:33:52.078] 
  [13:33:52.079]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:52.080] getGlobalsAndPackages() ...
  [13:33:52.080] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.080] Resolving globals: FALSE
  [13:33:52.081] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.082] - globals: [1] '...future.x_ii'
  [13:33:52.082] 
  [13:33:52.082] getGlobalsAndPackages() ... DONE
  [13:33:52.085] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.085] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.090] {
  [13:33:52.090]     {
  [13:33:52.090]         ...future.startTime <- Sys.time()
  [13:33:52.090]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.090]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.090]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.090]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.090]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.090]         {
  [13:33:52.090]             {
  [13:33:52.090]                 {
  [13:33:52.090]                   {
  [13:33:52.090]                     has_future <- requireNamespace("future", 
  [13:33:52.090]                       quietly = TRUE)
  [13:33:52.090]                     version <- if (has_future) 
  [13:33:52.090]                       packageVersion("future")
  [13:33:52.090]                     else NULL
  [13:33:52.090]                     if (!has_future || version < "1.8.0") {
  [13:33:52.090]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.090]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.090]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.090]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.090]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.090]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.090]                         info)
  [13:33:52.090]                       info <- paste(info, collapse = "; ")
  [13:33:52.090]                       if (!has_future) {
  [13:33:52.090]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.090]                           info)
  [13:33:52.090]                       }
  [13:33:52.090]                       else {
  [13:33:52.090]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.090]                           info, version)
  [13:33:52.090]                       }
  [13:33:52.090]                       stop(msg)
  [13:33:52.090]                     }
  [13:33:52.090]                   }
  [13:33:52.090]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.090]                   options(mc.cores = 1L)
  [13:33:52.090]                 }
  [13:33:52.090]                 local({
  [13:33:52.090]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.090]                     loadNamespace(pkg)
  [13:33:52.090]                     library(pkg, character.only = TRUE)
  [13:33:52.090]                   }
  [13:33:52.090]                 })
  [13:33:52.090]             }
  [13:33:52.090]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.090]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.090]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:52.090]                 label = NULL, ...) 
  [13:33:52.090]             {
  [13:33:52.090]                 if (substitute) 
  [13:33:52.090]                   expr <- substitute(expr)
  [13:33:52.090]                 local <- as.logical(local)
  [13:33:52.090]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:52.090]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.090]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:52.090]                   label = label, ...)
  [13:33:52.090]                 if (!future$lazy) 
  [13:33:52.090]                   future <- run(future)
  [13:33:52.090]                 invisible(future)
  [13:33:52.090]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.090]         }
  [13:33:52.090]     }
  [13:33:52.090]     if (is.na(TRUE)) {
  [13:33:52.090]     }
  [13:33:52.090]     else {
  [13:33:52.090]         if (TRUE) {
  [13:33:52.090]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.090]         }
  [13:33:52.090]         else {
  [13:33:52.090]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.090]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.090]         }
  [13:33:52.090]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.090]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.090]             sink(type = "output", split = FALSE)
  [13:33:52.090]             close(...future.stdout)
  [13:33:52.090]         }, add = TRUE)
  [13:33:52.090]     }
  [13:33:52.090]     ...future.frame <- sys.nframe()
  [13:33:52.090]     ...future.conditions <- list()
  [13:33:52.090]     ...future.result <- tryCatch({
  [13:33:52.090]         withCallingHandlers({
  [13:33:52.090]             ...future.value <- withVisible(local({
  [13:33:52.090]                 doFuture::registerDoFuture()
  [13:33:52.090]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.090]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.090]                   {
  [13:33:52.090]                     a <- NULL
  [13:33:52.090]                     b <- NULL
  [13:33:52.090]                   }
  [13:33:52.090]                   ...future.env <- environment()
  [13:33:52.090]                   local({
  [13:33:52.090]                     for (name in names(...future.x_jj)) {
  [13:33:52.090]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.090]                         inherits = FALSE)
  [13:33:52.090]                     }
  [13:33:52.090]                   })
  [13:33:52.090]                   tryCatch({
  [13:33:52.090]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.090]                       plan = future::plan())
  [13:33:52.090]                   }, error = identity)
  [13:33:52.090]                 })
  [13:33:52.090]             }))
  [13:33:52.090]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.090]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.090]                 version = "1.8")
  [13:33:52.090]         }, condition = local({
  [13:33:52.090]             inherits <- base::inherits
  [13:33:52.090]             invokeRestart <- base::invokeRestart
  [13:33:52.090]             length <- base::length
  [13:33:52.090]             seq.int <- base::seq.int
  [13:33:52.090]             sys.calls <- base::sys.calls
  [13:33:52.090]             `[[` <- base::`[[`
  [13:33:52.090]             `+` <- base::`+`
  [13:33:52.090]             `<<-` <- base::`<<-`
  [13:33:52.090]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.090]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.090]                   3L)]
  [13:33:52.090]             }
  [13:33:52.090]             function(cond) {
  [13:33:52.090]                 if (inherits(cond, "error")) {
  [13:33:52.090]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.090]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.090]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.090]                     signaled = 0L)
  [13:33:52.090]                   signalCondition(cond)
  [13:33:52.090]                 }
  [13:33:52.090]                 else if (inherits(cond, "condition")) {
  [13:33:52.090]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.090]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.090]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.090]                   if (!signal) {
  [13:33:52.090]                     muffleCondition <- function (cond) 
  [13:33:52.090]                     {
  [13:33:52.090]                       inherits <- base::inherits
  [13:33:52.090]                       invokeRestart <- base::invokeRestart
  [13:33:52.090]                       muffled <- FALSE
  [13:33:52.090]                       if (inherits(cond, "message")) {
  [13:33:52.090]                         invokeRestart("muffleMessage")
  [13:33:52.090]                         muffled <- TRUE
  [13:33:52.090]                       }
  [13:33:52.090]                       else if (inherits(cond, "warning")) {
  [13:33:52.090]                         invokeRestart("muffleWarning")
  [13:33:52.090]                         muffled <- TRUE
  [13:33:52.090]                       }
  [13:33:52.090]                       else if (inherits(cond, "condition")) {
  [13:33:52.090]                         computeRestarts <- base::computeRestarts
  [13:33:52.090]                         grepl <- base::grepl
  [13:33:52.090]                         is.null <- base::is.null
  [13:33:52.090]                         restarts <- computeRestarts(cond)
  [13:33:52.090]                         for (restart in restarts) {
  [13:33:52.090]                           name <- restart$name
  [13:33:52.090]                           if (is.null(name)) 
  [13:33:52.090]                             next
  [13:33:52.090]                           if (!grepl("^muffle", name)) 
  [13:33:52.090]                             next
  [13:33:52.090]                           invokeRestart(restart)
  [13:33:52.090]                           muffled <- TRUE
  [13:33:52.090]                           break
  [13:33:52.090]                         }
  [13:33:52.090]                       }
  [13:33:52.090]                       invisible(muffled)
  [13:33:52.090]                     }
  [13:33:52.090]                     muffleCondition(cond)
  [13:33:52.090]                   }
  [13:33:52.090]                 }
  [13:33:52.090]             }
  [13:33:52.090]         }))
  [13:33:52.090]     }, error = function(ex) {
  [13:33:52.090]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.090]             version = "1.8"), class = "FutureResult")
  [13:33:52.090]     }, finally = {
  [13:33:52.090]         {
  [13:33:52.090]             {
  [13:33:52.090]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.090]             }
  [13:33:52.090]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.090]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.090]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.090]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.090]             {
  [13:33:52.090]                 if (substitute) 
  [13:33:52.090]                   expr <- substitute(expr)
  [13:33:52.090]                 if (is.function(workers)) 
  [13:33:52.090]                   workers <- workers()
  [13:33:52.090]                 workers <- as.integer(workers)
  [13:33:52.090]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.090]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.090]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.090]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.090]                     local = TRUE, label = label, ...))
  [13:33:52.090]                 }
  [13:33:52.090]                 oopts <- options(mc.cores = workers)
  [13:33:52.090]                 on.exit(options(oopts))
  [13:33:52.090]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.090]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.090]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.090]                   label = label, ...)
  [13:33:52.090]                 if (!future$lazy) 
  [13:33:52.090]                   future <- run(future)
  [13:33:52.090]                 invisible(future)
  [13:33:52.090]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.090]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:33:52.090]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.090]             {
  [13:33:52.090]                 if (substitute) 
  [13:33:52.090]                   expr <- substitute(expr)
  [13:33:52.090]                 local <- as.logical(local)
  [13:33:52.090]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:52.090]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.090]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:52.090]                   label = label, ...)
  [13:33:52.090]                 if (!future$lazy) 
  [13:33:52.090]                   future <- run(future)
  [13:33:52.090]                 invisible(future)
  [13:33:52.090]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.090]         }
  [13:33:52.090]         options(...future.oldOptions)
  [13:33:52.090]     })
  [13:33:52.090]     if (is.na(TRUE)) {
  [13:33:52.090]     }
  [13:33:52.090]     else {
  [13:33:52.090]         sink(type = "output", split = FALSE)
  [13:33:52.090]         if (TRUE) {
  [13:33:52.090]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.090]         }
  [13:33:52.090]         else {
  [13:33:52.090]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.090]         }
  [13:33:52.090]         close(...future.stdout)
  [13:33:52.090]         ...future.stdout <- NULL
  [13:33:52.090]     }
  [13:33:52.090]     ...future.result$conditions <- ...future.conditions
  [13:33:52.090]     ...future.result
  [13:33:52.090] }
  [13:33:52.095] requestCore(): workers = 2
  [13:33:52.100] MulticoreFuture started
  [13:33:52.101] Chunk #1 of 2 ... DONE
  [13:33:52.101] Chunk #2 of 2 ...
  [13:33:52.102]  - Finding globals in 'args_list' chunk #2 ...
  [13:33:52.102] getGlobalsAndPackages() ...
  [13:33:52.103] Searching for globals...
  [13:33:52.104] 
  [13:33:52.105] Searching for globals ... DONE
  [13:33:52.105] - globals: [0] <none>
  [13:33:52.105] getGlobalsAndPackages() ... DONE
  [13:33:52.106] 
  [13:33:52.106] 
  [13:33:52.107]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:33:52.109] getGlobalsAndPackages() ...
  [13:33:52.109] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.110] Resolving globals: FALSE
  [13:33:52.111] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.112] - globals: [1] '...future.x_ii'
  [13:33:52.112] 
  [13:33:52.112] getGlobalsAndPackages() ... DONE
  [13:33:52.114] plan(): Setting new future strategy stack:
  [13:33:52.115] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.115] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.115] List of future strategies:
  [13:33:52.115] 1. sequential:
  [13:33:52.115]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.115]    - tweaked: FALSE
  [13:33:52.115]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.116] plan(): nbrOfWorkers() = 1
  [13:33:52.118] plan(): Setting new future strategy stack:
  [13:33:52.119] List of future strategies:
  [13:33:52.119] 1. multicore:
  [13:33:52.119]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.119]    - tweaked: FALSE
  [13:33:52.119]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.119] 2. sequential:
  [13:33:52.119]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.119]    - tweaked: FALSE
  [13:33:52.119]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.121] plan(): nbrOfWorkers() = 2
  [13:33:52.121] {
  [13:33:52.121]     {
  [13:33:52.121]         ...future.startTime <- Sys.time()
  [13:33:52.121]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.121]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.121]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.121]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.121]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.121]         {
  [13:33:52.121]             {
  [13:33:52.121]                 {
  [13:33:52.121]                   {
  [13:33:52.121]                     has_future <- requireNamespace("future", 
  [13:33:52.121]                       quietly = TRUE)
  [13:33:52.121]                     version <- if (has_future) 
  [13:33:52.121]                       packageVersion("future")
  [13:33:52.121]                     else NULL
  [13:33:52.121]                     if (!has_future || version < "1.8.0") {
  [13:33:52.121]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.121]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.121]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.121]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.121]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.121]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.121]                         info)
  [13:33:52.121]                       info <- paste(info, collapse = "; ")
  [13:33:52.121]                       if (!has_future) {
  [13:33:52.121]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.121]                           info)
  [13:33:52.121]                       }
  [13:33:52.121]                       else {
  [13:33:52.121]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.121]                           info, version)
  [13:33:52.121]                       }
  [13:33:52.121]                       stop(msg)
  [13:33:52.121]                     }
  [13:33:52.121]                   }
  [13:33:52.121]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.121]                   options(mc.cores = 1L)
  [13:33:52.121]                 }
  [13:33:52.121]                 local({
  [13:33:52.121]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.121]                     loadNamespace(pkg)
  [13:33:52.121]                     library(pkg, character.only = TRUE)
  [13:33:52.121]                   }
  [13:33:52.121]                 })
  [13:33:52.121]             }
  [13:33:52.121]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.121]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.121]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:33:52.121]                 label = NULL, ...) 
  [13:33:52.121]             {
  [13:33:52.121]                 if (substitute) 
  [13:33:52.121]                   expr <- substitute(expr)
  [13:33:52.121]                 local <- as.logical(local)
  [13:33:52.121]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:52.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.121]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:52.121]                   label = label, ...)
  [13:33:52.121]                 if (!future$lazy) 
  [13:33:52.121]                   future <- run(future)
  [13:33:52.121]                 invisible(future)
  [13:33:52.121]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.121]         }
  [13:33:52.121]     }
  [13:33:52.121]     if (is.na(TRUE)) {
  [13:33:52.121]     }
  [13:33:52.121]     else {
  [13:33:52.121]         if (TRUE) {
  [13:33:52.121]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.121]         }
  [13:33:52.121]         else {
  [13:33:52.121]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.121]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.121]         }
  [13:33:52.121]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.121]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.121]             sink(type = "output", split = FALSE)
  [13:33:52.121]             close(...future.stdout)
  [13:33:52.121]         }, add = TRUE)
  [13:33:52.121]     }
  [13:33:52.121]     ...future.frame <- sys.nframe()
  [13:33:52.121]     ...future.conditions <- list()
  [13:33:52.121]     ...future.result <- tryCatch({
  [13:33:52.121]         withCallingHandlers({
  [13:33:52.121]             ...future.value <- withVisible(local({
  [13:33:52.121]                 doFuture::registerDoFuture()
  [13:33:52.121]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.121]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.121]                   {
  [13:33:52.121]                     a <- NULL
  [13:33:52.121]                     b <- NULL
  [13:33:52.121]                   }
  [13:33:52.121]                   ...future.env <- environment()
  [13:33:52.121]                   local({
  [13:33:52.121]                     for (name in names(...future.x_jj)) {
  [13:33:52.121]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.121]                         inherits = FALSE)
  [13:33:52.121]                     }
  [13:33:52.121]                   })
  [13:33:52.121]                   tryCatch({
  [13:33:52.121]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.121]                       plan = future::plan())
  [13:33:52.121]                   }, error = identity)
  [13:33:52.121]                 })
  [13:33:52.121]             }))
  [13:33:52.121]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.121]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.121]                 version = "1.8")
  [13:33:52.121]         }, condition = local({
  [13:33:52.121]             inherits <- base::inherits
  [13:33:52.121]             invokeRestart <- base::invokeRestart
  [13:33:52.121]             length <- base::length
  [13:33:52.121]             seq.int <- base::seq.int
  [13:33:52.121]             sys.calls <- base::sys.calls
  [13:33:52.121]             `[[` <- base::`[[`
  [13:33:52.121]             `+` <- base::`+`
  [13:33:52.121]             `<<-` <- base::`<<-`
  [13:33:52.121]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.121]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.121]                   3L)]
  [13:33:52.121]             }
  [13:33:52.121]             function(cond) {
  [13:33:52.121]                 if (inherits(cond, "error")) {
  [13:33:52.121]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.121]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.121]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.121]                     signaled = 0L)
  [13:33:52.121]                   signalCondition(cond)
  [13:33:52.121]                 }
  [13:33:52.121]                 else if (inherits(cond, "condition")) {
  [13:33:52.121]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.121]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.121]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.121]                   if (!signal) {
  [13:33:52.121]                     muffleCondition <- function (cond) 
  [13:33:52.121]                     {
  [13:33:52.121]                       inherits <- base::inherits
  [13:33:52.121]                       invokeRestart <- base::invokeRestart
  [13:33:52.121]                       muffled <- FALSE
  [13:33:52.121]                       if (inherits(cond, "message")) {
  [13:33:52.121]                         invokeRestart("muffleMessage")
  [13:33:52.121]                         muffled <- TRUE
  [13:33:52.121]                       }
  [13:33:52.121]                       else if (inherits(cond, "warning")) {
  [13:33:52.121]                         invokeRestart("muffleWarning")
  [13:33:52.121]                         muffled <- TRUE
  [13:33:52.121]                       }
  [13:33:52.121]                       else if (inherits(cond, "condition")) {
  [13:33:52.121]                         computeRestarts <- base::computeRestarts
  [13:33:52.121]                         grepl <- base::grepl
  [13:33:52.121]                         is.null <- base::is.null
  [13:33:52.121]                         restarts <- computeRestarts(cond)
  [13:33:52.121]                         for (restart in restarts) {
  [13:33:52.121]                           name <- restart$name
  [13:33:52.121]                           if (is.null(name)) 
  [13:33:52.121]                             next
  [13:33:52.121]                           if (!grepl("^muffle", name)) 
  [13:33:52.121]                             next
  [13:33:52.121]                           invokeRestart(restart)
  [13:33:52.121]                           muffled <- TRUE
  [13:33:52.121]                           break
  [13:33:52.121]                         }
  [13:33:52.121]                       }
  [13:33:52.121]                       invisible(muffled)
  [13:33:52.121]                     }
  [13:33:52.121]                     muffleCondition(cond)
  [13:33:52.121]                   }
  [13:33:52.121]                 }
  [13:33:52.121]             }
  [13:33:52.121]         }))
  [13:33:52.121]     }, error = function(ex) {
  [13:33:52.121]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.121]             version = "1.8"), class = "FutureResult")
  [13:33:52.121]     }, finally = {
  [13:33:52.121]         {
  [13:33:52.121]             {
  [13:33:52.121]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.121]             }
  [13:33:52.121]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.121]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.121]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.121]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.121]             {
  [13:33:52.121]                 if (substitute) 
  [13:33:52.121]                   expr <- substitute(expr)
  [13:33:52.121]                 if (is.function(workers)) 
  [13:33:52.121]                   workers <- workers()
  [13:33:52.121]                 workers <- as.integer(workers)
  [13:33:52.121]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.121]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.121]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.121]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.121]                     local = TRUE, label = label, ...))
  [13:33:52.121]                 }
  [13:33:52.121]                 oopts <- options(mc.cores = workers)
  [13:33:52.121]                 on.exit(options(oopts))
  [13:33:52.121]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.121]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.121]                   label = label, ...)
  [13:33:52.121]                 if (!future$lazy) 
  [13:33:52.121]                   future <- run(future)
  [13:33:52.121]                 invisible(future)
  [13:33:52.121]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.121]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:33:52.121]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.121]             {
  [13:33:52.121]                 if (substitute) 
  [13:33:52.121]                   expr <- substitute(expr)
  [13:33:52.121]                 local <- as.logical(local)
  [13:33:52.121]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:33:52.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.121]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:33:52.121]                   label = label, ...)
  [13:33:52.121]                 if (!future$lazy) 
  [13:33:52.121]                   future <- run(future)
  [13:33:52.121]                 invisible(future)
  [13:33:52.121]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.121]         }
  [13:33:52.121]         options(...future.oldOptions)
  [13:33:52.121]     })
  [13:33:52.121]     if (is.na(TRUE)) {
  [13:33:52.121]     }
  [13:33:52.121]     else {
  [13:33:52.121]         sink(type = "output", split = FALSE)
  [13:33:52.121]         if (TRUE) {
  [13:33:52.121]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.121]         }
  [13:33:52.121]         else {
  [13:33:52.121]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.121]         }
  [13:33:52.121]         close(...future.stdout)
  [13:33:52.121]         ...future.stdout <- NULL
  [13:33:52.121]     }
  [13:33:52.121]     ...future.result$conditions <- ...future.conditions
  [13:33:52.121]     ...future.result
  [13:33:52.121] }
  [13:33:52.127] requestCore(): workers = 2
  [13:33:52.139] MulticoreFuture started
  [13:33:52.140] Chunk #2 of 2 ... DONE
  [13:33:52.140] Launching 2 futures (chunks) ... DONE
  [13:33:52.140] - resolving futures
  [13:33:52.141]   - gathering results & relaying conditions (except errors)
  [13:33:52.141] resolve() on list ...
  [13:33:52.142]  recursive: 0
  [13:33:52.142]  length: 2
  [13:33:52.142] 
  [13:33:52.146] Future #1
  [13:33:52.155] plan(): Setting new future strategy stack:
  [13:33:52.155] List of future strategies:
  [13:33:52.155] 1. sequential:
  [13:33:52.155]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.155]    - tweaked: FALSE
  [13:33:52.155]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.157] plan(): nbrOfWorkers() = 1
  [13:33:52.159] plan(): Setting new future strategy stack:
  [13:33:52.159] List of future strategies:
  [13:33:52.159] 1. multicore:
  [13:33:52.159]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.159]    - tweaked: FALSE
  [13:33:52.159]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.159] 2. sequential:
  [13:33:52.159]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.159]    - tweaked: FALSE
  [13:33:52.159]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.162] plan(): nbrOfWorkers() = 2
  [13:33:52.164] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [13:33:52.165] - nx: 2
  [13:33:52.165] - relay: TRUE
  [13:33:52.166] - stdout: TRUE
  [13:33:52.166] - signal: TRUE
  [13:33:52.166] - resignal: FALSE
  [13:33:52.167] - force: FALSE
  [13:33:52.167] - relayed: [n=2] FALSE, FALSE
  [13:33:52.167] - queued futures: [n=2] FALSE, FALSE
  [13:33:52.168]  - until=1
  [13:33:52.168]  - relaying element #1
  [13:33:52.169] - relayed: [n=2] TRUE, FALSE
  [13:33:52.169] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.169] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [13:33:52.170]  length: 1 (resolved future 1)
  [13:33:52.170] Future #2
  [13:33:52.173] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [13:33:52.173] - nx: 2
  [13:33:52.173] - relay: TRUE
  [13:33:52.174] - stdout: TRUE
  [13:33:52.174] - signal: TRUE
  [13:33:52.184] - resignal: FALSE
  [13:33:52.184] - force: FALSE
  [13:33:52.185] - relayed: [n=2] TRUE, FALSE
  [13:33:52.185] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.186]  - until=2
  [13:33:52.186]  - relaying element #2
  [13:33:52.187] - relayed: [n=2] TRUE, TRUE
  [13:33:52.187] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.187] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [13:33:52.188]  length: 0 (resolved future 2)
  [13:33:52.188] Relaying remaining futures
  [13:33:52.188] signalConditionsASAP(NULL, pos=0) ...
  [13:33:52.189] - nx: 2
  [13:33:52.189] - relay: TRUE
  [13:33:52.189] - stdout: TRUE
  [13:33:52.190] - signal: TRUE
  [13:33:52.190] - resignal: FALSE
  [13:33:52.190] - force: FALSE
  [13:33:52.191] - relayed: [n=2] TRUE, TRUE
  [13:33:52.191] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:33:52.192] - relayed: [n=2] TRUE, TRUE
  [13:33:52.192] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.192] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:52.193] resolve() on list ... DONE
  [13:33:52.193] - collecting values of futures
  [13:33:52.194] - accumulating results
  [13:33:52.196] - processing errors (handler = 'stop')
  [13:33:52.197] - extracting results
  [13:33:52.197] doFuture() ... DONE
  - plan(list('multicore', 'sequential')) ... DONE
  - plan(list('multicore', 'multicore')) ...
  [13:33:52.199] plan(): Setting new future strategy stack:
  [13:33:52.199] List of future strategies:
  [13:33:52.199] 1. multicore:
  [13:33:52.199]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.199]    - tweaked: FALSE
  [13:33:52.199]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.199] 2. multicore:
  [13:33:52.199]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.199]    - tweaked: FALSE
  [13:33:52.199]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.201] plan(): nbrOfWorkers() = 2
  [13:33:52.202] doFuture() ...
  [13:33:52.207] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:52.208] - R expression:
  [13:33:52.208] {
  [13:33:52.208]     doFuture::registerDoFuture()
  [13:33:52.208]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.208]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.208]         {
  [13:33:52.208]             a <- NULL
  [13:33:52.208]             b <- NULL
  [13:33:52.208]         }
  [13:33:52.208]         ...future.env <- environment()
  [13:33:52.208]         local({
  [13:33:52.208]             for (name in names(...future.x_jj)) {
  [13:33:52.208]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.208]                   inherits = FALSE)
  [13:33:52.208]             }
  [13:33:52.208]         })
  [13:33:52.208]         tryCatch({
  [13:33:52.208]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.208]                 plan = future::plan())
  [13:33:52.208]         }, error = identity)
  [13:33:52.208]     })
  [13:33:52.208] }
  [13:33:52.209] - identifying globals and packages ...
  [13:33:52.210] getGlobalsAndPackages() ...
  [13:33:52.210] Searching for globals...
  [13:33:52.227] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:52.228] Searching for globals ... DONE
  [13:33:52.228] Resolving globals: FALSE
  [13:33:52.230] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:52.231] - globals: [1] '...future.x_ii'
  [13:33:52.232] 
  [13:33:52.232] getGlobalsAndPackages() ... DONE
  [13:33:52.232] List of 1
  [13:33:52.232]  $ ...future.x_ii: NULL
  [13:33:52.232]  - attr(*, "where")=List of 1
  [13:33:52.232]   ..$ ...future.x_ii:<environment: 0x563b848f4f28> 
  [13:33:52.232]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.232]  - attr(*, "resolved")= logi FALSE
  [13:33:52.232]  - attr(*, "total_size")= num 0
  [13:33:52.239]   - R expression:
  [13:33:52.239] {
  [13:33:52.239]     doFuture::registerDoFuture()
  [13:33:52.239]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.239]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.239]         {
  [13:33:52.239]             a <- NULL
  [13:33:52.239]             b <- NULL
  [13:33:52.239]         }
  [13:33:52.239]         ...future.env <- environment()
  [13:33:52.239]         local({
  [13:33:52.239]             for (name in names(...future.x_jj)) {
  [13:33:52.239]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.239]                   inherits = FALSE)
  [13:33:52.239]             }
  [13:33:52.239]         })
  [13:33:52.239]         tryCatch({
  [13:33:52.239]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.239]                 plan = future::plan())
  [13:33:52.239]         }, error = identity)
  [13:33:52.239]     })
  [13:33:52.239] }
  [13:33:52.240]   - globals: [1] '...future.x_ii'
  [13:33:52.240] List of 1
  [13:33:52.240]  $ ...future.x_ii: NULL
  [13:33:52.240]  - attr(*, "where")=List of 1
  [13:33:52.240]   ..$ ...future.x_ii:<environment: 0x563b848f4f28> 
  [13:33:52.240]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.240]  - attr(*, "resolved")= logi FALSE
  [13:33:52.240]  - attr(*, "total_size")= num 0
  [13:33:52.247]   - packages: [1] 'doFuture'
  [13:33:52.247] - identifying globals and packages ... DONE
  [13:33:52.249] Number of chunks: 2
  [13:33:52.249] Number of futures (= number of chunks): 2
  [13:33:52.253] Launching 2 futures (chunks) ...
  [13:33:52.253] Chunk #1 of 2 ...
  [13:33:52.253]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:52.254] getGlobalsAndPackages() ...
  [13:33:52.254] Searching for globals...
  [13:33:52.255] 
  [13:33:52.255] Searching for globals ... DONE
  [13:33:52.256] - globals: [0] <none>
  [13:33:52.256] getGlobalsAndPackages() ... DONE
  [13:33:52.256] 
  [13:33:52.257] 
  [13:33:52.257]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:52.258] getGlobalsAndPackages() ...
  [13:33:52.258] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.259] Resolving globals: FALSE
  [13:33:52.260] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.260] - globals: [1] '...future.x_ii'
  [13:33:52.260] 
  [13:33:52.261] getGlobalsAndPackages() ... DONE
  [13:33:52.263] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.263] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.268] {
  [13:33:52.268]     {
  [13:33:52.268]         ...future.startTime <- Sys.time()
  [13:33:52.268]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.268]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.268]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.268]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.268]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.268]         {
  [13:33:52.268]             {
  [13:33:52.268]                 {
  [13:33:52.268]                   {
  [13:33:52.268]                     has_future <- requireNamespace("future", 
  [13:33:52.268]                       quietly = TRUE)
  [13:33:52.268]                     version <- if (has_future) 
  [13:33:52.268]                       packageVersion("future")
  [13:33:52.268]                     else NULL
  [13:33:52.268]                     if (!has_future || version < "1.8.0") {
  [13:33:52.268]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.268]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.268]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.268]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.268]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.268]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.268]                         info)
  [13:33:52.268]                       info <- paste(info, collapse = "; ")
  [13:33:52.268]                       if (!has_future) {
  [13:33:52.268]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.268]                           info)
  [13:33:52.268]                       }
  [13:33:52.268]                       else {
  [13:33:52.268]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.268]                           info, version)
  [13:33:52.268]                       }
  [13:33:52.268]                       stop(msg)
  [13:33:52.268]                     }
  [13:33:52.268]                   }
  [13:33:52.268]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.268]                   options(mc.cores = 1L)
  [13:33:52.268]                 }
  [13:33:52.268]                 local({
  [13:33:52.268]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.268]                     loadNamespace(pkg)
  [13:33:52.268]                     library(pkg, character.only = TRUE)
  [13:33:52.268]                   }
  [13:33:52.268]                 })
  [13:33:52.268]             }
  [13:33:52.268]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.268]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.268]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.268]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.268]             {
  [13:33:52.268]                 if (substitute) 
  [13:33:52.268]                   expr <- substitute(expr)
  [13:33:52.268]                 if (is.function(workers)) 
  [13:33:52.268]                   workers <- workers()
  [13:33:52.268]                 workers <- as.integer(workers)
  [13:33:52.268]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.268]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.268]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.268]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.268]                     local = TRUE, label = label, ...))
  [13:33:52.268]                 }
  [13:33:52.268]                 oopts <- options(mc.cores = workers)
  [13:33:52.268]                 on.exit(options(oopts))
  [13:33:52.268]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.268]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.268]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.268]                   label = label, ...)
  [13:33:52.268]                 if (!future$lazy) 
  [13:33:52.268]                   future <- run(future)
  [13:33:52.268]                 invisible(future)
  [13:33:52.268]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.268]         }
  [13:33:52.268]     }
  [13:33:52.268]     if (is.na(TRUE)) {
  [13:33:52.268]     }
  [13:33:52.268]     else {
  [13:33:52.268]         if (TRUE) {
  [13:33:52.268]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.268]         }
  [13:33:52.268]         else {
  [13:33:52.268]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.268]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.268]         }
  [13:33:52.268]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.268]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.268]             sink(type = "output", split = FALSE)
  [13:33:52.268]             close(...future.stdout)
  [13:33:52.268]         }, add = TRUE)
  [13:33:52.268]     }
  [13:33:52.268]     ...future.frame <- sys.nframe()
  [13:33:52.268]     ...future.conditions <- list()
  [13:33:52.268]     ...future.result <- tryCatch({
  [13:33:52.268]         withCallingHandlers({
  [13:33:52.268]             ...future.value <- withVisible(local({
  [13:33:52.268]                 doFuture::registerDoFuture()
  [13:33:52.268]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.268]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.268]                   {
  [13:33:52.268]                     a <- NULL
  [13:33:52.268]                     b <- NULL
  [13:33:52.268]                   }
  [13:33:52.268]                   ...future.env <- environment()
  [13:33:52.268]                   local({
  [13:33:52.268]                     for (name in names(...future.x_jj)) {
  [13:33:52.268]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.268]                         inherits = FALSE)
  [13:33:52.268]                     }
  [13:33:52.268]                   })
  [13:33:52.268]                   tryCatch({
  [13:33:52.268]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.268]                       plan = future::plan())
  [13:33:52.268]                   }, error = identity)
  [13:33:52.268]                 })
  [13:33:52.268]             }))
  [13:33:52.268]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.268]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.268]                 version = "1.8")
  [13:33:52.268]         }, condition = local({
  [13:33:52.268]             inherits <- base::inherits
  [13:33:52.268]             invokeRestart <- base::invokeRestart
  [13:33:52.268]             length <- base::length
  [13:33:52.268]             seq.int <- base::seq.int
  [13:33:52.268]             sys.calls <- base::sys.calls
  [13:33:52.268]             `[[` <- base::`[[`
  [13:33:52.268]             `+` <- base::`+`
  [13:33:52.268]             `<<-` <- base::`<<-`
  [13:33:52.268]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.268]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.268]                   3L)]
  [13:33:52.268]             }
  [13:33:52.268]             function(cond) {
  [13:33:52.268]                 if (inherits(cond, "error")) {
  [13:33:52.268]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.268]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.268]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.268]                     signaled = 0L)
  [13:33:52.268]                   signalCondition(cond)
  [13:33:52.268]                 }
  [13:33:52.268]                 else if (inherits(cond, "condition")) {
  [13:33:52.268]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.268]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.268]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.268]                   if (!signal) {
  [13:33:52.268]                     muffleCondition <- function (cond) 
  [13:33:52.268]                     {
  [13:33:52.268]                       inherits <- base::inherits
  [13:33:52.268]                       invokeRestart <- base::invokeRestart
  [13:33:52.268]                       muffled <- FALSE
  [13:33:52.268]                       if (inherits(cond, "message")) {
  [13:33:52.268]                         invokeRestart("muffleMessage")
  [13:33:52.268]                         muffled <- TRUE
  [13:33:52.268]                       }
  [13:33:52.268]                       else if (inherits(cond, "warning")) {
  [13:33:52.268]                         invokeRestart("muffleWarning")
  [13:33:52.268]                         muffled <- TRUE
  [13:33:52.268]                       }
  [13:33:52.268]                       else if (inherits(cond, "condition")) {
  [13:33:52.268]                         computeRestarts <- base::computeRestarts
  [13:33:52.268]                         grepl <- base::grepl
  [13:33:52.268]                         is.null <- base::is.null
  [13:33:52.268]                         restarts <- computeRestarts(cond)
  [13:33:52.268]                         for (restart in restarts) {
  [13:33:52.268]                           name <- restart$name
  [13:33:52.268]                           if (is.null(name)) 
  [13:33:52.268]                             next
  [13:33:52.268]                           if (!grepl("^muffle", name)) 
  [13:33:52.268]                             next
  [13:33:52.268]                           invokeRestart(restart)
  [13:33:52.268]                           muffled <- TRUE
  [13:33:52.268]                           break
  [13:33:52.268]                         }
  [13:33:52.268]                       }
  [13:33:52.268]                       invisible(muffled)
  [13:33:52.268]                     }
  [13:33:52.268]                     muffleCondition(cond)
  [13:33:52.268]                   }
  [13:33:52.268]                 }
  [13:33:52.268]             }
  [13:33:52.268]         }))
  [13:33:52.268]     }, error = function(ex) {
  [13:33:52.268]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.268]             version = "1.8"), class = "FutureResult")
  [13:33:52.268]     }, finally = {
  [13:33:52.268]         {
  [13:33:52.268]             {
  [13:33:52.268]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.268]             }
  [13:33:52.268]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.268]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.268]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.268]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.268]             {
  [13:33:52.268]                 if (substitute) 
  [13:33:52.268]                   expr <- substitute(expr)
  [13:33:52.268]                 if (is.function(workers)) 
  [13:33:52.268]                   workers <- workers()
  [13:33:52.268]                 workers <- as.integer(workers)
  [13:33:52.268]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.268]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.268]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.268]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.268]                     local = TRUE, label = label, ...))
  [13:33:52.268]                 }
  [13:33:52.268]                 oopts <- options(mc.cores = workers)
  [13:33:52.268]                 on.exit(options(oopts))
  [13:33:52.268]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.268]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.268]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.268]                   label = label, ...)
  [13:33:52.268]                 if (!future$lazy) 
  [13:33:52.268]                   future <- run(future)
  [13:33:52.268]                 invisible(future)
  [13:33:52.268]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.268]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.268]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.268]             {
  [13:33:52.268]                 if (substitute) 
  [13:33:52.268]                   expr <- substitute(expr)
  [13:33:52.268]                 if (is.function(workers)) 
  [13:33:52.268]                   workers <- workers()
  [13:33:52.268]                 workers <- as.integer(workers)
  [13:33:52.268]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.268]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.268]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.268]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.268]                     local = TRUE, label = label, ...))
  [13:33:52.268]                 }
  [13:33:52.268]                 oopts <- options(mc.cores = workers)
  [13:33:52.268]                 on.exit(options(oopts))
  [13:33:52.268]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.268]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.268]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.268]                   label = label, ...)
  [13:33:52.268]                 if (!future$lazy) 
  [13:33:52.268]                   future <- run(future)
  [13:33:52.268]                 invisible(future)
  [13:33:52.268]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.268]         }
  [13:33:52.268]         options(...future.oldOptions)
  [13:33:52.268]     })
  [13:33:52.268]     if (is.na(TRUE)) {
  [13:33:52.268]     }
  [13:33:52.268]     else {
  [13:33:52.268]         sink(type = "output", split = FALSE)
  [13:33:52.268]         if (TRUE) {
  [13:33:52.268]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.268]         }
  [13:33:52.268]         else {
  [13:33:52.268]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.268]         }
  [13:33:52.268]         close(...future.stdout)
  [13:33:52.268]         ...future.stdout <- NULL
  [13:33:52.268]     }
  [13:33:52.268]     ...future.result$conditions <- ...future.conditions
  [13:33:52.268]     ...future.result
  [13:33:52.268] }
  [13:33:52.273] requestCore(): workers = 2
  [13:33:52.276] MulticoreFuture started
  [13:33:52.277] Chunk #1 of 2 ... DONE
  [13:33:52.277] Chunk #2 of 2 ...
  [13:33:52.278]  - Finding globals in 'args_list' chunk #2 ...
  [13:33:52.278] getGlobalsAndPackages() ...
  [13:33:52.278] Searching for globals...
  [13:33:52.280] 
  [13:33:52.280] Searching for globals ... DONE
  [13:33:52.281] - globals: [0] <none>
  [13:33:52.281] getGlobalsAndPackages() ... DONE
  [13:33:52.281] 
  [13:33:52.282] 
  [13:33:52.282]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:33:52.284] getGlobalsAndPackages() ...
  [13:33:52.285] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.285] Resolving globals: FALSE
  [13:33:52.287] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.287] - globals: [1] '...future.x_ii'
  [13:33:52.288] 
  [13:33:52.288] getGlobalsAndPackages() ... DONE
  [13:33:52.291] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.292] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.294] plan(): Setting new future strategy stack:
  [13:33:52.295] List of future strategies:
  [13:33:52.295] 1. multicore:
  [13:33:52.295]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.295]    - tweaked: FALSE
  [13:33:52.295]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.297] plan(): nbrOfWorkers() = 1
  [13:33:52.299] plan(): Setting new future strategy stack:
  [13:33:52.300] List of future strategies:
  [13:33:52.300] 1. multicore:
  [13:33:52.300]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.300]    - tweaked: FALSE
  [13:33:52.300]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.300] 2. multicore:
  [13:33:52.300]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.300]    - tweaked: FALSE
  [13:33:52.300]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.302] plan(): nbrOfWorkers() = 2
  [13:33:52.297] {
  [13:33:52.297]     {
  [13:33:52.297]         ...future.startTime <- Sys.time()
  [13:33:52.297]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.297]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.297]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.297]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.297]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.297]         {
  [13:33:52.297]             {
  [13:33:52.297]                 {
  [13:33:52.297]                   {
  [13:33:52.297]                     has_future <- requireNamespace("future", 
  [13:33:52.297]                       quietly = TRUE)
  [13:33:52.297]                     version <- if (has_future) 
  [13:33:52.297]                       packageVersion("future")
  [13:33:52.297]                     else NULL
  [13:33:52.297]                     if (!has_future || version < "1.8.0") {
  [13:33:52.297]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.297]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.297]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.297]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.297]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.297]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.297]                         info)
  [13:33:52.297]                       info <- paste(info, collapse = "; ")
  [13:33:52.297]                       if (!has_future) {
  [13:33:52.297]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.297]                           info)
  [13:33:52.297]                       }
  [13:33:52.297]                       else {
  [13:33:52.297]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.297]                           info, version)
  [13:33:52.297]                       }
  [13:33:52.297]                       stop(msg)
  [13:33:52.297]                     }
  [13:33:52.297]                   }
  [13:33:52.297]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.297]                   options(mc.cores = 1L)
  [13:33:52.297]                 }
  [13:33:52.297]                 local({
  [13:33:52.297]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.297]                     loadNamespace(pkg)
  [13:33:52.297]                     library(pkg, character.only = TRUE)
  [13:33:52.297]                   }
  [13:33:52.297]                 })
  [13:33:52.297]             }
  [13:33:52.297]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.297]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.297]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.297]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.297]             {
  [13:33:52.297]                 if (substitute) 
  [13:33:52.297]                   expr <- substitute(expr)
  [13:33:52.297]                 if (is.function(workers)) 
  [13:33:52.297]                   workers <- workers()
  [13:33:52.297]                 workers <- as.integer(workers)
  [13:33:52.297]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.297]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.297]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.297]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.297]                     local = TRUE, label = label, ...))
  [13:33:52.297]                 }
  [13:33:52.297]                 oopts <- options(mc.cores = workers)
  [13:33:52.297]                 on.exit(options(oopts))
  [13:33:52.297]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.297]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.297]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.297]                   label = label, ...)
  [13:33:52.297]                 if (!future$lazy) 
  [13:33:52.297]                   future <- run(future)
  [13:33:52.297]                 invisible(future)
  [13:33:52.297]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.297]         }
  [13:33:52.297]     }
  [13:33:52.297]     if (is.na(TRUE)) {
  [13:33:52.297]     }
  [13:33:52.297]     else {
  [13:33:52.297]         if (TRUE) {
  [13:33:52.297]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.297]         }
  [13:33:52.297]         else {
  [13:33:52.297]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.297]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.297]         }
  [13:33:52.297]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.297]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.297]             sink(type = "output", split = FALSE)
  [13:33:52.297]             close(...future.stdout)
  [13:33:52.297]         }, add = TRUE)
  [13:33:52.297]     }
  [13:33:52.297]     ...future.frame <- sys.nframe()
  [13:33:52.297]     ...future.conditions <- list()
  [13:33:52.297]     ...future.result <- tryCatch({
  [13:33:52.297]         withCallingHandlers({
  [13:33:52.297]             ...future.value <- withVisible(local({
  [13:33:52.297]                 doFuture::registerDoFuture()
  [13:33:52.297]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.297]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.297]                   {
  [13:33:52.297]                     a <- NULL
  [13:33:52.297]                     b <- NULL
  [13:33:52.297]                   }
  [13:33:52.297]                   ...future.env <- environment()
  [13:33:52.297]                   local({
  [13:33:52.297]                     for (name in names(...future.x_jj)) {
  [13:33:52.297]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.297]                         inherits = FALSE)
  [13:33:52.297]                     }
  [13:33:52.297]                   })
  [13:33:52.297]                   tryCatch({
  [13:33:52.297]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.297]                       plan = future::plan())
  [13:33:52.297]                   }, error = identity)
  [13:33:52.297]                 })
  [13:33:52.297]             }))
  [13:33:52.297]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.297]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.297]                 version = "1.8")
  [13:33:52.297]         }, condition = local({
  [13:33:52.297]             inherits <- base::inherits
  [13:33:52.297]             invokeRestart <- base::invokeRestart
  [13:33:52.297]             length <- base::length
  [13:33:52.297]             seq.int <- base::seq.int
  [13:33:52.297]             sys.calls <- base::sys.calls
  [13:33:52.297]             `[[` <- base::`[[`
  [13:33:52.297]             `+` <- base::`+`
  [13:33:52.297]             `<<-` <- base::`<<-`
  [13:33:52.297]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.297]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.297]                   3L)]
  [13:33:52.297]             }
  [13:33:52.297]             function(cond) {
  [13:33:52.297]                 if (inherits(cond, "error")) {
  [13:33:52.297]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.297]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.297]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.297]                     signaled = 0L)
  [13:33:52.297]                   signalCondition(cond)
  [13:33:52.297]                 }
  [13:33:52.297]                 else if (inherits(cond, "condition")) {
  [13:33:52.297]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.297]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.297]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.297]                   if (!signal) {
  [13:33:52.297]                     muffleCondition <- function (cond) 
  [13:33:52.297]                     {
  [13:33:52.297]                       inherits <- base::inherits
  [13:33:52.297]                       invokeRestart <- base::invokeRestart
  [13:33:52.297]                       muffled <- FALSE
  [13:33:52.297]                       if (inherits(cond, "message")) {
  [13:33:52.297]                         invokeRestart("muffleMessage")
  [13:33:52.297]                         muffled <- TRUE
  [13:33:52.297]                       }
  [13:33:52.297]                       else if (inherits(cond, "warning")) {
  [13:33:52.297]                         invokeRestart("muffleWarning")
  [13:33:52.297]                         muffled <- TRUE
  [13:33:52.297]                       }
  [13:33:52.297]                       else if (inherits(cond, "condition")) {
  [13:33:52.297]                         computeRestarts <- base::computeRestarts
  [13:33:52.297]                         grepl <- base::grepl
  [13:33:52.297]                         is.null <- base::is.null
  [13:33:52.297]                         restarts <- computeRestarts(cond)
  [13:33:52.297]                         for (restart in restarts) {
  [13:33:52.297]                           name <- restart$name
  [13:33:52.297]                           if (is.null(name)) 
  [13:33:52.297]                             next
  [13:33:52.297]                           if (!grepl("^muffle", name)) 
  [13:33:52.297]                             next
  [13:33:52.297]                           invokeRestart(restart)
  [13:33:52.297]                           muffled <- TRUE
  [13:33:52.297]                           break
  [13:33:52.297]                         }
  [13:33:52.297]                       }
  [13:33:52.297]                       invisible(muffled)
  [13:33:52.297]                     }
  [13:33:52.297]                     muffleCondition(cond)
  [13:33:52.297]                   }
  [13:33:52.297]                 }
  [13:33:52.297]             }
  [13:33:52.297]         }))
  [13:33:52.297]     }, error = function(ex) {
  [13:33:52.297]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.297]             version = "1.8"), class = "FutureResult")
  [13:33:52.297]     }, finally = {
  [13:33:52.297]         {
  [13:33:52.297]             {
  [13:33:52.297]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.297]             }
  [13:33:52.297]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.297]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.297]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.297]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.297]             {
  [13:33:52.297]                 if (substitute) 
  [13:33:52.297]                   expr <- substitute(expr)
  [13:33:52.297]                 if (is.function(workers)) 
  [13:33:52.297]                   workers <- workers()
  [13:33:52.297]                 workers <- as.integer(workers)
  [13:33:52.297]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.297]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.297]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.297]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.297]                     local = TRUE, label = label, ...))
  [13:33:52.297]                 }
  [13:33:52.297]                 oopts <- options(mc.cores = workers)
  [13:33:52.297]                 on.exit(options(oopts))
  [13:33:52.297]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.297]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.297]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.297]                   label = label, ...)
  [13:33:52.297]                 if (!future$lazy) 
  [13:33:52.297]                   future <- run(future)
  [13:33:52.297]                 invisible(future)
  [13:33:52.297]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.297]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.297]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.297]             {
  [13:33:52.297]                 if (substitute) 
  [13:33:52.297]                   expr <- substitute(expr)
  [13:33:52.297]                 if (is.function(workers)) 
  [13:33:52.297]                   workers <- workers()
  [13:33:52.297]                 workers <- as.integer(workers)
  [13:33:52.297]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.297]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.297]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.297]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.297]                     local = TRUE, label = label, ...))
  [13:33:52.297]                 }
  [13:33:52.297]                 oopts <- options(mc.cores = workers)
  [13:33:52.297]                 on.exit(options(oopts))
  [13:33:52.297]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.297]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.297]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.297]                   label = label, ...)
  [13:33:52.297]                 if (!future$lazy) 
  [13:33:52.297]                   future <- run(future)
  [13:33:52.297]                 invisible(future)
  [13:33:52.297]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.297]         }
  [13:33:52.297]         options(...future.oldOptions)
  [13:33:52.297]     })
  [13:33:52.297]     if (is.na(TRUE)) {
  [13:33:52.297]     }
  [13:33:52.297]     else {
  [13:33:52.297]         sink(type = "output", split = FALSE)
  [13:33:52.297]         if (TRUE) {
  [13:33:52.297]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.297]         }
  [13:33:52.297]         else {
  [13:33:52.297]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.297]         }
  [13:33:52.297]         close(...future.stdout)
  [13:33:52.297]         ...future.stdout <- NULL
  [13:33:52.297]     }
  [13:33:52.297]     ...future.result$conditions <- ...future.conditions
  [13:33:52.297]     ...future.result
  [13:33:52.297] }
  [13:33:52.304] requestCore(): workers = 2
  [13:33:52.307] MulticoreFuture started
  [13:33:52.308] Chunk #2 of 2 ... DONE
  [13:33:52.308] Launching 2 futures (chunks) ... DONE
  [13:33:52.309] - resolving futures
  [13:33:52.309]   - gathering results & relaying conditions (except errors)
  [13:33:52.310] resolve() on list ...
  [13:33:52.310]  recursive: 0
  [13:33:52.310]  length: 2
  [13:33:52.311] 
  [13:33:52.311] Future #1
  [13:33:52.315] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [13:33:52.315] - nx: 2
  [13:33:52.315] - relay: TRUE
  [13:33:52.316] - stdout: TRUE
  [13:33:52.316] - signal: TRUE
  [13:33:52.317] - resignal: FALSE
  [13:33:52.317] - force: FALSE
  [13:33:52.317] - relayed: [n=2] FALSE, FALSE
  [13:33:52.318] - queued futures: [n=2] FALSE, FALSE
  [13:33:52.318]  - until=1
  [13:33:52.318]  - relaying element #1
  [13:33:52.319] - relayed: [n=2] TRUE, FALSE
  [13:33:52.319] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.320] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [13:33:52.320]  length: 1 (resolved future 1)
  [13:33:52.325] plan(): Setting new future strategy stack:
  [13:33:52.325] List of future strategies:
  [13:33:52.325] 1. multicore:
  [13:33:52.325]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.325]    - tweaked: FALSE
  [13:33:52.325]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.328] plan(): nbrOfWorkers() = 1
  [13:33:52.330] plan(): Setting new future strategy stack:
  [13:33:52.330] List of future strategies:
  [13:33:52.330] 1. multicore:
  [13:33:52.330]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.330]    - tweaked: FALSE
  [13:33:52.330]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.330] 2. multicore:
  [13:33:52.330]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.330]    - tweaked: FALSE
  [13:33:52.330]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.333] plan(): nbrOfWorkers() = 2
  [13:33:52.334] Future #2
  [13:33:52.337] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [13:33:52.337] - nx: 2
  [13:33:52.338] - relay: TRUE
  [13:33:52.338] - stdout: TRUE
  [13:33:52.339] - signal: TRUE
  [13:33:52.339] - resignal: FALSE
  [13:33:52.339] - force: FALSE
  [13:33:52.340] - relayed: [n=2] TRUE, FALSE
  [13:33:52.340] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.340]  - until=2
  [13:33:52.341]  - relaying element #2
  [13:33:52.341] - relayed: [n=2] TRUE, TRUE
  [13:33:52.342] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.342] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [13:33:52.342]  length: 0 (resolved future 2)
  [13:33:52.343] Relaying remaining futures
  [13:33:52.343] signalConditionsASAP(NULL, pos=0) ...
  [13:33:52.343] - nx: 2
  [13:33:52.344] - relay: TRUE
  [13:33:52.344] - stdout: TRUE
  [13:33:52.344] - signal: TRUE
  [13:33:52.345] - resignal: FALSE
  [13:33:52.345] - force: FALSE
  [13:33:52.346] - relayed: [n=2] TRUE, TRUE
  [13:33:52.346] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:33:52.347] - relayed: [n=2] TRUE, TRUE
  [13:33:52.347] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.347] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:52.348] resolve() on list ... DONE
  [13:33:52.348] - collecting values of futures
  [13:33:52.349] - accumulating results
  [13:33:52.355] - processing errors (handler = 'stop')
  [13:33:52.355] - extracting results
  [13:33:52.356] doFuture() ... DONE
  - plan(list('multicore', 'multicore')) ... DONE
  - plan(list('multicore', 'multisession')) ...
  [13:33:52.357] plan(): Setting new future strategy stack:
  [13:33:52.358] List of future strategies:
  [13:33:52.358] 1. multicore:
  [13:33:52.358]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.358]    - tweaked: FALSE
  [13:33:52.358]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.358] 2. multisession:
  [13:33:52.358]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.358]    - tweaked: FALSE
  [13:33:52.358]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.360] plan(): nbrOfWorkers() = 2
  [13:33:52.361] doFuture() ...
  [13:33:52.370] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:52.372] - R expression:
  [13:33:52.372] {
  [13:33:52.372]     doFuture::registerDoFuture()
  [13:33:52.372]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.372]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.372]         {
  [13:33:52.372]             a <- NULL
  [13:33:52.372]             b <- NULL
  [13:33:52.372]         }
  [13:33:52.372]         ...future.env <- environment()
  [13:33:52.372]         local({
  [13:33:52.372]             for (name in names(...future.x_jj)) {
  [13:33:52.372]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.372]                   inherits = FALSE)
  [13:33:52.372]             }
  [13:33:52.372]         })
  [13:33:52.372]         tryCatch({
  [13:33:52.372]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.372]                 plan = future::plan())
  [13:33:52.372]         }, error = identity)
  [13:33:52.372]     })
  [13:33:52.372] }
  [13:33:52.373] - identifying globals and packages ...
  [13:33:52.374] getGlobalsAndPackages() ...
  [13:33:52.374] Searching for globals...
  [13:33:52.392] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:52.392] Searching for globals ... DONE
  [13:33:52.392] Resolving globals: FALSE
  [13:33:52.394] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:52.395] - globals: [1] '...future.x_ii'
  [13:33:52.395] 
  [13:33:52.395] getGlobalsAndPackages() ... DONE
  [13:33:52.396] List of 1
  [13:33:52.396]  $ ...future.x_ii: NULL
  [13:33:52.396]  - attr(*, "where")=List of 1
  [13:33:52.396]   ..$ ...future.x_ii:<environment: 0x563b84d56738> 
  [13:33:52.396]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.396]  - attr(*, "resolved")= logi FALSE
  [13:33:52.396]  - attr(*, "total_size")= num 0
  [13:33:52.402]   - R expression:
  [13:33:52.403] {
  [13:33:52.403]     doFuture::registerDoFuture()
  [13:33:52.403]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.403]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.403]         {
  [13:33:52.403]             a <- NULL
  [13:33:52.403]             b <- NULL
  [13:33:52.403]         }
  [13:33:52.403]         ...future.env <- environment()
  [13:33:52.403]         local({
  [13:33:52.403]             for (name in names(...future.x_jj)) {
  [13:33:52.403]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.403]                   inherits = FALSE)
  [13:33:52.403]             }
  [13:33:52.403]         })
  [13:33:52.403]         tryCatch({
  [13:33:52.403]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.403]                 plan = future::plan())
  [13:33:52.403]         }, error = identity)
  [13:33:52.403]     })
  [13:33:52.403] }
  [13:33:52.404]   - globals: [1] '...future.x_ii'
  [13:33:52.404] List of 1
  [13:33:52.404]  $ ...future.x_ii: NULL
  [13:33:52.404]  - attr(*, "where")=List of 1
  [13:33:52.404]   ..$ ...future.x_ii:<environment: 0x563b84d56738> 
  [13:33:52.404]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.404]  - attr(*, "resolved")= logi FALSE
  [13:33:52.404]  - attr(*, "total_size")= num 0
  [13:33:52.410]   - packages: [1] 'doFuture'
  [13:33:52.410] - identifying globals and packages ... DONE
  [13:33:52.412] Number of chunks: 2
  [13:33:52.412] Number of futures (= number of chunks): 2
  [13:33:52.412] Launching 2 futures (chunks) ...
  [13:33:52.412] Chunk #1 of 2 ...
  [13:33:52.413]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:52.413] getGlobalsAndPackages() ...
  [13:33:52.413] Searching for globals...
  [13:33:52.414] 
  [13:33:52.415] Searching for globals ... DONE
  [13:33:52.415] - globals: [0] <none>
  [13:33:52.415] getGlobalsAndPackages() ... DONE
  [13:33:52.415] 
  [13:33:52.416] 
  [13:33:52.416]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:52.417] getGlobalsAndPackages() ...
  [13:33:52.417] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.418] Resolving globals: FALSE
  [13:33:52.419] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.419] - globals: [1] '...future.x_ii'
  [13:33:52.419] 
  [13:33:52.420] getGlobalsAndPackages() ... DONE
  [13:33:52.421] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.422] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.430] {
  [13:33:52.430]     {
  [13:33:52.430]         ...future.startTime <- Sys.time()
  [13:33:52.430]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.430]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.430]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.430]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.430]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.430]         {
  [13:33:52.430]             {
  [13:33:52.430]                 {
  [13:33:52.430]                   {
  [13:33:52.430]                     has_future <- requireNamespace("future", 
  [13:33:52.430]                       quietly = TRUE)
  [13:33:52.430]                     version <- if (has_future) 
  [13:33:52.430]                       packageVersion("future")
  [13:33:52.430]                     else NULL
  [13:33:52.430]                     if (!has_future || version < "1.8.0") {
  [13:33:52.430]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.430]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.430]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.430]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.430]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.430]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.430]                         info)
  [13:33:52.430]                       info <- paste(info, collapse = "; ")
  [13:33:52.430]                       if (!has_future) {
  [13:33:52.430]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.430]                           info)
  [13:33:52.430]                       }
  [13:33:52.430]                       else {
  [13:33:52.430]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.430]                           info, version)
  [13:33:52.430]                       }
  [13:33:52.430]                       stop(msg)
  [13:33:52.430]                     }
  [13:33:52.430]                   }
  [13:33:52.430]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.430]                   options(mc.cores = 1L)
  [13:33:52.430]                 }
  [13:33:52.430]                 local({
  [13:33:52.430]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.430]                     loadNamespace(pkg)
  [13:33:52.430]                     library(pkg, character.only = TRUE)
  [13:33:52.430]                   }
  [13:33:52.430]                 })
  [13:33:52.430]             }
  [13:33:52.430]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.430]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.430]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:33:52.430]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:52.430]                 ...) 
  [13:33:52.430]             {
  [13:33:52.430]                 if (substitute) 
  [13:33:52.430]                   expr <- substitute(expr)
  [13:33:52.430]                 if (is.function(workers)) 
  [13:33:52.430]                   workers <- workers()
  [13:33:52.430]                 workers <- as.integer(workers)
  [13:33:52.430]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:52.430]                   workers >= 1)
  [13:33:52.430]                 if (workers == 1L) {
  [13:33:52.430]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.430]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:52.430]                     local = TRUE, label = label, ...))
  [13:33:52.430]                 }
  [13:33:52.430]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:52.430]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:52.430]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.430]                   globals = globals, persistent = persistent, 
  [13:33:52.430]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:52.430]                   label = label, ...)
  [13:33:52.430]                 if (!future$lazy) 
  [13:33:52.430]                   future <- run(future)
  [13:33:52.430]                 invisible(future)
  [13:33:52.430]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.430]         }
  [13:33:52.430]     }
  [13:33:52.430]     if (is.na(TRUE)) {
  [13:33:52.430]     }
  [13:33:52.430]     else {
  [13:33:52.430]         if (TRUE) {
  [13:33:52.430]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.430]         }
  [13:33:52.430]         else {
  [13:33:52.430]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.430]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.430]         }
  [13:33:52.430]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.430]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.430]             sink(type = "output", split = FALSE)
  [13:33:52.430]             close(...future.stdout)
  [13:33:52.430]         }, add = TRUE)
  [13:33:52.430]     }
  [13:33:52.430]     ...future.frame <- sys.nframe()
  [13:33:52.430]     ...future.conditions <- list()
  [13:33:52.430]     ...future.result <- tryCatch({
  [13:33:52.430]         withCallingHandlers({
  [13:33:52.430]             ...future.value <- withVisible(local({
  [13:33:52.430]                 doFuture::registerDoFuture()
  [13:33:52.430]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.430]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.430]                   {
  [13:33:52.430]                     a <- NULL
  [13:33:52.430]                     b <- NULL
  [13:33:52.430]                   }
  [13:33:52.430]                   ...future.env <- environment()
  [13:33:52.430]                   local({
  [13:33:52.430]                     for (name in names(...future.x_jj)) {
  [13:33:52.430]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.430]                         inherits = FALSE)
  [13:33:52.430]                     }
  [13:33:52.430]                   })
  [13:33:52.430]                   tryCatch({
  [13:33:52.430]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.430]                       plan = future::plan())
  [13:33:52.430]                   }, error = identity)
  [13:33:52.430]                 })
  [13:33:52.430]             }))
  [13:33:52.430]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.430]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.430]                 version = "1.8")
  [13:33:52.430]         }, condition = local({
  [13:33:52.430]             inherits <- base::inherits
  [13:33:52.430]             invokeRestart <- base::invokeRestart
  [13:33:52.430]             length <- base::length
  [13:33:52.430]             seq.int <- base::seq.int
  [13:33:52.430]             sys.calls <- base::sys.calls
  [13:33:52.430]             `[[` <- base::`[[`
  [13:33:52.430]             `+` <- base::`+`
  [13:33:52.430]             `<<-` <- base::`<<-`
  [13:33:52.430]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.430]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.430]                   3L)]
  [13:33:52.430]             }
  [13:33:52.430]             function(cond) {
  [13:33:52.430]                 if (inherits(cond, "error")) {
  [13:33:52.430]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.430]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.430]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.430]                     signaled = 0L)
  [13:33:52.430]                   signalCondition(cond)
  [13:33:52.430]                 }
  [13:33:52.430]                 else if (inherits(cond, "condition")) {
  [13:33:52.430]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.430]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.430]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.430]                   if (!signal) {
  [13:33:52.430]                     muffleCondition <- function (cond) 
  [13:33:52.430]                     {
  [13:33:52.430]                       inherits <- base::inherits
  [13:33:52.430]                       invokeRestart <- base::invokeRestart
  [13:33:52.430]                       muffled <- FALSE
  [13:33:52.430]                       if (inherits(cond, "message")) {
  [13:33:52.430]                         invokeRestart("muffleMessage")
  [13:33:52.430]                         muffled <- TRUE
  [13:33:52.430]                       }
  [13:33:52.430]                       else if (inherits(cond, "warning")) {
  [13:33:52.430]                         invokeRestart("muffleWarning")
  [13:33:52.430]                         muffled <- TRUE
  [13:33:52.430]                       }
  [13:33:52.430]                       else if (inherits(cond, "condition")) {
  [13:33:52.430]                         computeRestarts <- base::computeRestarts
  [13:33:52.430]                         grepl <- base::grepl
  [13:33:52.430]                         is.null <- base::is.null
  [13:33:52.430]                         restarts <- computeRestarts(cond)
  [13:33:52.430]                         for (restart in restarts) {
  [13:33:52.430]                           name <- restart$name
  [13:33:52.430]                           if (is.null(name)) 
  [13:33:52.430]                             next
  [13:33:52.430]                           if (!grepl("^muffle", name)) 
  [13:33:52.430]                             next
  [13:33:52.430]                           invokeRestart(restart)
  [13:33:52.430]                           muffled <- TRUE
  [13:33:52.430]                           break
  [13:33:52.430]                         }
  [13:33:52.430]                       }
  [13:33:52.430]                       invisible(muffled)
  [13:33:52.430]                     }
  [13:33:52.430]                     muffleCondition(cond)
  [13:33:52.430]                   }
  [13:33:52.430]                 }
  [13:33:52.430]             }
  [13:33:52.430]         }))
  [13:33:52.430]     }, error = function(ex) {
  [13:33:52.430]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.430]             version = "1.8"), class = "FutureResult")
  [13:33:52.430]     }, finally = {
  [13:33:52.430]         {
  [13:33:52.430]             {
  [13:33:52.430]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.430]             }
  [13:33:52.430]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.430]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.430]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.430]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.430]             {
  [13:33:52.430]                 if (substitute) 
  [13:33:52.430]                   expr <- substitute(expr)
  [13:33:52.430]                 if (is.function(workers)) 
  [13:33:52.430]                   workers <- workers()
  [13:33:52.430]                 workers <- as.integer(workers)
  [13:33:52.430]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.430]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.430]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.430]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.430]                     local = TRUE, label = label, ...))
  [13:33:52.430]                 }
  [13:33:52.430]                 oopts <- options(mc.cores = workers)
  [13:33:52.430]                 on.exit(options(oopts))
  [13:33:52.430]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.430]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.430]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.430]                   label = label, ...)
  [13:33:52.430]                 if (!future$lazy) 
  [13:33:52.430]                   future <- run(future)
  [13:33:52.430]                 invisible(future)
  [13:33:52.430]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.430]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:52.430]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:33:52.430]                 label = NULL, ...) 
  [13:33:52.430]             {
  [13:33:52.430]                 if (substitute) 
  [13:33:52.430]                   expr <- substitute(expr)
  [13:33:52.430]                 if (is.function(workers)) 
  [13:33:52.430]                   workers <- workers()
  [13:33:52.430]                 workers <- as.integer(workers)
  [13:33:52.430]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:52.430]                   workers >= 1)
  [13:33:52.430]                 if (workers == 1L) {
  [13:33:52.430]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.430]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:52.430]                     local = TRUE, label = label, ...))
  [13:33:52.430]                 }
  [13:33:52.430]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:52.430]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:52.430]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.430]                   globals = globals, persistent = persistent, 
  [13:33:52.430]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:52.430]                   label = label, ...)
  [13:33:52.430]                 if (!future$lazy) 
  [13:33:52.430]                   future <- run(future)
  [13:33:52.430]                 invisible(future)
  [13:33:52.430]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.430]         }
  [13:33:52.430]         options(...future.oldOptions)
  [13:33:52.430]     })
  [13:33:52.430]     if (is.na(TRUE)) {
  [13:33:52.430]     }
  [13:33:52.430]     else {
  [13:33:52.430]         sink(type = "output", split = FALSE)
  [13:33:52.430]         if (TRUE) {
  [13:33:52.430]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.430]         }
  [13:33:52.430]         else {
  [13:33:52.430]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.430]         }
  [13:33:52.430]         close(...future.stdout)
  [13:33:52.430]         ...future.stdout <- NULL
  [13:33:52.430]     }
  [13:33:52.430]     ...future.result$conditions <- ...future.conditions
  [13:33:52.430]     ...future.result
  [13:33:52.430] }
  [13:33:52.435] requestCore(): workers = 2
  [13:33:52.438] MulticoreFuture started
  [13:33:52.439] Chunk #1 of 2 ... DONE
  [13:33:52.440] Chunk #2 of 2 ...
  [13:33:52.440]  - Finding globals in 'args_list' chunk #2 ...
  [13:33:52.441] getGlobalsAndPackages() ...
  [13:33:52.441] Searching for globals...
  [13:33:52.443] 
  [13:33:52.443] Searching for globals ... DONE
  [13:33:52.444] - globals: [0] <none>
  [13:33:52.444] getGlobalsAndPackages() ... DONE
  [13:33:52.445] 
  [13:33:52.445] 
  [13:33:52.446]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:33:52.447] getGlobalsAndPackages() ...
  [13:33:52.448] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.449] Resolving globals: FALSE
  [13:33:52.455] plan(): Setting new future strategy stack:
  [13:33:52.455] List of future strategies:
  [13:33:52.455] 1. multisession:
  [13:33:52.455]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.455]    - tweaked: FALSE
  [13:33:52.455]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.458] plan(): nbrOfWorkers() = 1
  [13:33:52.460] plan(): Setting new future strategy stack:
  [13:33:52.460] List of future strategies:
  [13:33:52.460] 1. multicore:
  [13:33:52.460]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.460]    - tweaked: FALSE
  [13:33:52.460]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.460] 2. multisession:
  [13:33:52.460]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.460]    - tweaked: FALSE
  [13:33:52.460]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.462] plan(): nbrOfWorkers() = 2
  [13:33:52.450] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.464] - globals: [1] '...future.x_ii'
  [13:33:52.465] 
  [13:33:52.465] getGlobalsAndPackages() ... DONE
  [13:33:52.467] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.468] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.474] {
  [13:33:52.474]     {
  [13:33:52.474]         ...future.startTime <- Sys.time()
  [13:33:52.474]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.474]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.474]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.474]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.474]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.474]         {
  [13:33:52.474]             {
  [13:33:52.474]                 {
  [13:33:52.474]                   {
  [13:33:52.474]                     has_future <- requireNamespace("future", 
  [13:33:52.474]                       quietly = TRUE)
  [13:33:52.474]                     version <- if (has_future) 
  [13:33:52.474]                       packageVersion("future")
  [13:33:52.474]                     else NULL
  [13:33:52.474]                     if (!has_future || version < "1.8.0") {
  [13:33:52.474]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.474]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.474]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.474]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.474]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.474]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.474]                         info)
  [13:33:52.474]                       info <- paste(info, collapse = "; ")
  [13:33:52.474]                       if (!has_future) {
  [13:33:52.474]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.474]                           info)
  [13:33:52.474]                       }
  [13:33:52.474]                       else {
  [13:33:52.474]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.474]                           info, version)
  [13:33:52.474]                       }
  [13:33:52.474]                       stop(msg)
  [13:33:52.474]                     }
  [13:33:52.474]                   }
  [13:33:52.474]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.474]                   options(mc.cores = 1L)
  [13:33:52.474]                 }
  [13:33:52.474]                 local({
  [13:33:52.474]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.474]                     loadNamespace(pkg)
  [13:33:52.474]                     library(pkg, character.only = TRUE)
  [13:33:52.474]                   }
  [13:33:52.474]                 })
  [13:33:52.474]             }
  [13:33:52.474]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.474]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.474]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:33:52.474]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:52.474]                 ...) 
  [13:33:52.474]             {
  [13:33:52.474]                 if (substitute) 
  [13:33:52.474]                   expr <- substitute(expr)
  [13:33:52.474]                 if (is.function(workers)) 
  [13:33:52.474]                   workers <- workers()
  [13:33:52.474]                 workers <- as.integer(workers)
  [13:33:52.474]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:52.474]                   workers >= 1)
  [13:33:52.474]                 if (workers == 1L) {
  [13:33:52.474]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.474]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:52.474]                     local = TRUE, label = label, ...))
  [13:33:52.474]                 }
  [13:33:52.474]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:52.474]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:52.474]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.474]                   globals = globals, persistent = persistent, 
  [13:33:52.474]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:52.474]                   label = label, ...)
  [13:33:52.474]                 if (!future$lazy) 
  [13:33:52.474]                   future <- run(future)
  [13:33:52.474]                 invisible(future)
  [13:33:52.474]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.474]         }
  [13:33:52.474]     }
  [13:33:52.474]     if (is.na(TRUE)) {
  [13:33:52.474]     }
  [13:33:52.474]     else {
  [13:33:52.474]         if (TRUE) {
  [13:33:52.474]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.474]         }
  [13:33:52.474]         else {
  [13:33:52.474]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.474]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.474]         }
  [13:33:52.474]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.474]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.474]             sink(type = "output", split = FALSE)
  [13:33:52.474]             close(...future.stdout)
  [13:33:52.474]         }, add = TRUE)
  [13:33:52.474]     }
  [13:33:52.474]     ...future.frame <- sys.nframe()
  [13:33:52.474]     ...future.conditions <- list()
  [13:33:52.474]     ...future.result <- tryCatch({
  [13:33:52.474]         withCallingHandlers({
  [13:33:52.474]             ...future.value <- withVisible(local({
  [13:33:52.474]                 doFuture::registerDoFuture()
  [13:33:52.474]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.474]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.474]                   {
  [13:33:52.474]                     a <- NULL
  [13:33:52.474]                     b <- NULL
  [13:33:52.474]                   }
  [13:33:52.474]                   ...future.env <- environment()
  [13:33:52.474]                   local({
  [13:33:52.474]                     for (name in names(...future.x_jj)) {
  [13:33:52.474]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.474]                         inherits = FALSE)
  [13:33:52.474]                     }
  [13:33:52.474]                   })
  [13:33:52.474]                   tryCatch({
  [13:33:52.474]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.474]                       plan = future::plan())
  [13:33:52.474]                   }, error = identity)
  [13:33:52.474]                 })
  [13:33:52.474]             }))
  [13:33:52.474]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.474]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.474]                 version = "1.8")
  [13:33:52.474]         }, condition = local({
  [13:33:52.474]             inherits <- base::inherits
  [13:33:52.474]             invokeRestart <- base::invokeRestart
  [13:33:52.474]             length <- base::length
  [13:33:52.474]             seq.int <- base::seq.int
  [13:33:52.474]             sys.calls <- base::sys.calls
  [13:33:52.474]             `[[` <- base::`[[`
  [13:33:52.474]             `+` <- base::`+`
  [13:33:52.474]             `<<-` <- base::`<<-`
  [13:33:52.474]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.474]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.474]                   3L)]
  [13:33:52.474]             }
  [13:33:52.474]             function(cond) {
  [13:33:52.474]                 if (inherits(cond, "error")) {
  [13:33:52.474]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.474]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.474]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.474]                     signaled = 0L)
  [13:33:52.474]                   signalCondition(cond)
  [13:33:52.474]                 }
  [13:33:52.474]                 else if (inherits(cond, "condition")) {
  [13:33:52.474]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.474]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.474]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.474]                   if (!signal) {
  [13:33:52.474]                     muffleCondition <- function (cond) 
  [13:33:52.474]                     {
  [13:33:52.474]                       inherits <- base::inherits
  [13:33:52.474]                       invokeRestart <- base::invokeRestart
  [13:33:52.474]                       muffled <- FALSE
  [13:33:52.474]                       if (inherits(cond, "message")) {
  [13:33:52.474]                         invokeRestart("muffleMessage")
  [13:33:52.474]                         muffled <- TRUE
  [13:33:52.474]                       }
  [13:33:52.474]                       else if (inherits(cond, "warning")) {
  [13:33:52.474]                         invokeRestart("muffleWarning")
  [13:33:52.474]                         muffled <- TRUE
  [13:33:52.474]                       }
  [13:33:52.474]                       else if (inherits(cond, "condition")) {
  [13:33:52.474]                         computeRestarts <- base::computeRestarts
  [13:33:52.474]                         grepl <- base::grepl
  [13:33:52.474]                         is.null <- base::is.null
  [13:33:52.474]                         restarts <- computeRestarts(cond)
  [13:33:52.474]                         for (restart in restarts) {
  [13:33:52.474]                           name <- restart$name
  [13:33:52.474]                           if (is.null(name)) 
  [13:33:52.474]                             next
  [13:33:52.474]                           if (!grepl("^muffle", name)) 
  [13:33:52.474]                             next
  [13:33:52.474]                           invokeRestart(restart)
  [13:33:52.474]                           muffled <- TRUE
  [13:33:52.474]                           break
  [13:33:52.474]                         }
  [13:33:52.474]                       }
  [13:33:52.474]                       invisible(muffled)
  [13:33:52.474]                     }
  [13:33:52.474]                     muffleCondition(cond)
  [13:33:52.474]                   }
  [13:33:52.474]                 }
  [13:33:52.474]             }
  [13:33:52.474]         }))
  [13:33:52.474]     }, error = function(ex) {
  [13:33:52.474]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.474]             version = "1.8"), class = "FutureResult")
  [13:33:52.474]     }, finally = {
  [13:33:52.474]         {
  [13:33:52.474]             {
  [13:33:52.474]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.474]             }
  [13:33:52.474]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.474]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.474]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.474]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.474]             {
  [13:33:52.474]                 if (substitute) 
  [13:33:52.474]                   expr <- substitute(expr)
  [13:33:52.474]                 if (is.function(workers)) 
  [13:33:52.474]                   workers <- workers()
  [13:33:52.474]                 workers <- as.integer(workers)
  [13:33:52.474]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.474]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.474]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.474]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.474]                     local = TRUE, label = label, ...))
  [13:33:52.474]                 }
  [13:33:52.474]                 oopts <- options(mc.cores = workers)
  [13:33:52.474]                 on.exit(options(oopts))
  [13:33:52.474]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.474]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.474]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.474]                   label = label, ...)
  [13:33:52.474]                 if (!future$lazy) 
  [13:33:52.474]                   future <- run(future)
  [13:33:52.474]                 invisible(future)
  [13:33:52.474]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.474]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:52.474]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:33:52.474]                 label = NULL, ...) 
  [13:33:52.474]             {
  [13:33:52.474]                 if (substitute) 
  [13:33:52.474]                   expr <- substitute(expr)
  [13:33:52.474]                 if (is.function(workers)) 
  [13:33:52.474]                   workers <- workers()
  [13:33:52.474]                 workers <- as.integer(workers)
  [13:33:52.474]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:33:52.474]                   workers >= 1)
  [13:33:52.474]                 if (workers == 1L) {
  [13:33:52.474]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.474]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:33:52.474]                     local = TRUE, label = label, ...))
  [13:33:52.474]                 }
  [13:33:52.474]                 workers <- ClusterRegistry("start", workers = workers)
  [13:33:52.474]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:33:52.474]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.474]                   globals = globals, persistent = persistent, 
  [13:33:52.474]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:33:52.474]                   label = label, ...)
  [13:33:52.474]                 if (!future$lazy) 
  [13:33:52.474]                   future <- run(future)
  [13:33:52.474]                 invisible(future)
  [13:33:52.474]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.474]         }
  [13:33:52.474]         options(...future.oldOptions)
  [13:33:52.474]     })
  [13:33:52.474]     if (is.na(TRUE)) {
  [13:33:52.474]     }
  [13:33:52.474]     else {
  [13:33:52.474]         sink(type = "output", split = FALSE)
  [13:33:52.474]         if (TRUE) {
  [13:33:52.474]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.474]         }
  [13:33:52.474]         else {
  [13:33:52.474]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.474]         }
  [13:33:52.474]         close(...future.stdout)
  [13:33:52.474]         ...future.stdout <- NULL
  [13:33:52.474]     }
  [13:33:52.474]     ...future.result$conditions <- ...future.conditions
  [13:33:52.474]     ...future.result
  [13:33:52.474] }
  [13:33:52.480] requestCore(): workers = 2
  [13:33:52.483] MulticoreFuture started
  [13:33:52.484] Chunk #2 of 2 ... DONE
  [13:33:52.485] Launching 2 futures (chunks) ... DONE
  [13:33:52.485] - resolving futures
  [13:33:52.485]   - gathering results & relaying conditions (except errors)
  [13:33:52.486] resolve() on list ...
  [13:33:52.486]  recursive: 0
  [13:33:52.487]  length: 2
  [13:33:52.487] 
  [13:33:52.488] Future #1
  [13:33:52.494] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [13:33:52.495] - nx: 2
  [13:33:52.495] - relay: TRUE
  [13:33:52.496] - stdout: TRUE
  [13:33:52.496] - signal: TRUE
  [13:33:52.496] - resignal: FALSE
  [13:33:52.497] - force: FALSE
  [13:33:52.497] - relayed: [n=2] FALSE, FALSE
  [13:33:52.498] - queued futures: [n=2] FALSE, FALSE
  [13:33:52.498]  - until=1
  [13:33:52.498]  - relaying element #1
  [13:33:52.499] - relayed: [n=2] TRUE, FALSE
  [13:33:52.500] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.500] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [13:33:52.500]  length: 1 (resolved future 1)
  [13:33:52.510] plan(): Setting new future strategy stack:
  [13:33:52.511] List of future strategies:
  [13:33:52.511] 1. multisession:
  [13:33:52.511]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.511]    - tweaked: FALSE
  [13:33:52.511]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.513] plan(): nbrOfWorkers() = 1
  [13:33:52.515] plan(): Setting new future strategy stack:
  [13:33:52.516] List of future strategies:
  [13:33:52.516] 1. multicore:
  [13:33:52.516]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.516]    - tweaked: FALSE
  [13:33:52.516]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.516] 2. multisession:
  [13:33:52.516]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.516]    - tweaked: FALSE
  [13:33:52.516]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.518] plan(): nbrOfWorkers() = 2
  [13:33:52.519] Future #2
  [13:33:52.522] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [13:33:52.523] - nx: 2
  [13:33:52.523] - relay: TRUE
  [13:33:52.523] - stdout: TRUE
  [13:33:52.524] - signal: TRUE
  [13:33:52.524] - resignal: FALSE
  [13:33:52.524] - force: FALSE
  [13:33:52.525] - relayed: [n=2] TRUE, FALSE
  [13:33:52.525] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.526]  - until=2
  [13:33:52.526]  - relaying element #2
  [13:33:52.527] - relayed: [n=2] TRUE, TRUE
  [13:33:52.527] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.527] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [13:33:52.528]  length: 0 (resolved future 2)
  [13:33:52.528] Relaying remaining futures
  [13:33:52.528] signalConditionsASAP(NULL, pos=0) ...
  [13:33:52.529] - nx: 2
  [13:33:52.529] - relay: TRUE
  [13:33:52.529] - stdout: TRUE
  [13:33:52.530] - signal: TRUE
  [13:33:52.530] - resignal: FALSE
  [13:33:52.531] - force: FALSE
  [13:33:52.531] - relayed: [n=2] TRUE, TRUE
  [13:33:52.531] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:33:52.532] - relayed: [n=2] TRUE, TRUE
  [13:33:52.532] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.547] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:52.547] resolve() on list ... DONE
  [13:33:52.547] - collecting values of futures
  [13:33:52.548] - accumulating results
  [13:33:52.551] - processing errors (handler = 'stop')
  [13:33:52.551] - extracting results
  [13:33:52.551] doFuture() ... DONE
  - plan(list('multicore', 'multisession')) ... DONE
  - plan(list('multicore', 'cluster')) ...
  [13:33:52.553] plan(): Setting new future strategy stack:
  [13:33:52.553] List of future strategies:
  [13:33:52.553] 1. multicore:
  [13:33:52.553]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.553]    - tweaked: FALSE
  [13:33:52.553]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.553] 2. cluster:
  [13:33:52.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, ...)
  [13:33:52.553]    - tweaked: FALSE
  [13:33:52.553]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.555] plan(): nbrOfWorkers() = 2
  [13:33:52.556] doFuture() ...
  [13:33:52.561] - dummy globals (as locals): [2] 'a', 'b'
  [13:33:52.562] - R expression:
  [13:33:52.562] {
  [13:33:52.562]     doFuture::registerDoFuture()
  [13:33:52.562]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.562]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.562]         {
  [13:33:52.562]             a <- NULL
  [13:33:52.562]             b <- NULL
  [13:33:52.562]         }
  [13:33:52.562]         ...future.env <- environment()
  [13:33:52.562]         local({
  [13:33:52.562]             for (name in names(...future.x_jj)) {
  [13:33:52.562]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.562]                   inherits = FALSE)
  [13:33:52.562]             }
  [13:33:52.562]         })
  [13:33:52.562]         tryCatch({
  [13:33:52.562]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.562]                 plan = future::plan())
  [13:33:52.562]         }, error = identity)
  [13:33:52.562]     })
  [13:33:52.562] }
  [13:33:52.579] - identifying globals and packages ...
  [13:33:52.580] getGlobalsAndPackages() ...
  [13:33:52.580] Searching for globals...
  [13:33:52.618] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:33:52.619] Searching for globals ... DONE
  [13:33:52.619] Resolving globals: FALSE
  [13:33:52.621] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:33:52.621] - globals: [1] '...future.x_ii'
  [13:33:52.622] 
  [13:33:52.622] getGlobalsAndPackages() ... DONE
  [13:33:52.622] List of 1
  [13:33:52.622]  $ ...future.x_ii: NULL
  [13:33:52.622]  - attr(*, "where")=List of 1
  [13:33:52.622]   ..$ ...future.x_ii:<environment: 0x563b864c8558> 
  [13:33:52.622]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.622]  - attr(*, "resolved")= logi FALSE
  [13:33:52.622]  - attr(*, "total_size")= num 0
  [13:33:52.645]   - R expression:
  [13:33:52.645] {
  [13:33:52.645]     doFuture::registerDoFuture()
  [13:33:52.645]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.645]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.645]         {
  [13:33:52.645]             a <- NULL
  [13:33:52.645]             b <- NULL
  [13:33:52.645]         }
  [13:33:52.645]         ...future.env <- environment()
  [13:33:52.645]         local({
  [13:33:52.645]             for (name in names(...future.x_jj)) {
  [13:33:52.645]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.645]                   inherits = FALSE)
  [13:33:52.645]             }
  [13:33:52.645]         })
  [13:33:52.645]         tryCatch({
  [13:33:52.645]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.645]                 plan = future::plan())
  [13:33:52.645]         }, error = identity)
  [13:33:52.645]     })
  [13:33:52.645] }
  [13:33:52.646]   - globals: [1] '...future.x_ii'
  [13:33:52.647] List of 1
  [13:33:52.647]  $ ...future.x_ii: NULL
  [13:33:52.647]  - attr(*, "where")=List of 1
  [13:33:52.647]   ..$ ...future.x_ii:<environment: 0x563b864c8558> 
  [13:33:52.647]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:33:52.647]  - attr(*, "resolved")= logi FALSE
  [13:33:52.647]  - attr(*, "total_size")= num 0
  [13:33:52.652]   - packages: [1] 'doFuture'
  [13:33:52.653] - identifying globals and packages ... DONE
  [13:33:52.654] Number of chunks: 2
  [13:33:52.654] Number of futures (= number of chunks): 2
  [13:33:52.655] Launching 2 futures (chunks) ...
  [13:33:52.655] Chunk #1 of 2 ...
  [13:33:52.655]  - Finding globals in 'args_list' chunk #1 ...
  [13:33:52.655] getGlobalsAndPackages() ...
  [13:33:52.656] Searching for globals...
  [13:33:52.657] 
  [13:33:52.657] Searching for globals ... DONE
  [13:33:52.657] - globals: [0] <none>
  [13:33:52.657] getGlobalsAndPackages() ... DONE
  [13:33:52.658] 
  [13:33:52.658] 
  [13:33:52.674]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:33:52.675] getGlobalsAndPackages() ...
  [13:33:52.676] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.676] Resolving globals: FALSE
  [13:33:52.677] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.677] - globals: [1] '...future.x_ii'
  [13:33:52.678] 
  [13:33:52.678] getGlobalsAndPackages() ... DONE
  [13:33:52.680] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.680] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.685] {
  [13:33:52.685]     {
  [13:33:52.685]         ...future.startTime <- Sys.time()
  [13:33:52.685]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.685]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.685]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.685]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.685]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.685]         {
  [13:33:52.685]             {
  [13:33:52.685]                 {
  [13:33:52.685]                   {
  [13:33:52.685]                     has_future <- requireNamespace("future", 
  [13:33:52.685]                       quietly = TRUE)
  [13:33:52.685]                     version <- if (has_future) 
  [13:33:52.685]                       packageVersion("future")
  [13:33:52.685]                     else NULL
  [13:33:52.685]                     if (!has_future || version < "1.8.0") {
  [13:33:52.685]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.685]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.685]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.685]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.685]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.685]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.685]                         info)
  [13:33:52.685]                       info <- paste(info, collapse = "; ")
  [13:33:52.685]                       if (!has_future) {
  [13:33:52.685]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.685]                           info)
  [13:33:52.685]                       }
  [13:33:52.685]                       else {
  [13:33:52.685]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.685]                           info, version)
  [13:33:52.685]                       }
  [13:33:52.685]                       stop(msg)
  [13:33:52.685]                     }
  [13:33:52.685]                   }
  [13:33:52.685]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.685]                   options(mc.cores = 1L)
  [13:33:52.685]                 }
  [13:33:52.685]                 local({
  [13:33:52.685]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.685]                     loadNamespace(pkg)
  [13:33:52.685]                     library(pkg, character.only = TRUE)
  [13:33:52.685]                   }
  [13:33:52.685]                 })
  [13:33:52.685]             }
  [13:33:52.685]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.685]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.685]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:33:52.685]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:33:52.685]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:52.685]                 ...) 
  [13:33:52.685]             {
  [13:33:52.685]                 if (substitute) 
  [13:33:52.685]                   expr <- substitute(expr)
  [13:33:52.685]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:52.685]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.685]                   globals = globals, persistent = persistent, 
  [13:33:52.685]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:52.685]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:52.685]                   label = label, ...)
  [13:33:52.685]                 if (!future$lazy) 
  [13:33:52.685]                   future <- run(future)
  [13:33:52.685]                 invisible(future)
  [13:33:52.685]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.685]         }
  [13:33:52.685]     }
  [13:33:52.685]     if (is.na(TRUE)) {
  [13:33:52.685]     }
  [13:33:52.685]     else {
  [13:33:52.685]         if (TRUE) {
  [13:33:52.685]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.685]         }
  [13:33:52.685]         else {
  [13:33:52.685]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.685]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.685]         }
  [13:33:52.685]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.685]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.685]             sink(type = "output", split = FALSE)
  [13:33:52.685]             close(...future.stdout)
  [13:33:52.685]         }, add = TRUE)
  [13:33:52.685]     }
  [13:33:52.685]     ...future.frame <- sys.nframe()
  [13:33:52.685]     ...future.conditions <- list()
  [13:33:52.685]     ...future.result <- tryCatch({
  [13:33:52.685]         withCallingHandlers({
  [13:33:52.685]             ...future.value <- withVisible(local({
  [13:33:52.685]                 doFuture::registerDoFuture()
  [13:33:52.685]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.685]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.685]                   {
  [13:33:52.685]                     a <- NULL
  [13:33:52.685]                     b <- NULL
  [13:33:52.685]                   }
  [13:33:52.685]                   ...future.env <- environment()
  [13:33:52.685]                   local({
  [13:33:52.685]                     for (name in names(...future.x_jj)) {
  [13:33:52.685]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.685]                         inherits = FALSE)
  [13:33:52.685]                     }
  [13:33:52.685]                   })
  [13:33:52.685]                   tryCatch({
  [13:33:52.685]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.685]                       plan = future::plan())
  [13:33:52.685]                   }, error = identity)
  [13:33:52.685]                 })
  [13:33:52.685]             }))
  [13:33:52.685]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.685]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.685]                 version = "1.8")
  [13:33:52.685]         }, condition = local({
  [13:33:52.685]             inherits <- base::inherits
  [13:33:52.685]             invokeRestart <- base::invokeRestart
  [13:33:52.685]             length <- base::length
  [13:33:52.685]             seq.int <- base::seq.int
  [13:33:52.685]             sys.calls <- base::sys.calls
  [13:33:52.685]             `[[` <- base::`[[`
  [13:33:52.685]             `+` <- base::`+`
  [13:33:52.685]             `<<-` <- base::`<<-`
  [13:33:52.685]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.685]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.685]                   3L)]
  [13:33:52.685]             }
  [13:33:52.685]             function(cond) {
  [13:33:52.685]                 if (inherits(cond, "error")) {
  [13:33:52.685]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.685]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.685]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.685]                     signaled = 0L)
  [13:33:52.685]                   signalCondition(cond)
  [13:33:52.685]                 }
  [13:33:52.685]                 else if (inherits(cond, "condition")) {
  [13:33:52.685]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.685]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.685]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.685]                   if (!signal) {
  [13:33:52.685]                     muffleCondition <- function (cond) 
  [13:33:52.685]                     {
  [13:33:52.685]                       inherits <- base::inherits
  [13:33:52.685]                       invokeRestart <- base::invokeRestart
  [13:33:52.685]                       muffled <- FALSE
  [13:33:52.685]                       if (inherits(cond, "message")) {
  [13:33:52.685]                         invokeRestart("muffleMessage")
  [13:33:52.685]                         muffled <- TRUE
  [13:33:52.685]                       }
  [13:33:52.685]                       else if (inherits(cond, "warning")) {
  [13:33:52.685]                         invokeRestart("muffleWarning")
  [13:33:52.685]                         muffled <- TRUE
  [13:33:52.685]                       }
  [13:33:52.685]                       else if (inherits(cond, "condition")) {
  [13:33:52.685]                         computeRestarts <- base::computeRestarts
  [13:33:52.685]                         grepl <- base::grepl
  [13:33:52.685]                         is.null <- base::is.null
  [13:33:52.685]                         restarts <- computeRestarts(cond)
  [13:33:52.685]                         for (restart in restarts) {
  [13:33:52.685]                           name <- restart$name
  [13:33:52.685]                           if (is.null(name)) 
  [13:33:52.685]                             next
  [13:33:52.685]                           if (!grepl("^muffle", name)) 
  [13:33:52.685]                             next
  [13:33:52.685]                           invokeRestart(restart)
  [13:33:52.685]                           muffled <- TRUE
  [13:33:52.685]                           break
  [13:33:52.685]                         }
  [13:33:52.685]                       }
  [13:33:52.685]                       invisible(muffled)
  [13:33:52.685]                     }
  [13:33:52.685]                     muffleCondition(cond)
  [13:33:52.685]                   }
  [13:33:52.685]                 }
  [13:33:52.685]             }
  [13:33:52.685]         }))
  [13:33:52.685]     }, error = function(ex) {
  [13:33:52.685]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.685]             version = "1.8"), class = "FutureResult")
  [13:33:52.685]     }, finally = {
  [13:33:52.685]         {
  [13:33:52.685]             {
  [13:33:52.685]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.685]             }
  [13:33:52.685]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.685]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.685]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.685]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.685]             {
  [13:33:52.685]                 if (substitute) 
  [13:33:52.685]                   expr <- substitute(expr)
  [13:33:52.685]                 if (is.function(workers)) 
  [13:33:52.685]                   workers <- workers()
  [13:33:52.685]                 workers <- as.integer(workers)
  [13:33:52.685]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.685]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.685]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.685]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.685]                     local = TRUE, label = label, ...))
  [13:33:52.685]                 }
  [13:33:52.685]                 oopts <- options(mc.cores = workers)
  [13:33:52.685]                 on.exit(options(oopts))
  [13:33:52.685]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.685]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.685]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.685]                   label = label, ...)
  [13:33:52.685]                 if (!future$lazy) 
  [13:33:52.685]                   future <- run(future)
  [13:33:52.685]                 invisible(future)
  [13:33:52.685]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.685]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:52.685]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:33:52.685]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:33:52.685]                 label = NULL, ...) 
  [13:33:52.685]             {
  [13:33:52.685]                 if (substitute) 
  [13:33:52.685]                   expr <- substitute(expr)
  [13:33:52.685]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:52.685]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.685]                   globals = globals, persistent = persistent, 
  [13:33:52.685]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:52.685]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:52.685]                   label = label, ...)
  [13:33:52.685]                 if (!future$lazy) 
  [13:33:52.685]                   future <- run(future)
  [13:33:52.685]                 invisible(future)
  [13:33:52.685]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.685]         }
  [13:33:52.685]         options(...future.oldOptions)
  [13:33:52.685]     })
  [13:33:52.685]     if (is.na(TRUE)) {
  [13:33:52.685]     }
  [13:33:52.685]     else {
  [13:33:52.685]         sink(type = "output", split = FALSE)
  [13:33:52.685]         if (TRUE) {
  [13:33:52.685]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.685]         }
  [13:33:52.685]         else {
  [13:33:52.685]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.685]         }
  [13:33:52.685]         close(...future.stdout)
  [13:33:52.685]         ...future.stdout <- NULL
  [13:33:52.685]     }
  [13:33:52.685]     ...future.result$conditions <- ...future.conditions
  [13:33:52.685]     ...future.result
  [13:33:52.685] }
  [13:33:52.689] requestCore(): workers = 2
  [13:33:52.709] MulticoreFuture started
  [13:33:52.709] Chunk #1 of 2 ... DONE
  [13:33:52.710] Chunk #2 of 2 ...
  [13:33:52.710]  - Finding globals in 'args_list' chunk #2 ...
  [13:33:52.710] getGlobalsAndPackages() ...
  [13:33:52.711] Searching for globals...
  [13:33:52.712] 
  [13:33:52.713] Searching for globals ... DONE
  [13:33:52.713] - globals: [0] <none>
  [13:33:52.714] getGlobalsAndPackages() ... DONE
  [13:33:52.714] 
  [13:33:52.714] 
  [13:33:52.715]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:33:52.716] getGlobalsAndPackages() ...
  [13:33:52.717] - globals passed as-is: [1] '...future.x_ii'
  [13:33:52.717] Resolving globals: FALSE
  [13:33:52.719] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:33:52.719] - globals: [1] '...future.x_ii'
  [13:33:52.722] plan(): Setting new future strategy stack:
  [13:33:52.723] List of future strategies:
  [13:33:52.723] 1. cluster:
  [13:33:52.723]    - 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, ...)
  [13:33:52.723]    - tweaked: FALSE
  [13:33:52.723]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.726] plan(): nbrOfWorkers() = 1
  [13:33:52.728] plan(): Setting new future strategy stack:
  [13:33:52.728] List of future strategies:
  [13:33:52.728] 1. multicore:
  [13:33:52.728]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.728]    - tweaked: FALSE
  [13:33:52.728]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.728] 2. cluster:
  [13:33:52.728]    - 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, ...)
  [13:33:52.728]    - tweaked: FALSE
  [13:33:52.728]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.737] plan(): nbrOfWorkers() = 2
  [13:33:52.720] 
  [13:33:52.741] getGlobalsAndPackages() ... DONE
  [13:33:52.744] Packages needed by the future expression (n = 1): 'doFuture'
  [13:33:52.745] Packages needed by future strategies (n = 1): 'future'
  [13:33:52.751] {
  [13:33:52.751]     {
  [13:33:52.751]         ...future.startTime <- Sys.time()
  [13:33:52.751]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:33:52.751]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:33:52.751]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:33:52.751]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:33:52.751]             future.resolve.recursive = NULL, width = 80L)
  [13:33:52.751]         {
  [13:33:52.751]             {
  [13:33:52.751]                 {
  [13:33:52.751]                   {
  [13:33:52.751]                     has_future <- requireNamespace("future", 
  [13:33:52.751]                       quietly = TRUE)
  [13:33:52.751]                     version <- if (has_future) 
  [13:33:52.751]                       packageVersion("future")
  [13:33:52.751]                     else NULL
  [13:33:52.751]                     if (!has_future || version < "1.8.0") {
  [13:33:52.751]                       info <- c(r_version = gsub("R version ", 
  [13:33:52.751]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:33:52.751]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:33:52.751]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:33:52.751]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:33:52.751]                       info <- sprintf("%s: %s", names(info), 
  [13:33:52.751]                         info)
  [13:33:52.751]                       info <- paste(info, collapse = "; ")
  [13:33:52.751]                       if (!has_future) {
  [13:33:52.751]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:33:52.751]                           info)
  [13:33:52.751]                       }
  [13:33:52.751]                       else {
  [13:33:52.751]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:33:52.751]                           info, version)
  [13:33:52.751]                       }
  [13:33:52.751]                       stop(msg)
  [13:33:52.751]                     }
  [13:33:52.751]                   }
  [13:33:52.751]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:33:52.751]                   options(mc.cores = 1L)
  [13:33:52.751]                 }
  [13:33:52.751]                 local({
  [13:33:52.751]                   for (pkg in c("doFuture", "future")) {
  [13:33:52.751]                     loadNamespace(pkg)
  [13:33:52.751]                     library(pkg, character.only = TRUE)
  [13:33:52.751]                   }
  [13:33:52.751]                 })
  [13:33:52.751]             }
  [13:33:52.751]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:33:52.751]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.751]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:33:52.751]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:33:52.751]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:33:52.751]                 ...) 
  [13:33:52.751]             {
  [13:33:52.751]                 if (substitute) 
  [13:33:52.751]                   expr <- substitute(expr)
  [13:33:52.751]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:52.751]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.751]                   globals = globals, persistent = persistent, 
  [13:33:52.751]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:52.751]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:52.751]                   label = label, ...)
  [13:33:52.751]                 if (!future$lazy) 
  [13:33:52.751]                   future <- run(future)
  [13:33:52.751]                 invisible(future)
  [13:33:52.751]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.751]         }
  [13:33:52.751]     }
  [13:33:52.751]     if (is.na(TRUE)) {
  [13:33:52.751]     }
  [13:33:52.751]     else {
  [13:33:52.751]         if (TRUE) {
  [13:33:52.751]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:33:52.751]         }
  [13:33:52.751]         else {
  [13:33:52.751]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:33:52.751]                 windows = "NUL", "/dev/null"), open = "w")
  [13:33:52.751]         }
  [13:33:52.751]         sink(...future.stdout, type = "output", split = FALSE)
  [13:33:52.751]         on.exit(if (!is.null(...future.stdout)) {
  [13:33:52.751]             sink(type = "output", split = FALSE)
  [13:33:52.751]             close(...future.stdout)
  [13:33:52.751]         }, add = TRUE)
  [13:33:52.751]     }
  [13:33:52.751]     ...future.frame <- sys.nframe()
  [13:33:52.751]     ...future.conditions <- list()
  [13:33:52.751]     ...future.result <- tryCatch({
  [13:33:52.751]         withCallingHandlers({
  [13:33:52.751]             ...future.value <- withVisible(local({
  [13:33:52.751]                 doFuture::registerDoFuture()
  [13:33:52.751]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:33:52.751]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:33:52.751]                   {
  [13:33:52.751]                     a <- NULL
  [13:33:52.751]                     b <- NULL
  [13:33:52.751]                   }
  [13:33:52.751]                   ...future.env <- environment()
  [13:33:52.751]                   local({
  [13:33:52.751]                     for (name in names(...future.x_jj)) {
  [13:33:52.751]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:33:52.751]                         inherits = FALSE)
  [13:33:52.751]                     }
  [13:33:52.751]                   })
  [13:33:52.751]                   tryCatch({
  [13:33:52.751]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:33:52.751]                       plan = future::plan())
  [13:33:52.751]                   }, error = identity)
  [13:33:52.751]                 })
  [13:33:52.751]             }))
  [13:33:52.751]             future::FutureResult(value = ...future.value$value, 
  [13:33:52.751]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:33:52.751]                 version = "1.8")
  [13:33:52.751]         }, condition = local({
  [13:33:52.751]             inherits <- base::inherits
  [13:33:52.751]             invokeRestart <- base::invokeRestart
  [13:33:52.751]             length <- base::length
  [13:33:52.751]             seq.int <- base::seq.int
  [13:33:52.751]             sys.calls <- base::sys.calls
  [13:33:52.751]             `[[` <- base::`[[`
  [13:33:52.751]             `+` <- base::`+`
  [13:33:52.751]             `<<-` <- base::`<<-`
  [13:33:52.751]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:33:52.751]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:33:52.751]                   3L)]
  [13:33:52.751]             }
  [13:33:52.751]             function(cond) {
  [13:33:52.751]                 if (inherits(cond, "error")) {
  [13:33:52.751]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.751]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:33:52.751]                     cond$call), timestamp = base::Sys.time(), 
  [13:33:52.751]                     signaled = 0L)
  [13:33:52.751]                   signalCondition(cond)
  [13:33:52.751]                 }
  [13:33:52.751]                 else if (inherits(cond, "condition")) {
  [13:33:52.751]                   signal <- FALSE && inherits(cond, character(0))
  [13:33:52.751]                   ...future.conditions[[length(...future.conditions) + 
  [13:33:52.751]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:33:52.751]                   if (!signal) {
  [13:33:52.751]                     muffleCondition <- function (cond) 
  [13:33:52.751]                     {
  [13:33:52.751]                       inherits <- base::inherits
  [13:33:52.751]                       invokeRestart <- base::invokeRestart
  [13:33:52.751]                       muffled <- FALSE
  [13:33:52.751]                       if (inherits(cond, "message")) {
  [13:33:52.751]                         invokeRestart("muffleMessage")
  [13:33:52.751]                         muffled <- TRUE
  [13:33:52.751]                       }
  [13:33:52.751]                       else if (inherits(cond, "warning")) {
  [13:33:52.751]                         invokeRestart("muffleWarning")
  [13:33:52.751]                         muffled <- TRUE
  [13:33:52.751]                       }
  [13:33:52.751]                       else if (inherits(cond, "condition")) {
  [13:33:52.751]                         computeRestarts <- base::computeRestarts
  [13:33:52.751]                         grepl <- base::grepl
  [13:33:52.751]                         is.null <- base::is.null
  [13:33:52.751]                         restarts <- computeRestarts(cond)
  [13:33:52.751]                         for (restart in restarts) {
  [13:33:52.751]                           name <- restart$name
  [13:33:52.751]                           if (is.null(name)) 
  [13:33:52.751]                             next
  [13:33:52.751]                           if (!grepl("^muffle", name)) 
  [13:33:52.751]                             next
  [13:33:52.751]                           invokeRestart(restart)
  [13:33:52.751]                           muffled <- TRUE
  [13:33:52.751]                           break
  [13:33:52.751]                         }
  [13:33:52.751]                       }
  [13:33:52.751]                       invisible(muffled)
  [13:33:52.751]                     }
  [13:33:52.751]                     muffleCondition(cond)
  [13:33:52.751]                   }
  [13:33:52.751]                 }
  [13:33:52.751]             }
  [13:33:52.751]         }))
  [13:33:52.751]     }, error = function(ex) {
  [13:33:52.751]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:33:52.751]             version = "1.8"), class = "FutureResult")
  [13:33:52.751]     }, finally = {
  [13:33:52.751]         {
  [13:33:52.751]             {
  [13:33:52.751]                 options(mc.cores = ...future.mc.cores.old)
  [13:33:52.751]             }
  [13:33:52.751]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:33:52.751]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:33:52.751]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:33:52.751]                 earlySignal = FALSE, label = NULL, ...) 
  [13:33:52.751]             {
  [13:33:52.751]                 if (substitute) 
  [13:33:52.751]                   expr <- substitute(expr)
  [13:33:52.751]                 if (is.function(workers)) 
  [13:33:52.751]                   workers <- workers()
  [13:33:52.751]                 workers <- as.integer(workers)
  [13:33:52.751]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:33:52.751]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:33:52.751]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:33:52.751]                     lazy = lazy, seed = seed, globals = globals, 
  [13:33:52.751]                     local = TRUE, label = label, ...))
  [13:33:52.751]                 }
  [13:33:52.751]                 oopts <- options(mc.cores = workers)
  [13:33:52.751]                 on.exit(options(oopts))
  [13:33:52.751]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:33:52.751]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.751]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:33:52.751]                   label = label, ...)
  [13:33:52.751]                 if (!future$lazy) 
  [13:33:52.751]                   future <- run(future)
  [13:33:52.751]                 invisible(future)
  [13:33:52.751]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:33:52.751]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:33:52.751]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:33:52.751]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:33:52.751]                 label = NULL, ...) 
  [13:33:52.751]             {
  [13:33:52.751]                 if (substitute) 
  [13:33:52.751]                   expr <- substitute(expr)
  [13:33:52.751]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:33:52.751]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:33:52.751]                   globals = globals, persistent = persistent, 
  [13:33:52.751]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:33:52.751]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:33:52.751]                   label = label, ...)
  [13:33:52.751]                 if (!future$lazy) 
  [13:33:52.751]                   future <- run(future)
  [13:33:52.751]                 invisible(future)
  [13:33:52.751]             }), .cleanup = FALSE, .init = FALSE)
  [13:33:52.751]         }
  [13:33:52.751]         options(...future.oldOptions)
  [13:33:52.751]     })
  [13:33:52.751]     if (is.na(TRUE)) {
  [13:33:52.751]     }
  [13:33:52.751]     else {
  [13:33:52.751]         sink(type = "output", split = FALSE)
  [13:33:52.751]         if (TRUE) {
  [13:33:52.751]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:33:52.751]         }
  [13:33:52.751]         else {
  [13:33:52.751]             ...future.result["stdout"] <- list(NULL)
  [13:33:52.751]         }
  [13:33:52.751]         close(...future.stdout)
  [13:33:52.751]         ...future.stdout <- NULL
  [13:33:52.751]     }
  [13:33:52.751]     ...future.result$conditions <- ...future.conditions
  [13:33:52.751]     ...future.result
  [13:33:52.751] }
  [13:33:52.773] requestCore(): workers = 2
  [13:33:52.777] MulticoreFuture started
  [13:33:52.777] Chunk #2 of 2 ... DONE
  [13:33:52.778] Launching 2 futures (chunks) ... DONE
  [13:33:52.778] - resolving futures
  [13:33:52.779]   - gathering results & relaying conditions (except errors)
  [13:33:52.779] resolve() on list ...
  [13:33:52.779]  recursive: 0
  [13:33:52.780]  length: 2
  [13:33:52.780] 
  [13:33:52.781] Future #1
  [13:33:52.784] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [13:33:52.784] - nx: 2
  [13:33:52.785] - relay: TRUE
  [13:33:52.785] - stdout: TRUE
  [13:33:52.785] - signal: TRUE
  [13:33:52.786] - resignal: FALSE
  [13:33:52.786] - force: FALSE
  [13:33:52.786] - relayed: [n=2] FALSE, FALSE
  [13:33:52.787] - queued futures: [n=2] FALSE, FALSE
  [13:33:52.787]  - until=1
  [13:33:52.788]  - relaying element #1
  [13:33:52.788] - relayed: [n=2] TRUE, FALSE
  [13:33:52.789] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.789] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [13:33:52.790]  length: 1 (resolved future 1)
  [13:33:52.791] plan(): Setting new future strategy stack:
  [13:33:52.792] List of future strategies:
  [13:33:52.792] 1. cluster:
  [13:33:52.792]    - 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, ...)
  [13:33:52.792]    - tweaked: FALSE
  [13:33:52.792]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.795] plan(): nbrOfWorkers() = 1
  [13:33:52.798] plan(): Setting new future strategy stack:
  [13:33:52.798] List of future strategies:
  [13:33:52.798] 1. multicore:
  [13:33:52.798]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:33:52.798]    - tweaked: FALSE
  [13:33:52.798]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.798] 2. cluster:
  [13:33:52.798]    - 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, ...)
  [13:33:52.798]    - tweaked: FALSE
  [13:33:52.798]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.801] plan(): nbrOfWorkers() = 2
  [13:33:52.819] Future #2
  [13:33:52.821] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [13:33:52.822] - nx: 2
  [13:33:52.822] - relay: TRUE
  [13:33:52.822] - stdout: TRUE
  [13:33:52.823] - signal: TRUE
  [13:33:52.823] - resignal: FALSE
  [13:33:52.823] - force: FALSE
  [13:33:52.824] - relayed: [n=2] TRUE, FALSE
  [13:33:52.824] - queued futures: [n=2] TRUE, FALSE
  [13:33:52.824]  - until=2
  [13:33:52.825]  - relaying element #2
  [13:33:52.825] - relayed: [n=2] TRUE, TRUE
  [13:33:52.826] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.826] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [13:33:52.826]  length: 0 (resolved future 2)
  [13:33:52.827] Relaying remaining futures
  [13:33:52.827] signalConditionsASAP(NULL, pos=0) ...
  [13:33:52.827] - nx: 2
  [13:33:52.828] - relay: TRUE
  [13:33:52.828] - stdout: TRUE
  [13:33:52.828] - signal: TRUE
  [13:33:52.829] - resignal: FALSE
  [13:33:52.829] - force: FALSE
  [13:33:52.829] - relayed: [n=2] TRUE, TRUE
  [13:33:52.829] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:33:52.830] - relayed: [n=2] TRUE, TRUE
  [13:33:52.830] - queued futures: [n=2] TRUE, TRUE
  [13:33:52.831] signalConditionsASAP(NULL, pos=0) ... done
  [13:33:52.831] resolve() on list ... DONE
  [13:33:52.831] - collecting values of futures
  [13:33:52.832] - accumulating results
  [13:33:52.851] - processing errors (handler = 'stop')
  [13:33:52.851] - extracting results
  [13:33:52.852] doFuture() ... DONE
  - plan(list('multicore', 'cluster')) ... DONE
  - plan(list('multisession', 'sequential')) ...
  [13:33:52.853] plan(): Setting new future strategy stack:
  [13:33:52.853] List of future strategies:
  [13:33:52.853] 1. multisession:
  [13:33:52.853]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.853]    - tweaked: FALSE
  [13:33:52.853]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.853] 2. sequential:
  [13:33:52.853]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.853]    - tweaked: FALSE
  [13:33:52.853]    - call: plan(list(a = strategy1, b = strategy2))
  [13:33:52.855] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [13:33:52.855] multisession:
  [13:33:52.855] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:33:52.855] - tweaked: FALSE
  [13:33:52.855] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 36609
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d341e757c.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d341e757c.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d341e757c.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36609 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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d776974e9.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d776974e9.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d776974e9.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36609 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
  [13:34:08.577] getGlobalsAndPackages() ...
  [13:34:08.578] Not searching for globals
  [13:34:08.578] - globals: [0] <none>
  [13:34:08.579] getGlobalsAndPackages() ... DONE
  [13:34:08.581] Packages needed by the future expression (n = 0): <none>
  [13:34:08.582] Packages needed by future strategies (n = 1): 'future'
  [13:34:08.599] {
  [13:34:08.599]     {
  [13:34:08.599]         ...future.startTime <- Sys.time()
  [13:34:08.599]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:08.599]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:08.599]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:08.599]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:08.599]             future.resolve.recursive = NULL, width = 80L)
  [13:34:08.599]         {
  [13:34:08.599]             {
  [13:34:08.599]                 {
  [13:34:08.599]                   {
  [13:34:08.599]                     has_future <- requireNamespace("future", 
  [13:34:08.599]                       quietly = TRUE)
  [13:34:08.599]                     version <- if (has_future) 
  [13:34:08.599]                       packageVersion("future")
  [13:34:08.599]                     else NULL
  [13:34:08.599]                     if (!has_future || version < "1.8.0") {
  [13:34:08.599]                       info <- c(r_version = gsub("R version ", 
  [13:34:08.599]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:08.599]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:08.599]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:08.599]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:08.599]                       info <- sprintf("%s: %s", names(info), 
  [13:34:08.599]                         info)
  [13:34:08.599]                       info <- paste(info, collapse = "; ")
  [13:34:08.599]                       if (!has_future) {
  [13:34:08.599]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:08.599]                           info)
  [13:34:08.599]                       }
  [13:34:08.599]                       else {
  [13:34:08.599]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:08.599]                           info, version)
  [13:34:08.599]                       }
  [13:34:08.599]                       stop(msg)
  [13:34:08.599]                     }
  [13:34:08.599]                   }
  [13:34:08.599]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:08.599]                   options(mc.cores = 1L)
  [13:34:08.599]                 }
  [13:34:08.599]                 local({
  [13:34:08.599]                   for (pkg in "future") {
  [13:34:08.599]                     loadNamespace(pkg)
  [13:34:08.599]                     library(pkg, character.only = TRUE)
  [13:34:08.599]                   }
  [13:34:08.599]                 })
  [13:34:08.599]             }
  [13:34:08.599]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:08.599]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:08.599]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:34:08.599]                 label = NULL, ...) 
  [13:34:08.599]             {
  [13:34:08.599]                 if (substitute) 
  [13:34:08.599]                   expr <- substitute(expr)
  [13:34:08.599]                 local <- as.logical(local)
  [13:34:08.599]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:08.599]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.599]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:08.599]                   label = label, ...)
  [13:34:08.599]                 if (!future$lazy) 
  [13:34:08.599]                   future <- run(future)
  [13:34:08.599]                 invisible(future)
  [13:34:08.599]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:08.599]         }
  [13:34:08.599]     }
  [13:34:08.599]     if (is.na(TRUE)) {
  [13:34:08.599]     }
  [13:34:08.599]     else {
  [13:34:08.599]         if (TRUE) {
  [13:34:08.599]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:08.599]         }
  [13:34:08.599]         else {
  [13:34:08.599]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:08.599]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:08.599]         }
  [13:34:08.599]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:08.599]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:08.599]             sink(type = "output", split = FALSE)
  [13:34:08.599]             close(...future.stdout)
  [13:34:08.599]         }, add = TRUE)
  [13:34:08.599]     }
  [13:34:08.599]     ...future.frame <- sys.nframe()
  [13:34:08.599]     ...future.conditions <- list()
  [13:34:08.599]     ...future.result <- tryCatch({
  [13:34:08.599]         withCallingHandlers({
  [13:34:08.599]             ...future.value <- withVisible(local(NA))
  [13:34:08.599]             future::FutureResult(value = ...future.value$value, 
  [13:34:08.599]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:08.599]                 version = "1.8")
  [13:34:08.599]         }, condition = local({
  [13:34:08.599]             inherits <- base::inherits
  [13:34:08.599]             invokeRestart <- base::invokeRestart
  [13:34:08.599]             length <- base::length
  [13:34:08.599]             seq.int <- base::seq.int
  [13:34:08.599]             sys.calls <- base::sys.calls
  [13:34:08.599]             `[[` <- base::`[[`
  [13:34:08.599]             `+` <- base::`+`
  [13:34:08.599]             `<<-` <- base::`<<-`
  [13:34:08.599]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:08.599]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:08.599]                   3L)]
  [13:34:08.599]             }
  [13:34:08.599]             function(cond) {
  [13:34:08.599]                 if (inherits(cond, "error")) {
  [13:34:08.599]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:08.599]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:08.599]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:08.599]                     signaled = 0L)
  [13:34:08.599]                   signalCondition(cond)
  [13:34:08.599]                 }
  [13:34:08.599]                 else if (inherits(cond, "condition")) {
  [13:34:08.599]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:08.599]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:08.599]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:08.599]                   if (!signal) {
  [13:34:08.599]                     muffleCondition <- function (cond) 
  [13:34:08.599]                     {
  [13:34:08.599]                       inherits <- base::inherits
  [13:34:08.599]                       invokeRestart <- base::invokeRestart
  [13:34:08.599]                       muffled <- FALSE
  [13:34:08.599]                       if (inherits(cond, "message")) {
  [13:34:08.599]                         invokeRestart("muffleMessage")
  [13:34:08.599]                         muffled <- TRUE
  [13:34:08.599]                       }
  [13:34:08.599]                       else if (inherits(cond, "warning")) {
  [13:34:08.599]                         invokeRestart("muffleWarning")
  [13:34:08.599]                         muffled <- TRUE
  [13:34:08.599]                       }
  [13:34:08.599]                       else if (inherits(cond, "condition")) {
  [13:34:08.599]                         computeRestarts <- base::computeRestarts
  [13:34:08.599]                         grepl <- base::grepl
  [13:34:08.599]                         is.null <- base::is.null
  [13:34:08.599]                         restarts <- computeRestarts(cond)
  [13:34:08.599]                         for (restart in restarts) {
  [13:34:08.599]                           name <- restart$name
  [13:34:08.599]                           if (is.null(name)) 
  [13:34:08.599]                             next
  [13:34:08.599]                           if (!grepl("^muffle", name)) 
  [13:34:08.599]                             next
  [13:34:08.599]                           invokeRestart(restart)
  [13:34:08.599]                           muffled <- TRUE
  [13:34:08.599]                           break
  [13:34:08.599]                         }
  [13:34:08.599]                       }
  [13:34:08.599]                       invisible(muffled)
  [13:34:08.599]                     }
  [13:34:08.599]                     muffleCondition(cond)
  [13:34:08.599]                   }
  [13:34:08.599]                 }
  [13:34:08.599]             }
  [13:34:08.599]         }))
  [13:34:08.599]     }, error = function(ex) {
  [13:34:08.599]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:08.599]             version = "1.8"), class = "FutureResult")
  [13:34:08.599]     }, finally = {
  [13:34:08.599]         {
  [13:34:08.599]             {
  [13:34:08.599]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:08.599]             }
  [13:34:08.599]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:08.599]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:08.599]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:08.599]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:08.599]                 ...) 
  [13:34:08.599]             {
  [13:34:08.599]                 if (substitute) 
  [13:34:08.599]                   expr <- substitute(expr)
  [13:34:08.599]                 if (is.function(workers)) 
  [13:34:08.599]                   workers <- workers()
  [13:34:08.599]                 workers <- as.integer(workers)
  [13:34:08.599]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:08.599]                   workers >= 1)
  [13:34:08.599]                 if (workers == 1L) {
  [13:34:08.599]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:08.599]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:08.599]                     local = TRUE, label = label, ...))
  [13:34:08.599]                 }
  [13:34:08.599]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:08.599]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:08.599]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.599]                   globals = globals, persistent = persistent, 
  [13:34:08.599]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:08.599]                   label = label, ...)
  [13:34:08.599]                 if (!future$lazy) 
  [13:34:08.599]                   future <- run(future)
  [13:34:08.599]                 invisible(future)
  [13:34:08.599]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:08.599]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:34:08.599]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:08.599]             {
  [13:34:08.599]                 if (substitute) 
  [13:34:08.599]                   expr <- substitute(expr)
  [13:34:08.599]                 local <- as.logical(local)
  [13:34:08.599]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:08.599]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.599]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:08.599]                   label = label, ...)
  [13:34:08.599]                 if (!future$lazy) 
  [13:34:08.599]                   future <- run(future)
  [13:34:08.599]                 invisible(future)
  [13:34:08.599]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:08.599]         }
  [13:34:08.599]         options(...future.oldOptions)
  [13:34:08.599]     })
  [13:34:08.599]     if (is.na(TRUE)) {
  [13:34:08.599]     }
  [13:34:08.599]     else {
  [13:34:08.599]         sink(type = "output", split = FALSE)
  [13:34:08.599]         if (TRUE) {
  [13:34:08.599]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:08.599]         }
  [13:34:08.599]         else {
  [13:34:08.599]             ...future.result["stdout"] <- list(NULL)
  [13:34:08.599]         }
  [13:34:08.599]         close(...future.stdout)
  [13:34:08.599]         ...future.stdout <- NULL
  [13:34:08.599]     }
  [13:34:08.599]     ...future.result$conditions <- ...future.conditions
  [13:34:08.599]     ...future.result
  [13:34:08.599] }
  [13:34:08.622] MultisessionFuture started
  [13:34:08.624] result() for ClusterFuture ...
  [13:34:08.624] - Validating connection of MultisessionFuture
  [13:34:08.885] - class(result): FutureResult
  [13:34:08.886] result() for ClusterFuture ...
  [13:34:08.886] - result already collected: FutureResult
  [13:34:08.886] result() for ClusterFuture ... done
  [13:34:08.887] result() for ClusterFuture ... done
  [13:34:08.887] result() for ClusterFuture ...
  [13:34:08.887] - result already collected: FutureResult
  [13:34:08.888] result() for ClusterFuture ... done
  [13:34:08.888] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [13:34:08.889] plan(): nbrOfWorkers() = 2
  [13:34:08.890] doFuture() ...
  [13:34:08.894] - dummy globals (as locals): [2] 'a', 'b'
  [13:34:08.895] - R expression:
  [13:34:08.895] {
  [13:34:08.895]     doFuture::registerDoFuture()
  [13:34:08.895]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:08.895]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:08.895]         {
  [13:34:08.895]             a <- NULL
  [13:34:08.895]             b <- NULL
  [13:34:08.895]         }
  [13:34:08.895]         ...future.env <- environment()
  [13:34:08.895]         local({
  [13:34:08.895]             for (name in names(...future.x_jj)) {
  [13:34:08.895]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:08.895]                   inherits = FALSE)
  [13:34:08.895]             }
  [13:34:08.895]         })
  [13:34:08.895]         tryCatch({
  [13:34:08.895]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:08.895]                 plan = future::plan())
  [13:34:08.895]         }, error = identity)
  [13:34:08.895]     })
  [13:34:08.895] }
  [13:34:08.896] - identifying globals and packages ...
  [13:34:08.896] getGlobalsAndPackages() ...
  [13:34:08.897] Searching for globals...
  [13:34:08.918] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:34:08.934] Searching for globals ... DONE
  [13:34:08.935] Resolving globals: FALSE
  [13:34:08.937] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:34:08.937] - globals: [1] '...future.x_ii'
  [13:34:08.937] 
  [13:34:08.938] getGlobalsAndPackages() ... DONE
  [13:34:08.938] List of 1
  [13:34:08.938]  $ ...future.x_ii: NULL
  [13:34:08.938]  - attr(*, "where")=List of 1
  [13:34:08.938]   ..$ ...future.x_ii:<environment: 0x563b854bed80> 
  [13:34:08.938]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:08.938]  - attr(*, "resolved")= logi FALSE
  [13:34:08.938]  - attr(*, "total_size")= num 0
  [13:34:08.951]   - R expression:
  [13:34:08.951] {
  [13:34:08.951]     doFuture::registerDoFuture()
  [13:34:08.951]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:08.951]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:08.951]         {
  [13:34:08.951]             a <- NULL
  [13:34:08.951]             b <- NULL
  [13:34:08.951]         }
  [13:34:08.951]         ...future.env <- environment()
  [13:34:08.951]         local({
  [13:34:08.951]             for (name in names(...future.x_jj)) {
  [13:34:08.951]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:08.951]                   inherits = FALSE)
  [13:34:08.951]             }
  [13:34:08.951]         })
  [13:34:08.951]         tryCatch({
  [13:34:08.951]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:08.951]                 plan = future::plan())
  [13:34:08.951]         }, error = identity)
  [13:34:08.951]     })
  [13:34:08.951] }
  [13:34:08.952]   - globals: [1] '...future.x_ii'
  [13:34:08.952] List of 1
  [13:34:08.952]  $ ...future.x_ii: NULL
  [13:34:08.952]  - attr(*, "where")=List of 1
  [13:34:08.952]   ..$ ...future.x_ii:<environment: 0x563b854bed80> 
  [13:34:08.952]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:08.952]  - attr(*, "resolved")= logi FALSE
  [13:34:08.952]  - attr(*, "total_size")= num 0
  [13:34:08.958]   - packages: [1] 'doFuture'
  [13:34:08.959] - identifying globals and packages ... DONE
  [13:34:08.960] Number of chunks: 2
  [13:34:08.960] Number of futures (= number of chunks): 2
  [13:34:08.961] Launching 2 futures (chunks) ...
  [13:34:08.961] Chunk #1 of 2 ...
  [13:34:08.961]  - Finding globals in 'args_list' chunk #1 ...
  [13:34:08.962] getGlobalsAndPackages() ...
  [13:34:08.962] Searching for globals...
  [13:34:08.964] 
  [13:34:08.964] Searching for globals ... DONE
  [13:34:08.965] - globals: [0] <none>
  [13:34:08.965] getGlobalsAndPackages() ... DONE
  [13:34:08.965] 
  [13:34:08.966] 
  [13:34:08.966]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:34:08.974] getGlobalsAndPackages() ...
  [13:34:08.975] - globals passed as-is: [1] '...future.x_ii'
  [13:34:08.976] Resolving globals: FALSE
  [13:34:08.977] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:08.977] - globals: [1] '...future.x_ii'
  [13:34:08.978] 
  [13:34:08.978] getGlobalsAndPackages() ... DONE
  [13:34:08.980] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:08.980] Packages needed by future strategies (n = 1): 'future'
  [13:34:08.985] {
  [13:34:08.985]     {
  [13:34:08.985]         ...future.startTime <- Sys.time()
  [13:34:08.985]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:08.985]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:08.985]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:08.985]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:08.985]             future.resolve.recursive = NULL, width = 80L)
  [13:34:08.985]         {
  [13:34:08.985]             {
  [13:34:08.985]                 {
  [13:34:08.985]                   {
  [13:34:08.985]                     has_future <- requireNamespace("future", 
  [13:34:08.985]                       quietly = TRUE)
  [13:34:08.985]                     version <- if (has_future) 
  [13:34:08.985]                       packageVersion("future")
  [13:34:08.985]                     else NULL
  [13:34:08.985]                     if (!has_future || version < "1.8.0") {
  [13:34:08.985]                       info <- c(r_version = gsub("R version ", 
  [13:34:08.985]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:08.985]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:08.985]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:08.985]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:08.985]                       info <- sprintf("%s: %s", names(info), 
  [13:34:08.985]                         info)
  [13:34:08.985]                       info <- paste(info, collapse = "; ")
  [13:34:08.985]                       if (!has_future) {
  [13:34:08.985]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:08.985]                           info)
  [13:34:08.985]                       }
  [13:34:08.985]                       else {
  [13:34:08.985]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:08.985]                           info, version)
  [13:34:08.985]                       }
  [13:34:08.985]                       stop(msg)
  [13:34:08.985]                     }
  [13:34:08.985]                   }
  [13:34:08.985]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:08.985]                   options(mc.cores = 1L)
  [13:34:08.985]                 }
  [13:34:08.985]                 local({
  [13:34:08.985]                   for (pkg in c("doFuture", "future")) {
  [13:34:08.985]                     loadNamespace(pkg)
  [13:34:08.985]                     library(pkg, character.only = TRUE)
  [13:34:08.985]                   }
  [13:34:08.985]                 })
  [13:34:08.985]             }
  [13:34:08.985]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:08.985]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:08.985]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:34:08.985]                 label = NULL, ...) 
  [13:34:08.985]             {
  [13:34:08.985]                 if (substitute) 
  [13:34:08.985]                   expr <- substitute(expr)
  [13:34:08.985]                 local <- as.logical(local)
  [13:34:08.985]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:08.985]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.985]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:08.985]                   label = label, ...)
  [13:34:08.985]                 if (!future$lazy) 
  [13:34:08.985]                   future <- run(future)
  [13:34:08.985]                 invisible(future)
  [13:34:08.985]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:08.985]         }
  [13:34:08.985]     }
  [13:34:08.985]     if (is.na(TRUE)) {
  [13:34:08.985]     }
  [13:34:08.985]     else {
  [13:34:08.985]         if (TRUE) {
  [13:34:08.985]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:08.985]         }
  [13:34:08.985]         else {
  [13:34:08.985]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:08.985]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:08.985]         }
  [13:34:08.985]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:08.985]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:08.985]             sink(type = "output", split = FALSE)
  [13:34:08.985]             close(...future.stdout)
  [13:34:08.985]         }, add = TRUE)
  [13:34:08.985]     }
  [13:34:08.985]     ...future.frame <- sys.nframe()
  [13:34:08.985]     ...future.conditions <- list()
  [13:34:08.985]     ...future.result <- tryCatch({
  [13:34:08.985]         withCallingHandlers({
  [13:34:08.985]             ...future.value <- withVisible(local({
  [13:34:08.985]                 doFuture::registerDoFuture()
  [13:34:08.985]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:08.985]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:08.985]                   {
  [13:34:08.985]                     a <- NULL
  [13:34:08.985]                     b <- NULL
  [13:34:08.985]                   }
  [13:34:08.985]                   ...future.env <- environment()
  [13:34:08.985]                   local({
  [13:34:08.985]                     for (name in names(...future.x_jj)) {
  [13:34:08.985]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:08.985]                         inherits = FALSE)
  [13:34:08.985]                     }
  [13:34:08.985]                   })
  [13:34:08.985]                   tryCatch({
  [13:34:08.985]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:08.985]                       plan = future::plan())
  [13:34:08.985]                   }, error = identity)
  [13:34:08.985]                 })
  [13:34:08.985]             }))
  [13:34:08.985]             future::FutureResult(value = ...future.value$value, 
  [13:34:08.985]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:08.985]                 version = "1.8")
  [13:34:08.985]         }, condition = local({
  [13:34:08.985]             inherits <- base::inherits
  [13:34:08.985]             invokeRestart <- base::invokeRestart
  [13:34:08.985]             length <- base::length
  [13:34:08.985]             seq.int <- base::seq.int
  [13:34:08.985]             sys.calls <- base::sys.calls
  [13:34:08.985]             `[[` <- base::`[[`
  [13:34:08.985]             `+` <- base::`+`
  [13:34:08.985]             `<<-` <- base::`<<-`
  [13:34:08.985]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:08.985]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:08.985]                   3L)]
  [13:34:08.985]             }
  [13:34:08.985]             function(cond) {
  [13:34:08.985]                 if (inherits(cond, "error")) {
  [13:34:08.985]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:08.985]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:08.985]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:08.985]                     signaled = 0L)
  [13:34:08.985]                   signalCondition(cond)
  [13:34:08.985]                 }
  [13:34:08.985]                 else if (inherits(cond, "condition")) {
  [13:34:08.985]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:08.985]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:08.985]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:08.985]                   if (!signal) {
  [13:34:08.985]                     muffleCondition <- function (cond) 
  [13:34:08.985]                     {
  [13:34:08.985]                       inherits <- base::inherits
  [13:34:08.985]                       invokeRestart <- base::invokeRestart
  [13:34:08.985]                       muffled <- FALSE
  [13:34:08.985]                       if (inherits(cond, "message")) {
  [13:34:08.985]                         invokeRestart("muffleMessage")
  [13:34:08.985]                         muffled <- TRUE
  [13:34:08.985]                       }
  [13:34:08.985]                       else if (inherits(cond, "warning")) {
  [13:34:08.985]                         invokeRestart("muffleWarning")
  [13:34:08.985]                         muffled <- TRUE
  [13:34:08.985]                       }
  [13:34:08.985]                       else if (inherits(cond, "condition")) {
  [13:34:08.985]                         computeRestarts <- base::computeRestarts
  [13:34:08.985]                         grepl <- base::grepl
  [13:34:08.985]                         is.null <- base::is.null
  [13:34:08.985]                         restarts <- computeRestarts(cond)
  [13:34:08.985]                         for (restart in restarts) {
  [13:34:08.985]                           name <- restart$name
  [13:34:08.985]                           if (is.null(name)) 
  [13:34:08.985]                             next
  [13:34:08.985]                           if (!grepl("^muffle", name)) 
  [13:34:08.985]                             next
  [13:34:08.985]                           invokeRestart(restart)
  [13:34:08.985]                           muffled <- TRUE
  [13:34:08.985]                           break
  [13:34:08.985]                         }
  [13:34:08.985]                       }
  [13:34:08.985]                       invisible(muffled)
  [13:34:08.985]                     }
  [13:34:08.985]                     muffleCondition(cond)
  [13:34:08.985]                   }
  [13:34:08.985]                 }
  [13:34:08.985]             }
  [13:34:08.985]         }))
  [13:34:08.985]     }, error = function(ex) {
  [13:34:08.985]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:08.985]             version = "1.8"), class = "FutureResult")
  [13:34:08.985]     }, finally = {
  [13:34:08.985]         {
  [13:34:08.985]             {
  [13:34:08.985]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:08.985]             }
  [13:34:08.985]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:08.985]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:08.985]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:08.985]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:08.985]                 ...) 
  [13:34:08.985]             {
  [13:34:08.985]                 if (substitute) 
  [13:34:08.985]                   expr <- substitute(expr)
  [13:34:08.985]                 if (is.function(workers)) 
  [13:34:08.985]                   workers <- workers()
  [13:34:08.985]                 workers <- as.integer(workers)
  [13:34:08.985]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:08.985]                   workers >= 1)
  [13:34:08.985]                 if (workers == 1L) {
  [13:34:08.985]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:08.985]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:08.985]                     local = TRUE, label = label, ...))
  [13:34:08.985]                 }
  [13:34:08.985]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:08.985]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:08.985]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.985]                   globals = globals, persistent = persistent, 
  [13:34:08.985]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:08.985]                   label = label, ...)
  [13:34:08.985]                 if (!future$lazy) 
  [13:34:08.985]                   future <- run(future)
  [13:34:08.985]                 invisible(future)
  [13:34:08.985]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:08.985]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:34:08.985]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:08.985]             {
  [13:34:08.985]                 if (substitute) 
  [13:34:08.985]                   expr <- substitute(expr)
  [13:34:08.985]                 local <- as.logical(local)
  [13:34:08.985]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:08.985]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:08.985]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:08.985]                   label = label, ...)
  [13:34:08.985]                 if (!future$lazy) 
  [13:34:08.985]                   future <- run(future)
  [13:34:08.985]                 invisible(future)
  [13:34:08.985]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:08.985]         }
  [13:34:08.985]         options(...future.oldOptions)
  [13:34:08.985]     })
  [13:34:08.985]     if (is.na(TRUE)) {
  [13:34:08.985]     }
  [13:34:08.985]     else {
  [13:34:08.985]         sink(type = "output", split = FALSE)
  [13:34:08.985]         if (TRUE) {
  [13:34:08.985]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:08.985]         }
  [13:34:08.985]         else {
  [13:34:08.985]             ...future.result["stdout"] <- list(NULL)
  [13:34:08.985]         }
  [13:34:08.985]         close(...future.stdout)
  [13:34:08.985]         ...future.stdout <- NULL
  [13:34:08.985]     }
  [13:34:08.985]     ...future.result$conditions <- ...future.conditions
  [13:34:08.985]     ...future.result
  [13:34:08.985] }
  [13:34:08.991] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [13:34:08.991] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [13:34:08.992] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [13:34:08.993] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [13:34:08.994] MultisessionFuture started
  [13:34:08.995] Chunk #1 of 2 ... DONE
  [13:34:08.995] Chunk #2 of 2 ...
  [13:34:08.995]  - Finding globals in 'args_list' chunk #2 ...
  [13:34:08.995] getGlobalsAndPackages() ...
  [13:34:08.996] Searching for globals...
  [13:34:08.997] 
  [13:34:08.997] Searching for globals ... DONE
  [13:34:08.998] - globals: [0] <none>
  [13:34:08.998] getGlobalsAndPackages() ... DONE
  [13:34:08.999] 
  [13:34:08.999] 
  [13:34:09.000]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:34:09.008] getGlobalsAndPackages() ...
  [13:34:09.009] - globals passed as-is: [1] '...future.x_ii'
  [13:34:09.009] Resolving globals: FALSE
  [13:34:09.010] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:09.011] - globals: [1] '...future.x_ii'
  [13:34:09.011] 
  [13:34:09.012] getGlobalsAndPackages() ... DONE
  [13:34:09.014] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:09.014] Packages needed by future strategies (n = 1): 'future'
  [13:34:09.024] {
  [13:34:09.024]     {
  [13:34:09.024]         ...future.startTime <- Sys.time()
  [13:34:09.024]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:09.024]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:09.024]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:09.024]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:09.024]             future.resolve.recursive = NULL, width = 80L)
  [13:34:09.024]         {
  [13:34:09.024]             {
  [13:34:09.024]                 {
  [13:34:09.024]                   {
  [13:34:09.024]                     has_future <- requireNamespace("future", 
  [13:34:09.024]                       quietly = TRUE)
  [13:34:09.024]                     version <- if (has_future) 
  [13:34:09.024]                       packageVersion("future")
  [13:34:09.024]                     else NULL
  [13:34:09.024]                     if (!has_future || version < "1.8.0") {
  [13:34:09.024]                       info <- c(r_version = gsub("R version ", 
  [13:34:09.024]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:09.024]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:09.024]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:09.024]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:09.024]                       info <- sprintf("%s: %s", names(info), 
  [13:34:09.024]                         info)
  [13:34:09.024]                       info <- paste(info, collapse = "; ")
  [13:34:09.024]                       if (!has_future) {
  [13:34:09.024]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:09.024]                           info)
  [13:34:09.024]                       }
  [13:34:09.024]                       else {
  [13:34:09.024]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:09.024]                           info, version)
  [13:34:09.024]                       }
  [13:34:09.024]                       stop(msg)
  [13:34:09.024]                     }
  [13:34:09.024]                   }
  [13:34:09.024]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:09.024]                   options(mc.cores = 1L)
  [13:34:09.024]                 }
  [13:34:09.024]                 local({
  [13:34:09.024]                   for (pkg in c("doFuture", "future")) {
  [13:34:09.024]                     loadNamespace(pkg)
  [13:34:09.024]                     library(pkg, character.only = TRUE)
  [13:34:09.024]                   }
  [13:34:09.024]                 })
  [13:34:09.024]             }
  [13:34:09.024]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:09.024]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:09.024]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [13:34:09.024]                 label = NULL, ...) 
  [13:34:09.024]             {
  [13:34:09.024]                 if (substitute) 
  [13:34:09.024]                   expr <- substitute(expr)
  [13:34:09.024]                 local <- as.logical(local)
  [13:34:09.024]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:09.024]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:09.024]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:09.024]                   label = label, ...)
  [13:34:09.024]                 if (!future$lazy) 
  [13:34:09.024]                   future <- run(future)
  [13:34:09.024]                 invisible(future)
  [13:34:09.024]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:09.024]         }
  [13:34:09.024]     }
  [13:34:09.024]     if (is.na(TRUE)) {
  [13:34:09.024]     }
  [13:34:09.024]     else {
  [13:34:09.024]         if (TRUE) {
  [13:34:09.024]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:09.024]         }
  [13:34:09.024]         else {
  [13:34:09.024]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:09.024]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:09.024]         }
  [13:34:09.024]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:09.024]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:09.024]             sink(type = "output", split = FALSE)
  [13:34:09.024]             close(...future.stdout)
  [13:34:09.024]         }, add = TRUE)
  [13:34:09.024]     }
  [13:34:09.024]     ...future.frame <- sys.nframe()
  [13:34:09.024]     ...future.conditions <- list()
  [13:34:09.024]     ...future.result <- tryCatch({
  [13:34:09.024]         withCallingHandlers({
  [13:34:09.024]             ...future.value <- withVisible(local({
  [13:34:09.024]                 doFuture::registerDoFuture()
  [13:34:09.024]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:09.024]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:09.024]                   {
  [13:34:09.024]                     a <- NULL
  [13:34:09.024]                     b <- NULL
  [13:34:09.024]                   }
  [13:34:09.024]                   ...future.env <- environment()
  [13:34:09.024]                   local({
  [13:34:09.024]                     for (name in names(...future.x_jj)) {
  [13:34:09.024]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:09.024]                         inherits = FALSE)
  [13:34:09.024]                     }
  [13:34:09.024]                   })
  [13:34:09.024]                   tryCatch({
  [13:34:09.024]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:09.024]                       plan = future::plan())
  [13:34:09.024]                   }, error = identity)
  [13:34:09.024]                 })
  [13:34:09.024]             }))
  [13:34:09.024]             future::FutureResult(value = ...future.value$value, 
  [13:34:09.024]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:09.024]                 version = "1.8")
  [13:34:09.024]         }, condition = local({
  [13:34:09.024]             inherits <- base::inherits
  [13:34:09.024]             invokeRestart <- base::invokeRestart
  [13:34:09.024]             length <- base::length
  [13:34:09.024]             seq.int <- base::seq.int
  [13:34:09.024]             sys.calls <- base::sys.calls
  [13:34:09.024]             `[[` <- base::`[[`
  [13:34:09.024]             `+` <- base::`+`
  [13:34:09.024]             `<<-` <- base::`<<-`
  [13:34:09.024]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:09.024]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:09.024]                   3L)]
  [13:34:09.024]             }
  [13:34:09.024]             function(cond) {
  [13:34:09.024]                 if (inherits(cond, "error")) {
  [13:34:09.024]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:09.024]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:09.024]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:09.024]                     signaled = 0L)
  [13:34:09.024]                   signalCondition(cond)
  [13:34:09.024]                 }
  [13:34:09.024]                 else if (inherits(cond, "condition")) {
  [13:34:09.024]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:09.024]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:09.024]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:09.024]                   if (!signal) {
  [13:34:09.024]                     muffleCondition <- function (cond) 
  [13:34:09.024]                     {
  [13:34:09.024]                       inherits <- base::inherits
  [13:34:09.024]                       invokeRestart <- base::invokeRestart
  [13:34:09.024]                       muffled <- FALSE
  [13:34:09.024]                       if (inherits(cond, "message")) {
  [13:34:09.024]                         invokeRestart("muffleMessage")
  [13:34:09.024]                         muffled <- TRUE
  [13:34:09.024]                       }
  [13:34:09.024]                       else if (inherits(cond, "warning")) {
  [13:34:09.024]                         invokeRestart("muffleWarning")
  [13:34:09.024]                         muffled <- TRUE
  [13:34:09.024]                       }
  [13:34:09.024]                       else if (inherits(cond, "condition")) {
  [13:34:09.024]                         computeRestarts <- base::computeRestarts
  [13:34:09.024]                         grepl <- base::grepl
  [13:34:09.024]                         is.null <- base::is.null
  [13:34:09.024]                         restarts <- computeRestarts(cond)
  [13:34:09.024]                         for (restart in restarts) {
  [13:34:09.024]                           name <- restart$name
  [13:34:09.024]                           if (is.null(name)) 
  [13:34:09.024]                             next
  [13:34:09.024]                           if (!grepl("^muffle", name)) 
  [13:34:09.024]                             next
  [13:34:09.024]                           invokeRestart(restart)
  [13:34:09.024]                           muffled <- TRUE
  [13:34:09.024]                           break
  [13:34:09.024]                         }
  [13:34:09.024]                       }
  [13:34:09.024]                       invisible(muffled)
  [13:34:09.024]                     }
  [13:34:09.024]                     muffleCondition(cond)
  [13:34:09.024]                   }
  [13:34:09.024]                 }
  [13:34:09.024]             }
  [13:34:09.024]         }))
  [13:34:09.024]     }, error = function(ex) {
  [13:34:09.024]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:09.024]             version = "1.8"), class = "FutureResult")
  [13:34:09.024]     }, finally = {
  [13:34:09.024]         {
  [13:34:09.024]             {
  [13:34:09.024]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:09.024]             }
  [13:34:09.024]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:09.024]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:09.024]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:09.024]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:09.024]                 ...) 
  [13:34:09.024]             {
  [13:34:09.024]                 if (substitute) 
  [13:34:09.024]                   expr <- substitute(expr)
  [13:34:09.024]                 if (is.function(workers)) 
  [13:34:09.024]                   workers <- workers()
  [13:34:09.024]                 workers <- as.integer(workers)
  [13:34:09.024]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:09.024]                   workers >= 1)
  [13:34:09.024]                 if (workers == 1L) {
  [13:34:09.024]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:09.024]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:09.024]                     local = TRUE, label = label, ...))
  [13:34:09.024]                 }
  [13:34:09.024]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:09.024]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:09.024]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:09.024]                   globals = globals, persistent = persistent, 
  [13:34:09.024]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:09.024]                   label = label, ...)
  [13:34:09.024]                 if (!future$lazy) 
  [13:34:09.024]                   future <- run(future)
  [13:34:09.024]                 invisible(future)
  [13:34:09.024]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:09.024]                 lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
  [13:34:09.024]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:09.024]             {
  [13:34:09.024]                 if (substitute) 
  [13:34:09.024]                   expr <- substitute(expr)
  [13:34:09.024]                 local <- as.logical(local)
  [13:34:09.024]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [13:34:09.024]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:09.024]                   globals = globals, local = local, earlySignal = earlySignal, 
  [13:34:09.024]                   label = label, ...)
  [13:34:09.024]                 if (!future$lazy) 
  [13:34:09.024]                   future <- run(future)
  [13:34:09.024]                 invisible(future)
  [13:34:09.024]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:09.024]         }
  [13:34:09.024]         options(...future.oldOptions)
  [13:34:09.024]     })
  [13:34:09.024]     if (is.na(TRUE)) {
  [13:34:09.024]     }
  [13:34:09.024]     else {
  [13:34:09.024]         sink(type = "output", split = FALSE)
  [13:34:09.024]         if (TRUE) {
  [13:34:09.024]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:09.024]         }
  [13:34:09.024]         else {
  [13:34:09.024]             ...future.result["stdout"] <- list(NULL)
  [13:34:09.024]         }
  [13:34:09.024]         close(...future.stdout)
  [13:34:09.024]         ...future.stdout <- NULL
  [13:34:09.024]     }
  [13:34:09.024]     ...future.result$conditions <- ...future.conditions
  [13:34:09.024]     ...future.result
  [13:34:09.024] }
  [13:34:09.029] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [13:34:09.030] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [13:34:09.030] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [13:34:09.031] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [13:34:09.032] MultisessionFuture started
  [13:34:09.032] Chunk #2 of 2 ... DONE
  [13:34:09.033] Launching 2 futures (chunks) ... DONE
  [13:34:09.033] - resolving futures
  [13:34:09.033]   - gathering results & relaying conditions (except errors)
  [13:34:09.034] resolve() on list ...
  [13:34:09.034]  recursive: 0
  [13:34:09.034]  length: 2
  [13:34:09.051] 
  [13:34:09.225] Future #1
  [13:34:09.225] result() for ClusterFuture ...
  [13:34:09.226] - Validating connection of MultisessionFuture
  [13:34:09.267] - class(result): FutureResult
  [13:34:09.267] result() for ClusterFuture ...
  [13:34:09.268] - result already collected: FutureResult
  [13:34:09.268] result() for ClusterFuture ... done
  [13:34:09.268] result() for ClusterFuture ... done
  [13:34:09.269] result() for ClusterFuture ...
  [13:34:09.269] - result already collected: FutureResult
  [13:34:09.269] result() for ClusterFuture ... done
  [13:34:09.270] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [13:34:09.270] - nx: 2
  [13:34:09.270] - relay: TRUE
  [13:34:09.271] - stdout: TRUE
  [13:34:09.271] - signal: TRUE
  [13:34:09.271] - resignal: FALSE
  [13:34:09.271] - force: FALSE
  [13:34:09.272] - relayed: [n=2] FALSE, FALSE
  [13:34:09.272] - queued futures: [n=2] FALSE, FALSE
  [13:34:09.272]  - until=1
  [13:34:09.273]  - relaying element #1
  [13:34:09.273] result() for ClusterFuture ...
  [13:34:09.273] - result already collected: FutureResult
  [13:34:09.274] result() for ClusterFuture ... done
  [13:34:09.274] result() for ClusterFuture ...
  [13:34:09.274] - result already collected: FutureResult
  [13:34:09.275] result() for ClusterFuture ... done
  [13:34:09.275] result() for ClusterFuture ...
  [13:34:09.275] - result already collected: FutureResult
  [13:34:09.276] result() for ClusterFuture ... done
  [13:34:09.276] result() for ClusterFuture ...
  [13:34:09.276] - result already collected: FutureResult
  [13:34:09.276] result() for ClusterFuture ... done
  [13:34:09.277] - relayed: [n=2] TRUE, FALSE
  [13:34:09.277] - queued futures: [n=2] TRUE, FALSE
  [13:34:09.277] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [13:34:09.278]  length: 1 (resolved future 1)
  [13:34:09.325] Future #2
  [13:34:09.325] result() for ClusterFuture ...
  [13:34:09.326] - Validating connection of MultisessionFuture
  [13:34:09.367] - class(result): FutureResult
  [13:34:09.367] result() for ClusterFuture ...
  [13:34:09.368] - result already collected: FutureResult
  [13:34:09.368] result() for ClusterFuture ... done
  [13:34:09.368] result() for ClusterFuture ... done
  [13:34:09.369] result() for ClusterFuture ...
  [13:34:09.369] - result already collected: FutureResult
  [13:34:09.369] result() for ClusterFuture ... done
  [13:34:09.370] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [13:34:09.370] - nx: 2
  [13:34:09.370] - relay: TRUE
  [13:34:09.371] - stdout: TRUE
  [13:34:09.371] - signal: TRUE
  [13:34:09.371] - resignal: FALSE
  [13:34:09.372] - force: FALSE
  [13:34:09.372] - relayed: [n=2] TRUE, FALSE
  [13:34:09.372] - queued futures: [n=2] TRUE, FALSE
  [13:34:09.372]  - until=2
  [13:34:09.373]  - relaying element #2
  [13:34:09.373] result() for ClusterFuture ...
  [13:34:09.373] - result already collected: FutureResult
  [13:34:09.374] result() for ClusterFuture ... done
  [13:34:09.374] result() for ClusterFuture ...
  [13:34:09.374] - result already collected: FutureResult
  [13:34:09.375] result() for ClusterFuture ... done
  [13:34:09.375] result() for ClusterFuture ...
  [13:34:09.375] - result already collected: FutureResult
  [13:34:09.376] result() for ClusterFuture ... done
  [13:34:09.376] result() for ClusterFuture ...
  [13:34:09.376] - result already collected: FutureResult
  [13:34:09.377] result() for ClusterFuture ... done
  [13:34:09.377] - relayed: [n=2] TRUE, TRUE
  [13:34:09.377] - queued futures: [n=2] TRUE, TRUE
  [13:34:09.378] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [13:34:09.378]  length: 0 (resolved future 2)
  [13:34:09.378] Relaying remaining futures
  [13:34:09.379] signalConditionsASAP(NULL, pos=0) ...
  [13:34:09.379] - nx: 2
  [13:34:09.379] - relay: TRUE
  [13:34:09.380] - stdout: TRUE
  [13:34:09.380] - signal: TRUE
  [13:34:09.380] - resignal: FALSE
  [13:34:09.380] - force: FALSE
  [13:34:09.381] - relayed: [n=2] TRUE, TRUE
  [13:34:09.381] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:34:09.381] - relayed: [n=2] TRUE, TRUE
  [13:34:09.382] - queued futures: [n=2] TRUE, TRUE
  [13:34:09.382] signalConditionsASAP(NULL, pos=0) ... done
  [13:34:09.384] resolve() on list ... DONE
  [13:34:09.384] - collecting values of futures
  [13:34:09.384] result() for ClusterFuture ...
  [13:34:09.385] - result already collected: FutureResult
  [13:34:09.385] result() for ClusterFuture ... done
  [13:34:09.385] result() for ClusterFuture ...
  [13:34:09.386] - result already collected: FutureResult
  [13:34:09.386] result() for ClusterFuture ... done
  [13:34:09.386] result() for ClusterFuture ...
  [13:34:09.387] - result already collected: FutureResult
  [13:34:09.387] result() for ClusterFuture ... done
  [13:34:09.387] result() for ClusterFuture ...
  [13:34:09.387] - result already collected: FutureResult
  [13:34:09.388] result() for ClusterFuture ... done
  [13:34:09.388] - accumulating results
  [13:34:09.391] - processing errors (handler = 'stop')
  [13:34:09.391] - extracting results
  [13:34:09.391] doFuture() ... DONE
  - plan(list('multisession', 'sequential')) ... DONE
  - plan(list('multisession', 'multicore')) ...
  [13:34:09.393] plan(): Setting new future strategy stack:
  [13:34:09.393] List of future strategies:
  [13:34:09.393] 1. multisession:
  [13:34:09.393]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:09.393]    - tweaked: FALSE
  [13:34:09.393]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:09.393] 2. multicore:
  [13:34:09.393]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [13:34:09.393]    - tweaked: FALSE
  [13:34:09.393]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:09.395] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [13:34:09.396] multisession:
  [13:34:09.396] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:09.396] - tweaked: FALSE
  [13:34:09.396] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 29586
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d3eb19142.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d3eb19142.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d3eb19142.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29586 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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d36ed5118.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d36ed5118.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d36ed5118.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=29586 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
  [13:34:25.915] getGlobalsAndPackages() ...
  [13:34:25.916] Not searching for globals
  [13:34:25.917] - globals: [0] <none>
  [13:34:25.917] getGlobalsAndPackages() ... DONE
  [13:34:25.919] Packages needed by the future expression (n = 0): <none>
  [13:34:25.920] Packages needed by future strategies (n = 1): 'future'
  [13:34:25.925] {
  [13:34:25.925]     {
  [13:34:25.925]         ...future.startTime <- Sys.time()
  [13:34:25.925]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:25.925]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:25.925]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:25.925]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:25.925]             future.resolve.recursive = NULL, width = 80L)
  [13:34:25.925]         {
  [13:34:25.925]             {
  [13:34:25.925]                 {
  [13:34:25.925]                   {
  [13:34:25.925]                     has_future <- requireNamespace("future", 
  [13:34:25.925]                       quietly = TRUE)
  [13:34:25.925]                     version <- if (has_future) 
  [13:34:25.925]                       packageVersion("future")
  [13:34:25.925]                     else NULL
  [13:34:25.925]                     if (!has_future || version < "1.8.0") {
  [13:34:25.925]                       info <- c(r_version = gsub("R version ", 
  [13:34:25.925]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:25.925]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:25.925]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:25.925]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:25.925]                       info <- sprintf("%s: %s", names(info), 
  [13:34:25.925]                         info)
  [13:34:25.925]                       info <- paste(info, collapse = "; ")
  [13:34:25.925]                       if (!has_future) {
  [13:34:25.925]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:25.925]                           info)
  [13:34:25.925]                       }
  [13:34:25.925]                       else {
  [13:34:25.925]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:25.925]                           info, version)
  [13:34:25.925]                       }
  [13:34:25.925]                       stop(msg)
  [13:34:25.925]                     }
  [13:34:25.925]                   }
  [13:34:25.925]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:25.925]                   options(mc.cores = 1L)
  [13:34:25.925]                 }
  [13:34:25.925]                 local({
  [13:34:25.925]                   for (pkg in "future") {
  [13:34:25.925]                     loadNamespace(pkg)
  [13:34:25.925]                     library(pkg, character.only = TRUE)
  [13:34:25.925]                   }
  [13:34:25.925]                 })
  [13:34:25.925]             }
  [13:34:25.925]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:25.925]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:25.925]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:25.925]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:25.925]             {
  [13:34:25.925]                 if (substitute) 
  [13:34:25.925]                   expr <- substitute(expr)
  [13:34:25.925]                 if (is.function(workers)) 
  [13:34:25.925]                   workers <- workers()
  [13:34:25.925]                 workers <- as.integer(workers)
  [13:34:25.925]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:25.925]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:25.925]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:25.925]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:25.925]                     local = TRUE, label = label, ...))
  [13:34:25.925]                 }
  [13:34:25.925]                 oopts <- options(mc.cores = workers)
  [13:34:25.925]                 on.exit(options(oopts))
  [13:34:25.925]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:25.925]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:25.925]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:25.925]                   label = label, ...)
  [13:34:25.925]                 if (!future$lazy) 
  [13:34:25.925]                   future <- run(future)
  [13:34:25.925]                 invisible(future)
  [13:34:25.925]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:25.925]         }
  [13:34:25.925]     }
  [13:34:25.925]     if (is.na(TRUE)) {
  [13:34:25.925]     }
  [13:34:25.925]     else {
  [13:34:25.925]         if (TRUE) {
  [13:34:25.925]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:25.925]         }
  [13:34:25.925]         else {
  [13:34:25.925]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:25.925]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:25.925]         }
  [13:34:25.925]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:25.925]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:25.925]             sink(type = "output", split = FALSE)
  [13:34:25.925]             close(...future.stdout)
  [13:34:25.925]         }, add = TRUE)
  [13:34:25.925]     }
  [13:34:25.925]     ...future.frame <- sys.nframe()
  [13:34:25.925]     ...future.conditions <- list()
  [13:34:25.925]     ...future.result <- tryCatch({
  [13:34:25.925]         withCallingHandlers({
  [13:34:25.925]             ...future.value <- withVisible(local(NA))
  [13:34:25.925]             future::FutureResult(value = ...future.value$value, 
  [13:34:25.925]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:25.925]                 version = "1.8")
  [13:34:25.925]         }, condition = local({
  [13:34:25.925]             inherits <- base::inherits
  [13:34:25.925]             invokeRestart <- base::invokeRestart
  [13:34:25.925]             length <- base::length
  [13:34:25.925]             seq.int <- base::seq.int
  [13:34:25.925]             sys.calls <- base::sys.calls
  [13:34:25.925]             `[[` <- base::`[[`
  [13:34:25.925]             `+` <- base::`+`
  [13:34:25.925]             `<<-` <- base::`<<-`
  [13:34:25.925]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:25.925]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:25.925]                   3L)]
  [13:34:25.925]             }
  [13:34:25.925]             function(cond) {
  [13:34:25.925]                 if (inherits(cond, "error")) {
  [13:34:25.925]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:25.925]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:25.925]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:25.925]                     signaled = 0L)
  [13:34:25.925]                   signalCondition(cond)
  [13:34:25.925]                 }
  [13:34:25.925]                 else if (inherits(cond, "condition")) {
  [13:34:25.925]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:25.925]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:25.925]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:25.925]                   if (!signal) {
  [13:34:25.925]                     muffleCondition <- function (cond) 
  [13:34:25.925]                     {
  [13:34:25.925]                       inherits <- base::inherits
  [13:34:25.925]                       invokeRestart <- base::invokeRestart
  [13:34:25.925]                       muffled <- FALSE
  [13:34:25.925]                       if (inherits(cond, "message")) {
  [13:34:25.925]                         invokeRestart("muffleMessage")
  [13:34:25.925]                         muffled <- TRUE
  [13:34:25.925]                       }
  [13:34:25.925]                       else if (inherits(cond, "warning")) {
  [13:34:25.925]                         invokeRestart("muffleWarning")
  [13:34:25.925]                         muffled <- TRUE
  [13:34:25.925]                       }
  [13:34:25.925]                       else if (inherits(cond, "condition")) {
  [13:34:25.925]                         computeRestarts <- base::computeRestarts
  [13:34:25.925]                         grepl <- base::grepl
  [13:34:25.925]                         is.null <- base::is.null
  [13:34:25.925]                         restarts <- computeRestarts(cond)
  [13:34:25.925]                         for (restart in restarts) {
  [13:34:25.925]                           name <- restart$name
  [13:34:25.925]                           if (is.null(name)) 
  [13:34:25.925]                             next
  [13:34:25.925]                           if (!grepl("^muffle", name)) 
  [13:34:25.925]                             next
  [13:34:25.925]                           invokeRestart(restart)
  [13:34:25.925]                           muffled <- TRUE
  [13:34:25.925]                           break
  [13:34:25.925]                         }
  [13:34:25.925]                       }
  [13:34:25.925]                       invisible(muffled)
  [13:34:25.925]                     }
  [13:34:25.925]                     muffleCondition(cond)
  [13:34:25.925]                   }
  [13:34:25.925]                 }
  [13:34:25.925]             }
  [13:34:25.925]         }))
  [13:34:25.925]     }, error = function(ex) {
  [13:34:25.925]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:25.925]             version = "1.8"), class = "FutureResult")
  [13:34:25.925]     }, finally = {
  [13:34:25.925]         {
  [13:34:25.925]             {
  [13:34:25.925]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:25.925]             }
  [13:34:25.925]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:25.925]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:25.925]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:25.925]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:25.925]                 ...) 
  [13:34:25.925]             {
  [13:34:25.925]                 if (substitute) 
  [13:34:25.925]                   expr <- substitute(expr)
  [13:34:25.925]                 if (is.function(workers)) 
  [13:34:25.925]                   workers <- workers()
  [13:34:25.925]                 workers <- as.integer(workers)
  [13:34:25.925]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:25.925]                   workers >= 1)
  [13:34:25.925]                 if (workers == 1L) {
  [13:34:25.925]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:25.925]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:25.925]                     local = TRUE, label = label, ...))
  [13:34:25.925]                 }
  [13:34:25.925]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:25.925]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:25.925]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:25.925]                   globals = globals, persistent = persistent, 
  [13:34:25.925]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:25.925]                   label = label, ...)
  [13:34:25.925]                 if (!future$lazy) 
  [13:34:25.925]                   future <- run(future)
  [13:34:25.925]                 invisible(future)
  [13:34:25.925]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:25.925]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:25.925]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:25.925]             {
  [13:34:25.925]                 if (substitute) 
  [13:34:25.925]                   expr <- substitute(expr)
  [13:34:25.925]                 if (is.function(workers)) 
  [13:34:25.925]                   workers <- workers()
  [13:34:25.925]                 workers <- as.integer(workers)
  [13:34:25.925]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:25.925]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:25.925]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:25.925]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:25.925]                     local = TRUE, label = label, ...))
  [13:34:25.925]                 }
  [13:34:25.925]                 oopts <- options(mc.cores = workers)
  [13:34:25.925]                 on.exit(options(oopts))
  [13:34:25.925]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:25.925]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:25.925]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:25.925]                   label = label, ...)
  [13:34:25.925]                 if (!future$lazy) 
  [13:34:25.925]                   future <- run(future)
  [13:34:25.925]                 invisible(future)
  [13:34:25.925]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:25.925]         }
  [13:34:25.925]         options(...future.oldOptions)
  [13:34:25.925]     })
  [13:34:25.925]     if (is.na(TRUE)) {
  [13:34:25.925]     }
  [13:34:25.925]     else {
  [13:34:25.925]         sink(type = "output", split = FALSE)
  [13:34:25.925]         if (TRUE) {
  [13:34:25.925]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:25.925]         }
  [13:34:25.925]         else {
  [13:34:25.925]             ...future.result["stdout"] <- list(NULL)
  [13:34:25.925]         }
  [13:34:25.925]         close(...future.stdout)
  [13:34:25.925]         ...future.stdout <- NULL
  [13:34:25.925]     }
  [13:34:25.925]     ...future.result$conditions <- ...future.conditions
  [13:34:25.925]     ...future.result
  [13:34:25.925] }
  [13:34:25.945] MultisessionFuture started
  [13:34:25.945] result() for ClusterFuture ...
  [13:34:25.946] - Validating connection of MultisessionFuture
  [13:34:26.243] - class(result): FutureResult
  [13:34:26.244] result() for ClusterFuture ...
  [13:34:26.244] - result already collected: FutureResult
  [13:34:26.244] result() for ClusterFuture ... done
  [13:34:26.245] result() for ClusterFuture ... done
  [13:34:26.245] result() for ClusterFuture ...
  [13:34:26.246] - result already collected: FutureResult
  [13:34:26.246] result() for ClusterFuture ... done
  [13:34:26.246] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [13:34:26.247] plan(): nbrOfWorkers() = 2
  [13:34:26.248] doFuture() ...
  [13:34:26.254] - dummy globals (as locals): [2] 'a', 'b'
  [13:34:26.255] - R expression:
  [13:34:26.255] {
  [13:34:26.255]     doFuture::registerDoFuture()
  [13:34:26.255]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:26.255]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:26.255]         {
  [13:34:26.255]             a <- NULL
  [13:34:26.255]             b <- NULL
  [13:34:26.255]         }
  [13:34:26.255]         ...future.env <- environment()
  [13:34:26.255]         local({
  [13:34:26.255]             for (name in names(...future.x_jj)) {
  [13:34:26.255]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:26.255]                   inherits = FALSE)
  [13:34:26.255]             }
  [13:34:26.255]         })
  [13:34:26.255]         tryCatch({
  [13:34:26.255]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:26.255]                 plan = future::plan())
  [13:34:26.255]         }, error = identity)
  [13:34:26.255]     })
  [13:34:26.255] }
  [13:34:26.256] - identifying globals and packages ...
  [13:34:26.257] getGlobalsAndPackages() ...
  [13:34:26.257] Searching for globals...
  [13:34:26.309] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:34:26.310] Searching for globals ... DONE
  [13:34:26.310] Resolving globals: FALSE
  [13:34:26.312] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:34:26.313] - globals: [1] '...future.x_ii'
  [13:34:26.313] 
  [13:34:26.313] getGlobalsAndPackages() ... DONE
  [13:34:26.314] List of 1
  [13:34:26.314]  $ ...future.x_ii: NULL
  [13:34:26.314]  - attr(*, "where")=List of 1
  [13:34:26.314]   ..$ ...future.x_ii:<environment: 0x563b860c4418> 
  [13:34:26.314]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:26.314]  - attr(*, "resolved")= logi FALSE
  [13:34:26.314]  - attr(*, "total_size")= num 0
  [13:34:26.337]   - R expression:
  [13:34:26.338] {
  [13:34:26.338]     doFuture::registerDoFuture()
  [13:34:26.338]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:26.338]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:26.338]         {
  [13:34:26.338]             a <- NULL
  [13:34:26.338]             b <- NULL
  [13:34:26.338]         }
  [13:34:26.338]         ...future.env <- environment()
  [13:34:26.338]         local({
  [13:34:26.338]             for (name in names(...future.x_jj)) {
  [13:34:26.338]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:26.338]                   inherits = FALSE)
  [13:34:26.338]             }
  [13:34:26.338]         })
  [13:34:26.338]         tryCatch({
  [13:34:26.338]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:26.338]                 plan = future::plan())
  [13:34:26.338]         }, error = identity)
  [13:34:26.338]     })
  [13:34:26.338] }
  [13:34:26.339]   - globals: [1] '...future.x_ii'
  [13:34:26.339] List of 1
  [13:34:26.339]  $ ...future.x_ii: NULL
  [13:34:26.339]  - attr(*, "where")=List of 1
  [13:34:26.339]   ..$ ...future.x_ii:<environment: 0x563b860c4418> 
  [13:34:26.339]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:26.339]  - attr(*, "resolved")= logi FALSE
  [13:34:26.339]  - attr(*, "total_size")= num 0
  [13:34:26.346]   - packages: [1] 'doFuture'
  [13:34:26.346] - identifying globals and packages ... DONE
  [13:34:26.364] Number of chunks: 2
  [13:34:26.365] Number of futures (= number of chunks): 2
  [13:34:26.365] Launching 2 futures (chunks) ...
  [13:34:26.365] Chunk #1 of 2 ...
  [13:34:26.366]  - Finding globals in 'args_list' chunk #1 ...
  [13:34:26.366] getGlobalsAndPackages() ...
  [13:34:26.366] Searching for globals...
  [13:34:26.367] 
  [13:34:26.368] Searching for globals ... DONE
  [13:34:26.368] - globals: [0] <none>
  [13:34:26.368] getGlobalsAndPackages() ... DONE
  [13:34:26.369] 
  [13:34:26.369] 
  [13:34:26.369]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:34:26.378] getGlobalsAndPackages() ...
  [13:34:26.395] - globals passed as-is: [1] '...future.x_ii'
  [13:34:26.395] Resolving globals: FALSE
  [13:34:26.396] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:26.397] - globals: [1] '...future.x_ii'
  [13:34:26.397] 
  [13:34:26.398] getGlobalsAndPackages() ... DONE
  [13:34:26.400] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:26.401] Packages needed by future strategies (n = 1): 'future'
  [13:34:26.405] {
  [13:34:26.405]     {
  [13:34:26.405]         ...future.startTime <- Sys.time()
  [13:34:26.405]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:26.405]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:26.405]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:26.405]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:26.405]             future.resolve.recursive = NULL, width = 80L)
  [13:34:26.405]         {
  [13:34:26.405]             {
  [13:34:26.405]                 {
  [13:34:26.405]                   {
  [13:34:26.405]                     has_future <- requireNamespace("future", 
  [13:34:26.405]                       quietly = TRUE)
  [13:34:26.405]                     version <- if (has_future) 
  [13:34:26.405]                       packageVersion("future")
  [13:34:26.405]                     else NULL
  [13:34:26.405]                     if (!has_future || version < "1.8.0") {
  [13:34:26.405]                       info <- c(r_version = gsub("R version ", 
  [13:34:26.405]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:26.405]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:26.405]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:26.405]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:26.405]                       info <- sprintf("%s: %s", names(info), 
  [13:34:26.405]                         info)
  [13:34:26.405]                       info <- paste(info, collapse = "; ")
  [13:34:26.405]                       if (!has_future) {
  [13:34:26.405]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:26.405]                           info)
  [13:34:26.405]                       }
  [13:34:26.405]                       else {
  [13:34:26.405]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:26.405]                           info, version)
  [13:34:26.405]                       }
  [13:34:26.405]                       stop(msg)
  [13:34:26.405]                     }
  [13:34:26.405]                   }
  [13:34:26.405]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:26.405]                   options(mc.cores = 1L)
  [13:34:26.405]                 }
  [13:34:26.405]                 local({
  [13:34:26.405]                   for (pkg in c("doFuture", "future")) {
  [13:34:26.405]                     loadNamespace(pkg)
  [13:34:26.405]                     library(pkg, character.only = TRUE)
  [13:34:26.405]                   }
  [13:34:26.405]                 })
  [13:34:26.405]             }
  [13:34:26.405]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:26.405]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:26.405]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:26.405]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:26.405]             {
  [13:34:26.405]                 if (substitute) 
  [13:34:26.405]                   expr <- substitute(expr)
  [13:34:26.405]                 if (is.function(workers)) 
  [13:34:26.405]                   workers <- workers()
  [13:34:26.405]                 workers <- as.integer(workers)
  [13:34:26.405]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:26.405]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:26.405]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.405]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:26.405]                     local = TRUE, label = label, ...))
  [13:34:26.405]                 }
  [13:34:26.405]                 oopts <- options(mc.cores = workers)
  [13:34:26.405]                 on.exit(options(oopts))
  [13:34:26.405]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:26.405]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.405]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:26.405]                   label = label, ...)
  [13:34:26.405]                 if (!future$lazy) 
  [13:34:26.405]                   future <- run(future)
  [13:34:26.405]                 invisible(future)
  [13:34:26.405]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:26.405]         }
  [13:34:26.405]     }
  [13:34:26.405]     if (is.na(TRUE)) {
  [13:34:26.405]     }
  [13:34:26.405]     else {
  [13:34:26.405]         if (TRUE) {
  [13:34:26.405]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:26.405]         }
  [13:34:26.405]         else {
  [13:34:26.405]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:26.405]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:26.405]         }
  [13:34:26.405]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:26.405]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:26.405]             sink(type = "output", split = FALSE)
  [13:34:26.405]             close(...future.stdout)
  [13:34:26.405]         }, add = TRUE)
  [13:34:26.405]     }
  [13:34:26.405]     ...future.frame <- sys.nframe()
  [13:34:26.405]     ...future.conditions <- list()
  [13:34:26.405]     ...future.result <- tryCatch({
  [13:34:26.405]         withCallingHandlers({
  [13:34:26.405]             ...future.value <- withVisible(local({
  [13:34:26.405]                 doFuture::registerDoFuture()
  [13:34:26.405]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:26.405]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:26.405]                   {
  [13:34:26.405]                     a <- NULL
  [13:34:26.405]                     b <- NULL
  [13:34:26.405]                   }
  [13:34:26.405]                   ...future.env <- environment()
  [13:34:26.405]                   local({
  [13:34:26.405]                     for (name in names(...future.x_jj)) {
  [13:34:26.405]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:26.405]                         inherits = FALSE)
  [13:34:26.405]                     }
  [13:34:26.405]                   })
  [13:34:26.405]                   tryCatch({
  [13:34:26.405]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:26.405]                       plan = future::plan())
  [13:34:26.405]                   }, error = identity)
  [13:34:26.405]                 })
  [13:34:26.405]             }))
  [13:34:26.405]             future::FutureResult(value = ...future.value$value, 
  [13:34:26.405]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:26.405]                 version = "1.8")
  [13:34:26.405]         }, condition = local({
  [13:34:26.405]             inherits <- base::inherits
  [13:34:26.405]             invokeRestart <- base::invokeRestart
  [13:34:26.405]             length <- base::length
  [13:34:26.405]             seq.int <- base::seq.int
  [13:34:26.405]             sys.calls <- base::sys.calls
  [13:34:26.405]             `[[` <- base::`[[`
  [13:34:26.405]             `+` <- base::`+`
  [13:34:26.405]             `<<-` <- base::`<<-`
  [13:34:26.405]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:26.405]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:26.405]                   3L)]
  [13:34:26.405]             }
  [13:34:26.405]             function(cond) {
  [13:34:26.405]                 if (inherits(cond, "error")) {
  [13:34:26.405]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:26.405]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:26.405]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:26.405]                     signaled = 0L)
  [13:34:26.405]                   signalCondition(cond)
  [13:34:26.405]                 }
  [13:34:26.405]                 else if (inherits(cond, "condition")) {
  [13:34:26.405]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:26.405]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:26.405]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:26.405]                   if (!signal) {
  [13:34:26.405]                     muffleCondition <- function (cond) 
  [13:34:26.405]                     {
  [13:34:26.405]                       inherits <- base::inherits
  [13:34:26.405]                       invokeRestart <- base::invokeRestart
  [13:34:26.405]                       muffled <- FALSE
  [13:34:26.405]                       if (inherits(cond, "message")) {
  [13:34:26.405]                         invokeRestart("muffleMessage")
  [13:34:26.405]                         muffled <- TRUE
  [13:34:26.405]                       }
  [13:34:26.405]                       else if (inherits(cond, "warning")) {
  [13:34:26.405]                         invokeRestart("muffleWarning")
  [13:34:26.405]                         muffled <- TRUE
  [13:34:26.405]                       }
  [13:34:26.405]                       else if (inherits(cond, "condition")) {
  [13:34:26.405]                         computeRestarts <- base::computeRestarts
  [13:34:26.405]                         grepl <- base::grepl
  [13:34:26.405]                         is.null <- base::is.null
  [13:34:26.405]                         restarts <- computeRestarts(cond)
  [13:34:26.405]                         for (restart in restarts) {
  [13:34:26.405]                           name <- restart$name
  [13:34:26.405]                           if (is.null(name)) 
  [13:34:26.405]                             next
  [13:34:26.405]                           if (!grepl("^muffle", name)) 
  [13:34:26.405]                             next
  [13:34:26.405]                           invokeRestart(restart)
  [13:34:26.405]                           muffled <- TRUE
  [13:34:26.405]                           break
  [13:34:26.405]                         }
  [13:34:26.405]                       }
  [13:34:26.405]                       invisible(muffled)
  [13:34:26.405]                     }
  [13:34:26.405]                     muffleCondition(cond)
  [13:34:26.405]                   }
  [13:34:26.405]                 }
  [13:34:26.405]             }
  [13:34:26.405]         }))
  [13:34:26.405]     }, error = function(ex) {
  [13:34:26.405]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:26.405]             version = "1.8"), class = "FutureResult")
  [13:34:26.405]     }, finally = {
  [13:34:26.405]         {
  [13:34:26.405]             {
  [13:34:26.405]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:26.405]             }
  [13:34:26.405]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:26.405]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:26.405]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:26.405]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:26.405]                 ...) 
  [13:34:26.405]             {
  [13:34:26.405]                 if (substitute) 
  [13:34:26.405]                   expr <- substitute(expr)
  [13:34:26.405]                 if (is.function(workers)) 
  [13:34:26.405]                   workers <- workers()
  [13:34:26.405]                 workers <- as.integer(workers)
  [13:34:26.405]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:26.405]                   workers >= 1)
  [13:34:26.405]                 if (workers == 1L) {
  [13:34:26.405]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.405]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:26.405]                     local = TRUE, label = label, ...))
  [13:34:26.405]                 }
  [13:34:26.405]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:26.405]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:26.405]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.405]                   globals = globals, persistent = persistent, 
  [13:34:26.405]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:26.405]                   label = label, ...)
  [13:34:26.405]                 if (!future$lazy) 
  [13:34:26.405]                   future <- run(future)
  [13:34:26.405]                 invisible(future)
  [13:34:26.405]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:26.405]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:26.405]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:26.405]             {
  [13:34:26.405]                 if (substitute) 
  [13:34:26.405]                   expr <- substitute(expr)
  [13:34:26.405]                 if (is.function(workers)) 
  [13:34:26.405]                   workers <- workers()
  [13:34:26.405]                 workers <- as.integer(workers)
  [13:34:26.405]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:26.405]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:26.405]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.405]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:26.405]                     local = TRUE, label = label, ...))
  [13:34:26.405]                 }
  [13:34:26.405]                 oopts <- options(mc.cores = workers)
  [13:34:26.405]                 on.exit(options(oopts))
  [13:34:26.405]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:26.405]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.405]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:26.405]                   label = label, ...)
  [13:34:26.405]                 if (!future$lazy) 
  [13:34:26.405]                   future <- run(future)
  [13:34:26.405]                 invisible(future)
  [13:34:26.405]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:26.405]         }
  [13:34:26.405]         options(...future.oldOptions)
  [13:34:26.405]     })
  [13:34:26.405]     if (is.na(TRUE)) {
  [13:34:26.405]     }
  [13:34:26.405]     else {
  [13:34:26.405]         sink(type = "output", split = FALSE)
  [13:34:26.405]         if (TRUE) {
  [13:34:26.405]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:26.405]         }
  [13:34:26.405]         else {
  [13:34:26.405]             ...future.result["stdout"] <- list(NULL)
  [13:34:26.405]         }
  [13:34:26.405]         close(...future.stdout)
  [13:34:26.405]         ...future.stdout <- NULL
  [13:34:26.405]     }
  [13:34:26.405]     ...future.result$conditions <- ...future.conditions
  [13:34:26.405]     ...future.result
  [13:34:26.405] }
  [13:34:26.428] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [13:34:26.621] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [13:34:26.623] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [13:34:26.624] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [13:34:26.626] MultisessionFuture started
  [13:34:26.626] Chunk #1 of 2 ... DONE
  [13:34:26.627] Chunk #2 of 2 ...
  [13:34:26.627]  - Finding globals in 'args_list' chunk #2 ...
  [13:34:26.627] getGlobalsAndPackages() ...
  [13:34:26.628] Searching for globals...
  [13:34:26.629] 
  [13:34:26.629] Searching for globals ... DONE
  [13:34:26.630] - globals: [0] <none>
  [13:34:26.630] getGlobalsAndPackages() ... DONE
  [13:34:26.630] 
  [13:34:26.631] 
  [13:34:26.631]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:34:26.642] getGlobalsAndPackages() ...
  [13:34:26.642] - globals passed as-is: [1] '...future.x_ii'
  [13:34:26.643] Resolving globals: FALSE
  [13:34:26.644] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:26.644] - globals: [1] '...future.x_ii'
  [13:34:26.645] 
  [13:34:26.645] getGlobalsAndPackages() ... DONE
  [13:34:26.647] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:26.648] Packages needed by future strategies (n = 1): 'future'
  [13:34:26.653] {
  [13:34:26.653]     {
  [13:34:26.653]         ...future.startTime <- Sys.time()
  [13:34:26.653]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:26.653]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:26.653]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:26.653]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:26.653]             future.resolve.recursive = NULL, width = 80L)
  [13:34:26.653]         {
  [13:34:26.653]             {
  [13:34:26.653]                 {
  [13:34:26.653]                   {
  [13:34:26.653]                     has_future <- requireNamespace("future", 
  [13:34:26.653]                       quietly = TRUE)
  [13:34:26.653]                     version <- if (has_future) 
  [13:34:26.653]                       packageVersion("future")
  [13:34:26.653]                     else NULL
  [13:34:26.653]                     if (!has_future || version < "1.8.0") {
  [13:34:26.653]                       info <- c(r_version = gsub("R version ", 
  [13:34:26.653]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:26.653]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:26.653]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:26.653]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:26.653]                       info <- sprintf("%s: %s", names(info), 
  [13:34:26.653]                         info)
  [13:34:26.653]                       info <- paste(info, collapse = "; ")
  [13:34:26.653]                       if (!has_future) {
  [13:34:26.653]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:26.653]                           info)
  [13:34:26.653]                       }
  [13:34:26.653]                       else {
  [13:34:26.653]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:26.653]                           info, version)
  [13:34:26.653]                       }
  [13:34:26.653]                       stop(msg)
  [13:34:26.653]                     }
  [13:34:26.653]                   }
  [13:34:26.653]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:26.653]                   options(mc.cores = 1L)
  [13:34:26.653]                 }
  [13:34:26.653]                 local({
  [13:34:26.653]                   for (pkg in c("doFuture", "future")) {
  [13:34:26.653]                     loadNamespace(pkg)
  [13:34:26.653]                     library(pkg, character.only = TRUE)
  [13:34:26.653]                   }
  [13:34:26.653]                 })
  [13:34:26.653]             }
  [13:34:26.653]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:26.653]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:26.653]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:26.653]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:26.653]             {
  [13:34:26.653]                 if (substitute) 
  [13:34:26.653]                   expr <- substitute(expr)
  [13:34:26.653]                 if (is.function(workers)) 
  [13:34:26.653]                   workers <- workers()
  [13:34:26.653]                 workers <- as.integer(workers)
  [13:34:26.653]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:26.653]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:26.653]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.653]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:26.653]                     local = TRUE, label = label, ...))
  [13:34:26.653]                 }
  [13:34:26.653]                 oopts <- options(mc.cores = workers)
  [13:34:26.653]                 on.exit(options(oopts))
  [13:34:26.653]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:26.653]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.653]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:26.653]                   label = label, ...)
  [13:34:26.653]                 if (!future$lazy) 
  [13:34:26.653]                   future <- run(future)
  [13:34:26.653]                 invisible(future)
  [13:34:26.653]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:26.653]         }
  [13:34:26.653]     }
  [13:34:26.653]     if (is.na(TRUE)) {
  [13:34:26.653]     }
  [13:34:26.653]     else {
  [13:34:26.653]         if (TRUE) {
  [13:34:26.653]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:26.653]         }
  [13:34:26.653]         else {
  [13:34:26.653]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:26.653]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:26.653]         }
  [13:34:26.653]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:26.653]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:26.653]             sink(type = "output", split = FALSE)
  [13:34:26.653]             close(...future.stdout)
  [13:34:26.653]         }, add = TRUE)
  [13:34:26.653]     }
  [13:34:26.653]     ...future.frame <- sys.nframe()
  [13:34:26.653]     ...future.conditions <- list()
  [13:34:26.653]     ...future.result <- tryCatch({
  [13:34:26.653]         withCallingHandlers({
  [13:34:26.653]             ...future.value <- withVisible(local({
  [13:34:26.653]                 doFuture::registerDoFuture()
  [13:34:26.653]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:26.653]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:26.653]                   {
  [13:34:26.653]                     a <- NULL
  [13:34:26.653]                     b <- NULL
  [13:34:26.653]                   }
  [13:34:26.653]                   ...future.env <- environment()
  [13:34:26.653]                   local({
  [13:34:26.653]                     for (name in names(...future.x_jj)) {
  [13:34:26.653]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:26.653]                         inherits = FALSE)
  [13:34:26.653]                     }
  [13:34:26.653]                   })
  [13:34:26.653]                   tryCatch({
  [13:34:26.653]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:26.653]                       plan = future::plan())
  [13:34:26.653]                   }, error = identity)
  [13:34:26.653]                 })
  [13:34:26.653]             }))
  [13:34:26.653]             future::FutureResult(value = ...future.value$value, 
  [13:34:26.653]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:26.653]                 version = "1.8")
  [13:34:26.653]         }, condition = local({
  [13:34:26.653]             inherits <- base::inherits
  [13:34:26.653]             invokeRestart <- base::invokeRestart
  [13:34:26.653]             length <- base::length
  [13:34:26.653]             seq.int <- base::seq.int
  [13:34:26.653]             sys.calls <- base::sys.calls
  [13:34:26.653]             `[[` <- base::`[[`
  [13:34:26.653]             `+` <- base::`+`
  [13:34:26.653]             `<<-` <- base::`<<-`
  [13:34:26.653]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:26.653]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:26.653]                   3L)]
  [13:34:26.653]             }
  [13:34:26.653]             function(cond) {
  [13:34:26.653]                 if (inherits(cond, "error")) {
  [13:34:26.653]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:26.653]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:26.653]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:26.653]                     signaled = 0L)
  [13:34:26.653]                   signalCondition(cond)
  [13:34:26.653]                 }
  [13:34:26.653]                 else if (inherits(cond, "condition")) {
  [13:34:26.653]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:26.653]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:26.653]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:26.653]                   if (!signal) {
  [13:34:26.653]                     muffleCondition <- function (cond) 
  [13:34:26.653]                     {
  [13:34:26.653]                       inherits <- base::inherits
  [13:34:26.653]                       invokeRestart <- base::invokeRestart
  [13:34:26.653]                       muffled <- FALSE
  [13:34:26.653]                       if (inherits(cond, "message")) {
  [13:34:26.653]                         invokeRestart("muffleMessage")
  [13:34:26.653]                         muffled <- TRUE
  [13:34:26.653]                       }
  [13:34:26.653]                       else if (inherits(cond, "warning")) {
  [13:34:26.653]                         invokeRestart("muffleWarning")
  [13:34:26.653]                         muffled <- TRUE
  [13:34:26.653]                       }
  [13:34:26.653]                       else if (inherits(cond, "condition")) {
  [13:34:26.653]                         computeRestarts <- base::computeRestarts
  [13:34:26.653]                         grepl <- base::grepl
  [13:34:26.653]                         is.null <- base::is.null
  [13:34:26.653]                         restarts <- computeRestarts(cond)
  [13:34:26.653]                         for (restart in restarts) {
  [13:34:26.653]                           name <- restart$name
  [13:34:26.653]                           if (is.null(name)) 
  [13:34:26.653]                             next
  [13:34:26.653]                           if (!grepl("^muffle", name)) 
  [13:34:26.653]                             next
  [13:34:26.653]                           invokeRestart(restart)
  [13:34:26.653]                           muffled <- TRUE
  [13:34:26.653]                           break
  [13:34:26.653]                         }
  [13:34:26.653]                       }
  [13:34:26.653]                       invisible(muffled)
  [13:34:26.653]                     }
  [13:34:26.653]                     muffleCondition(cond)
  [13:34:26.653]                   }
  [13:34:26.653]                 }
  [13:34:26.653]             }
  [13:34:26.653]         }))
  [13:34:26.653]     }, error = function(ex) {
  [13:34:26.653]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:26.653]             version = "1.8"), class = "FutureResult")
  [13:34:26.653]     }, finally = {
  [13:34:26.653]         {
  [13:34:26.653]             {
  [13:34:26.653]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:26.653]             }
  [13:34:26.653]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:26.653]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:26.653]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:26.653]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:26.653]                 ...) 
  [13:34:26.653]             {
  [13:34:26.653]                 if (substitute) 
  [13:34:26.653]                   expr <- substitute(expr)
  [13:34:26.653]                 if (is.function(workers)) 
  [13:34:26.653]                   workers <- workers()
  [13:34:26.653]                 workers <- as.integer(workers)
  [13:34:26.653]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:26.653]                   workers >= 1)
  [13:34:26.653]                 if (workers == 1L) {
  [13:34:26.653]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.653]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:26.653]                     local = TRUE, label = label, ...))
  [13:34:26.653]                 }
  [13:34:26.653]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:26.653]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:26.653]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.653]                   globals = globals, persistent = persistent, 
  [13:34:26.653]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:26.653]                   label = label, ...)
  [13:34:26.653]                 if (!future$lazy) 
  [13:34:26.653]                   future <- run(future)
  [13:34:26.653]                 invisible(future)
  [13:34:26.653]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:26.653]                 lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [13:34:26.653]                 earlySignal = FALSE, label = NULL, ...) 
  [13:34:26.653]             {
  [13:34:26.653]                 if (substitute) 
  [13:34:26.653]                   expr <- substitute(expr)
  [13:34:26.653]                 if (is.function(workers)) 
  [13:34:26.653]                   workers <- workers()
  [13:34:26.653]                 workers <- as.integer(workers)
  [13:34:26.653]                 stop_if_not(is.finite(workers), workers >= 1L)
  [13:34:26.653]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [13:34:26.653]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:26.653]                     lazy = lazy, seed = seed, globals = globals, 
  [13:34:26.653]                     local = TRUE, label = label, ...))
  [13:34:26.653]                 }
  [13:34:26.653]                 oopts <- options(mc.cores = workers)
  [13:34:26.653]                 on.exit(options(oopts))
  [13:34:26.653]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [13:34:26.653]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:26.653]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [13:34:26.653]                   label = label, ...)
  [13:34:26.653]                 if (!future$lazy) 
  [13:34:26.653]                   future <- run(future)
  [13:34:26.653]                 invisible(future)
  [13:34:26.653]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:26.653]         }
  [13:34:26.653]         options(...future.oldOptions)
  [13:34:26.653]     })
  [13:34:26.653]     if (is.na(TRUE)) {
  [13:34:26.653]     }
  [13:34:26.653]     else {
  [13:34:26.653]         sink(type = "output", split = FALSE)
  [13:34:26.653]         if (TRUE) {
  [13:34:26.653]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:26.653]         }
  [13:34:26.653]         else {
  [13:34:26.653]             ...future.result["stdout"] <- list(NULL)
  [13:34:26.653]         }
  [13:34:26.653]         close(...future.stdout)
  [13:34:26.653]         ...future.stdout <- NULL
  [13:34:26.653]     }
  [13:34:26.653]     ...future.result$conditions <- ...future.conditions
  [13:34:26.653]     ...future.result
  [13:34:26.653] }
  [13:34:26.660] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [13:34:26.661] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [13:34:26.662] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [13:34:26.663] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [13:34:26.664] MultisessionFuture started
  [13:34:26.665] Chunk #2 of 2 ... DONE
  [13:34:26.665] Launching 2 futures (chunks) ... DONE
  [13:34:26.666] - resolving futures
  [13:34:26.666]   - gathering results & relaying conditions (except errors)
  [13:34:26.682] resolve() on list ...
  [13:34:26.683]  recursive: 0
  [13:34:26.683]  length: 2
  [13:34:26.684] 
  [13:34:27.190] Future #1
  [13:34:27.191] result() for ClusterFuture ...
  [13:34:27.192] - Validating connection of MultisessionFuture
  [13:34:27.193] - class(result): FutureResult
  [13:34:27.194] result() for ClusterFuture ...
  [13:34:27.194] - result already collected: FutureResult
  [13:34:27.195] result() for ClusterFuture ... done
  [13:34:27.195] result() for ClusterFuture ... done
  [13:34:27.196] result() for ClusterFuture ...
  [13:34:27.196] - result already collected: FutureResult
  [13:34:27.197] result() for ClusterFuture ... done
  [13:34:27.197] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [13:34:27.197] - nx: 2
  [13:34:27.198] - relay: TRUE
  [13:34:27.198] - stdout: TRUE
  [13:34:27.198] - signal: TRUE
  [13:34:27.199] - resignal: FALSE
  [13:34:27.199] - force: FALSE
  [13:34:27.199] - relayed: [n=2] FALSE, FALSE
  [13:34:27.200] - queued futures: [n=2] FALSE, FALSE
  [13:34:27.200]  - until=1
  [13:34:27.201]  - relaying element #1
  [13:34:27.201] result() for ClusterFuture ...
  [13:34:27.201] - result already collected: FutureResult
  [13:34:27.202] result() for ClusterFuture ... done
  [13:34:27.202] result() for ClusterFuture ...
  [13:34:27.219] - result already collected: FutureResult
  [13:34:27.219] result() for ClusterFuture ... done
  [13:34:27.220] result() for ClusterFuture ...
  [13:34:27.220] - result already collected: FutureResult
  [13:34:27.221] result() for ClusterFuture ... done
  [13:34:27.221] result() for ClusterFuture ...
  [13:34:27.221] - result already collected: FutureResult
  [13:34:27.222] result() for ClusterFuture ... done
  [13:34:27.222] - relayed: [n=2] TRUE, FALSE
  [13:34:27.222] - queued futures: [n=2] TRUE, FALSE
  [13:34:27.223] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [13:34:27.223]  length: 1 (resolved future 1)
  [13:34:27.225] Future #2
  [13:34:27.226] result() for ClusterFuture ...
  [13:34:27.226] - Validating connection of MultisessionFuture
  [13:34:27.228] - class(result): FutureResult
  [13:34:27.228] result() for ClusterFuture ...
  [13:34:27.229] - result already collected: FutureResult
  [13:34:27.229] result() for ClusterFuture ... done
  [13:34:27.230] result() for ClusterFuture ... done
  [13:34:27.230] result() for ClusterFuture ...
  [13:34:27.230] - result already collected: FutureResult
  [13:34:27.231] result() for ClusterFuture ... done
  [13:34:27.231] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [13:34:27.232] - nx: 2
  [13:34:27.232] - relay: TRUE
  [13:34:27.232] - stdout: TRUE
  [13:34:27.233] - signal: TRUE
  [13:34:27.233] - resignal: FALSE
  [13:34:27.233] - force: FALSE
  [13:34:27.234] - relayed: [n=2] TRUE, FALSE
  [13:34:27.234] - queued futures: [n=2] TRUE, FALSE
  [13:34:27.250]  - until=2
  [13:34:27.251]  - relaying element #2
  [13:34:27.252] result() for ClusterFuture ...
  [13:34:27.252] - result already collected: FutureResult
  [13:34:27.252] result() for ClusterFuture ... done
  [13:34:27.253] result() for ClusterFuture ...
  [13:34:27.253] - result already collected: FutureResult
  [13:34:27.253] result() for ClusterFuture ... done
  [13:34:27.254] result() for ClusterFuture ...
  [13:34:27.254] - result already collected: FutureResult
  [13:34:27.255] result() for ClusterFuture ... done
  [13:34:27.255] result() for ClusterFuture ...
  [13:34:27.256] - result already collected: FutureResult
  [13:34:27.256] result() for ClusterFuture ... done
  [13:34:27.256] - relayed: [n=2] TRUE, TRUE
  [13:34:27.257] - queued futures: [n=2] TRUE, TRUE
  [13:34:27.257] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [13:34:27.257]  length: 0 (resolved future 2)
  [13:34:27.258] Relaying remaining futures
  [13:34:27.258] signalConditionsASAP(NULL, pos=0) ...
  [13:34:27.259] - nx: 2
  [13:34:27.259] - relay: TRUE
  [13:34:27.259] - stdout: TRUE
  [13:34:27.260] - signal: TRUE
  [13:34:27.260] - resignal: FALSE
  [13:34:27.260] - force: FALSE
  [13:34:27.261] - relayed: [n=2] TRUE, TRUE
  [13:34:27.261] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:34:27.262] - relayed: [n=2] TRUE, TRUE
  [13:34:27.262] - queued futures: [n=2] TRUE, TRUE
  [13:34:27.262] signalConditionsASAP(NULL, pos=0) ... done
  [13:34:27.263] resolve() on list ... DONE
  [13:34:27.263] - collecting values of futures
  [13:34:27.263] result() for ClusterFuture ...
  [13:34:27.264] - result already collected: FutureResult
  [13:34:27.264] result() for ClusterFuture ... done
  [13:34:27.264] result() for ClusterFuture ...
  [13:34:27.265] - result already collected: FutureResult
  [13:34:27.265] result() for ClusterFuture ... done
  [13:34:27.266] result() for ClusterFuture ...
  [13:34:27.266] - result already collected: FutureResult
  [13:34:27.266] result() for ClusterFuture ... done
  [13:34:27.290] result() for ClusterFuture ...
  [13:34:27.290] - result already collected: FutureResult
  [13:34:27.291] result() for ClusterFuture ... done
  [13:34:27.291] - accumulating results
  [13:34:27.295] - processing errors (handler = 'stop')
  [13:34:27.296] - extracting results
  [13:34:27.296] doFuture() ... DONE
  - plan(list('multisession', 'multicore')) ... DONE
  - plan(list('multisession', 'multisession')) ...
  [13:34:27.298] plan(): Setting new future strategy stack:
  [13:34:27.315] List of future strategies:
  [13:34:27.315] 1. multisession:
  [13:34:27.315]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:27.315]    - tweaked: FALSE
  [13:34:27.315]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:27.315] 2. multisession:
  [13:34:27.315]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:27.315]    - tweaked: FALSE
  [13:34:27.315]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:27.318] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [13:34:27.318] multisession:
  [13:34:27.318] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:27.318] - tweaked: FALSE
  [13:34:27.318] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 38185
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462da0ee7cc.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462da0ee7cc.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462da0ee7cc.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38185 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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d28908ed7.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d28908ed7.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d28908ed7.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=38185 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
  [13:34:42.698] getGlobalsAndPackages() ...
  [13:34:42.698] Not searching for globals
  [13:34:42.699] - globals: [0] <none>
  [13:34:42.699] getGlobalsAndPackages() ... DONE
  [13:34:42.701] Packages needed by the future expression (n = 0): <none>
  [13:34:42.701] Packages needed by future strategies (n = 1): 'future'
  [13:34:42.722] {
  [13:34:42.722]     {
  [13:34:42.722]         ...future.startTime <- Sys.time()
  [13:34:42.722]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:42.722]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:42.722]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:42.722]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:42.722]             future.resolve.recursive = NULL, width = 80L)
  [13:34:42.722]         {
  [13:34:42.722]             {
  [13:34:42.722]                 {
  [13:34:42.722]                   {
  [13:34:42.722]                     has_future <- requireNamespace("future", 
  [13:34:42.722]                       quietly = TRUE)
  [13:34:42.722]                     version <- if (has_future) 
  [13:34:42.722]                       packageVersion("future")
  [13:34:42.722]                     else NULL
  [13:34:42.722]                     if (!has_future || version < "1.8.0") {
  [13:34:42.722]                       info <- c(r_version = gsub("R version ", 
  [13:34:42.722]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:42.722]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:42.722]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:42.722]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:42.722]                       info <- sprintf("%s: %s", names(info), 
  [13:34:42.722]                         info)
  [13:34:42.722]                       info <- paste(info, collapse = "; ")
  [13:34:42.722]                       if (!has_future) {
  [13:34:42.722]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:42.722]                           info)
  [13:34:42.722]                       }
  [13:34:42.722]                       else {
  [13:34:42.722]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:42.722]                           info, version)
  [13:34:42.722]                       }
  [13:34:42.722]                       stop(msg)
  [13:34:42.722]                     }
  [13:34:42.722]                   }
  [13:34:42.722]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:42.722]                   options(mc.cores = 1L)
  [13:34:42.722]                 }
  [13:34:42.722]                 local({
  [13:34:42.722]                   for (pkg in "future") {
  [13:34:42.722]                     loadNamespace(pkg)
  [13:34:42.722]                     library(pkg, character.only = TRUE)
  [13:34:42.722]                   }
  [13:34:42.722]                 })
  [13:34:42.722]             }
  [13:34:42.722]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:42.722]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:42.722]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:42.722]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:42.722]                 ...) 
  [13:34:42.722]             {
  [13:34:42.722]                 if (substitute) 
  [13:34:42.722]                   expr <- substitute(expr)
  [13:34:42.722]                 if (is.function(workers)) 
  [13:34:42.722]                   workers <- workers()
  [13:34:42.722]                 workers <- as.integer(workers)
  [13:34:42.722]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:42.722]                   workers >= 1)
  [13:34:42.722]                 if (workers == 1L) {
  [13:34:42.722]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:42.722]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:42.722]                     local = TRUE, label = label, ...))
  [13:34:42.722]                 }
  [13:34:42.722]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:42.722]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:42.722]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:42.722]                   globals = globals, persistent = persistent, 
  [13:34:42.722]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:42.722]                   label = label, ...)
  [13:34:42.722]                 if (!future$lazy) 
  [13:34:42.722]                   future <- run(future)
  [13:34:42.722]                 invisible(future)
  [13:34:42.722]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:42.722]         }
  [13:34:42.722]     }
  [13:34:42.722]     if (is.na(TRUE)) {
  [13:34:42.722]     }
  [13:34:42.722]     else {
  [13:34:42.722]         if (TRUE) {
  [13:34:42.722]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:42.722]         }
  [13:34:42.722]         else {
  [13:34:42.722]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:42.722]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:42.722]         }
  [13:34:42.722]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:42.722]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:42.722]             sink(type = "output", split = FALSE)
  [13:34:42.722]             close(...future.stdout)
  [13:34:42.722]         }, add = TRUE)
  [13:34:42.722]     }
  [13:34:42.722]     ...future.frame <- sys.nframe()
  [13:34:42.722]     ...future.conditions <- list()
  [13:34:42.722]     ...future.result <- tryCatch({
  [13:34:42.722]         withCallingHandlers({
  [13:34:42.722]             ...future.value <- withVisible(local(NA))
  [13:34:42.722]             future::FutureResult(value = ...future.value$value, 
  [13:34:42.722]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:42.722]                 version = "1.8")
  [13:34:42.722]         }, condition = local({
  [13:34:42.722]             inherits <- base::inherits
  [13:34:42.722]             invokeRestart <- base::invokeRestart
  [13:34:42.722]             length <- base::length
  [13:34:42.722]             seq.int <- base::seq.int
  [13:34:42.722]             sys.calls <- base::sys.calls
  [13:34:42.722]             `[[` <- base::`[[`
  [13:34:42.722]             `+` <- base::`+`
  [13:34:42.722]             `<<-` <- base::`<<-`
  [13:34:42.722]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:42.722]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:42.722]                   3L)]
  [13:34:42.722]             }
  [13:34:42.722]             function(cond) {
  [13:34:42.722]                 if (inherits(cond, "error")) {
  [13:34:42.722]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:42.722]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:42.722]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:42.722]                     signaled = 0L)
  [13:34:42.722]                   signalCondition(cond)
  [13:34:42.722]                 }
  [13:34:42.722]                 else if (inherits(cond, "condition")) {
  [13:34:42.722]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:42.722]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:42.722]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:42.722]                   if (!signal) {
  [13:34:42.722]                     muffleCondition <- function (cond) 
  [13:34:42.722]                     {
  [13:34:42.722]                       inherits <- base::inherits
  [13:34:42.722]                       invokeRestart <- base::invokeRestart
  [13:34:42.722]                       muffled <- FALSE
  [13:34:42.722]                       if (inherits(cond, "message")) {
  [13:34:42.722]                         invokeRestart("muffleMessage")
  [13:34:42.722]                         muffled <- TRUE
  [13:34:42.722]                       }
  [13:34:42.722]                       else if (inherits(cond, "warning")) {
  [13:34:42.722]                         invokeRestart("muffleWarning")
  [13:34:42.722]                         muffled <- TRUE
  [13:34:42.722]                       }
  [13:34:42.722]                       else if (inherits(cond, "condition")) {
  [13:34:42.722]                         computeRestarts <- base::computeRestarts
  [13:34:42.722]                         grepl <- base::grepl
  [13:34:42.722]                         is.null <- base::is.null
  [13:34:42.722]                         restarts <- computeRestarts(cond)
  [13:34:42.722]                         for (restart in restarts) {
  [13:34:42.722]                           name <- restart$name
  [13:34:42.722]                           if (is.null(name)) 
  [13:34:42.722]                             next
  [13:34:42.722]                           if (!grepl("^muffle", name)) 
  [13:34:42.722]                             next
  [13:34:42.722]                           invokeRestart(restart)
  [13:34:42.722]                           muffled <- TRUE
  [13:34:42.722]                           break
  [13:34:42.722]                         }
  [13:34:42.722]                       }
  [13:34:42.722]                       invisible(muffled)
  [13:34:42.722]                     }
  [13:34:42.722]                     muffleCondition(cond)
  [13:34:42.722]                   }
  [13:34:42.722]                 }
  [13:34:42.722]             }
  [13:34:42.722]         }))
  [13:34:42.722]     }, error = function(ex) {
  [13:34:42.722]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:42.722]             version = "1.8"), class = "FutureResult")
  [13:34:42.722]     }, finally = {
  [13:34:42.722]         {
  [13:34:42.722]             {
  [13:34:42.722]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:42.722]             }
  [13:34:42.722]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:42.722]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:42.722]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:42.722]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:42.722]                 ...) 
  [13:34:42.722]             {
  [13:34:42.722]                 if (substitute) 
  [13:34:42.722]                   expr <- substitute(expr)
  [13:34:42.722]                 if (is.function(workers)) 
  [13:34:42.722]                   workers <- workers()
  [13:34:42.722]                 workers <- as.integer(workers)
  [13:34:42.722]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:42.722]                   workers >= 1)
  [13:34:42.722]                 if (workers == 1L) {
  [13:34:42.722]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:42.722]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:42.722]                     local = TRUE, label = label, ...))
  [13:34:42.722]                 }
  [13:34:42.722]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:42.722]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:42.722]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:42.722]                   globals = globals, persistent = persistent, 
  [13:34:42.722]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:42.722]                   label = label, ...)
  [13:34:42.722]                 if (!future$lazy) 
  [13:34:42.722]                   future <- run(future)
  [13:34:42.722]                 invisible(future)
  [13:34:42.722]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:42.722]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:34:42.722]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:34:42.722]                 label = NULL, ...) 
  [13:34:42.722]             {
  [13:34:42.722]                 if (substitute) 
  [13:34:42.722]                   expr <- substitute(expr)
  [13:34:42.722]                 if (is.function(workers)) 
  [13:34:42.722]                   workers <- workers()
  [13:34:42.722]                 workers <- as.integer(workers)
  [13:34:42.722]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:42.722]                   workers >= 1)
  [13:34:42.722]                 if (workers == 1L) {
  [13:34:42.722]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:42.722]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:42.722]                     local = TRUE, label = label, ...))
  [13:34:42.722]                 }
  [13:34:42.722]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:42.722]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:42.722]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:42.722]                   globals = globals, persistent = persistent, 
  [13:34:42.722]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:42.722]                   label = label, ...)
  [13:34:42.722]                 if (!future$lazy) 
  [13:34:42.722]                   future <- run(future)
  [13:34:42.722]                 invisible(future)
  [13:34:42.722]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:42.722]         }
  [13:34:42.722]         options(...future.oldOptions)
  [13:34:42.722]     })
  [13:34:42.722]     if (is.na(TRUE)) {
  [13:34:42.722]     }
  [13:34:42.722]     else {
  [13:34:42.722]         sink(type = "output", split = FALSE)
  [13:34:42.722]         if (TRUE) {
  [13:34:42.722]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:42.722]         }
  [13:34:42.722]         else {
  [13:34:42.722]             ...future.result["stdout"] <- list(NULL)
  [13:34:42.722]         }
  [13:34:42.722]         close(...future.stdout)
  [13:34:42.722]         ...future.stdout <- NULL
  [13:34:42.722]     }
  [13:34:42.722]     ...future.result$conditions <- ...future.conditions
  [13:34:42.722]     ...future.result
  [13:34:42.722] }
  [13:34:42.730] MultisessionFuture started
  [13:34:42.730] result() for ClusterFuture ...
  [13:34:42.731] - Validating connection of MultisessionFuture
  [13:34:42.966] - class(result): FutureResult
  [13:34:42.967] result() for ClusterFuture ...
  [13:34:42.967] - result already collected: FutureResult
  [13:34:42.968] result() for ClusterFuture ... done
  [13:34:42.968] result() for ClusterFuture ... done
  [13:34:42.968] result() for ClusterFuture ...
  [13:34:42.969] - result already collected: FutureResult
  [13:34:42.969] result() for ClusterFuture ... done
  [13:34:42.969] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [13:34:42.970] plan(): nbrOfWorkers() = 2
  [13:34:42.971] doFuture() ...
  [13:34:42.975] - dummy globals (as locals): [2] 'a', 'b'
  [13:34:42.976] - R expression:
  [13:34:42.977] {
  [13:34:42.977]     doFuture::registerDoFuture()
  [13:34:42.977]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:42.977]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:42.977]         {
  [13:34:42.977]             a <- NULL
  [13:34:42.977]             b <- NULL
  [13:34:42.977]         }
  [13:34:42.977]         ...future.env <- environment()
  [13:34:42.977]         local({
  [13:34:42.977]             for (name in names(...future.x_jj)) {
  [13:34:42.977]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:42.977]                   inherits = FALSE)
  [13:34:42.977]             }
  [13:34:42.977]         })
  [13:34:42.977]         tryCatch({
  [13:34:42.977]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:42.977]                 plan = future::plan())
  [13:34:42.977]         }, error = identity)
  [13:34:42.977]     })
  [13:34:42.977] }
  [13:34:42.978] - identifying globals and packages ...
  [13:34:42.978] getGlobalsAndPackages() ...
  [13:34:42.992] Searching for globals...
  [13:34:43.029] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:34:43.029] Searching for globals ... DONE
  [13:34:43.030] Resolving globals: FALSE
  [13:34:43.032] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:34:43.032] - globals: [1] '...future.x_ii'
  [13:34:43.032] 
  [13:34:43.033] getGlobalsAndPackages() ... DONE
  [13:34:43.033] List of 1
  [13:34:43.033]  $ ...future.x_ii: NULL
  [13:34:43.033]  - attr(*, "where")=List of 1
  [13:34:43.033]   ..$ ...future.x_ii:<environment: 0x563b860e1618> 
  [13:34:43.033]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:43.033]  - attr(*, "resolved")= logi FALSE
  [13:34:43.033]  - attr(*, "total_size")= num 0
  [13:34:43.056]   - R expression:
  [13:34:43.057] {
  [13:34:43.057]     doFuture::registerDoFuture()
  [13:34:43.057]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:43.057]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:43.057]         {
  [13:34:43.057]             a <- NULL
  [13:34:43.057]             b <- NULL
  [13:34:43.057]         }
  [13:34:43.057]         ...future.env <- environment()
  [13:34:43.057]         local({
  [13:34:43.057]             for (name in names(...future.x_jj)) {
  [13:34:43.057]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:43.057]                   inherits = FALSE)
  [13:34:43.057]             }
  [13:34:43.057]         })
  [13:34:43.057]         tryCatch({
  [13:34:43.057]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:43.057]                 plan = future::plan())
  [13:34:43.057]         }, error = identity)
  [13:34:43.057]     })
  [13:34:43.057] }
  [13:34:43.057]   - globals: [1] '...future.x_ii'
  [13:34:43.058] List of 1
  [13:34:43.058]  $ ...future.x_ii: NULL
  [13:34:43.058]  - attr(*, "where")=List of 1
  [13:34:43.058]   ..$ ...future.x_ii:<environment: 0x563b860e1618> 
  [13:34:43.058]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:43.058]  - attr(*, "resolved")= logi FALSE
  [13:34:43.058]  - attr(*, "total_size")= num 0
  [13:34:43.064]   - packages: [1] 'doFuture'
  [13:34:43.064] - identifying globals and packages ... DONE
  [13:34:43.066] Number of chunks: 2
  [13:34:43.066] Number of futures (= number of chunks): 2
  [13:34:43.066] Launching 2 futures (chunks) ...
  [13:34:43.066] Chunk #1 of 2 ...
  [13:34:43.067]  - Finding globals in 'args_list' chunk #1 ...
  [13:34:43.067] getGlobalsAndPackages() ...
  [13:34:43.067] Searching for globals...
  [13:34:43.068] 
  [13:34:43.069] Searching for globals ... DONE
  [13:34:43.069] - globals: [0] <none>
  [13:34:43.069] getGlobalsAndPackages() ... DONE
  [13:34:43.069] 
  [13:34:43.070] 
  [13:34:43.070]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:34:43.095] getGlobalsAndPackages() ...
  [13:34:43.096] - globals passed as-is: [1] '...future.x_ii'
  [13:34:43.096] Resolving globals: FALSE
  [13:34:43.097] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:43.098] - globals: [1] '...future.x_ii'
  [13:34:43.098] 
  [13:34:43.098] getGlobalsAndPackages() ... DONE
  [13:34:43.100] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:43.101] Packages needed by future strategies (n = 1): 'future'
  [13:34:43.122] {
  [13:34:43.122]     {
  [13:34:43.122]         ...future.startTime <- Sys.time()
  [13:34:43.122]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:43.122]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:43.122]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:43.122]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:43.122]             future.resolve.recursive = NULL, width = 80L)
  [13:34:43.122]         {
  [13:34:43.122]             {
  [13:34:43.122]                 {
  [13:34:43.122]                   {
  [13:34:43.122]                     has_future <- requireNamespace("future", 
  [13:34:43.122]                       quietly = TRUE)
  [13:34:43.122]                     version <- if (has_future) 
  [13:34:43.122]                       packageVersion("future")
  [13:34:43.122]                     else NULL
  [13:34:43.122]                     if (!has_future || version < "1.8.0") {
  [13:34:43.122]                       info <- c(r_version = gsub("R version ", 
  [13:34:43.122]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:43.122]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:43.122]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:43.122]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:43.122]                       info <- sprintf("%s: %s", names(info), 
  [13:34:43.122]                         info)
  [13:34:43.122]                       info <- paste(info, collapse = "; ")
  [13:34:43.122]                       if (!has_future) {
  [13:34:43.122]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:43.122]                           info)
  [13:34:43.122]                       }
  [13:34:43.122]                       else {
  [13:34:43.122]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:43.122]                           info, version)
  [13:34:43.122]                       }
  [13:34:43.122]                       stop(msg)
  [13:34:43.122]                     }
  [13:34:43.122]                   }
  [13:34:43.122]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:43.122]                   options(mc.cores = 1L)
  [13:34:43.122]                 }
  [13:34:43.122]                 local({
  [13:34:43.122]                   for (pkg in c("doFuture", "future")) {
  [13:34:43.122]                     loadNamespace(pkg)
  [13:34:43.122]                     library(pkg, character.only = TRUE)
  [13:34:43.122]                   }
  [13:34:43.122]                 })
  [13:34:43.122]             }
  [13:34:43.122]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:43.122]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:43.122]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:43.122]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:43.122]                 ...) 
  [13:34:43.122]             {
  [13:34:43.122]                 if (substitute) 
  [13:34:43.122]                   expr <- substitute(expr)
  [13:34:43.122]                 if (is.function(workers)) 
  [13:34:43.122]                   workers <- workers()
  [13:34:43.122]                 workers <- as.integer(workers)
  [13:34:43.122]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.122]                   workers >= 1)
  [13:34:43.122]                 if (workers == 1L) {
  [13:34:43.122]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.122]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.122]                     local = TRUE, label = label, ...))
  [13:34:43.122]                 }
  [13:34:43.122]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.122]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.122]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.122]                   globals = globals, persistent = persistent, 
  [13:34:43.122]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.122]                   label = label, ...)
  [13:34:43.122]                 if (!future$lazy) 
  [13:34:43.122]                   future <- run(future)
  [13:34:43.122]                 invisible(future)
  [13:34:43.122]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:43.122]         }
  [13:34:43.122]     }
  [13:34:43.122]     if (is.na(TRUE)) {
  [13:34:43.122]     }
  [13:34:43.122]     else {
  [13:34:43.122]         if (TRUE) {
  [13:34:43.122]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:43.122]         }
  [13:34:43.122]         else {
  [13:34:43.122]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:43.122]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:43.122]         }
  [13:34:43.122]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:43.122]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:43.122]             sink(type = "output", split = FALSE)
  [13:34:43.122]             close(...future.stdout)
  [13:34:43.122]         }, add = TRUE)
  [13:34:43.122]     }
  [13:34:43.122]     ...future.frame <- sys.nframe()
  [13:34:43.122]     ...future.conditions <- list()
  [13:34:43.122]     ...future.result <- tryCatch({
  [13:34:43.122]         withCallingHandlers({
  [13:34:43.122]             ...future.value <- withVisible(local({
  [13:34:43.122]                 doFuture::registerDoFuture()
  [13:34:43.122]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:43.122]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:43.122]                   {
  [13:34:43.122]                     a <- NULL
  [13:34:43.122]                     b <- NULL
  [13:34:43.122]                   }
  [13:34:43.122]                   ...future.env <- environment()
  [13:34:43.122]                   local({
  [13:34:43.122]                     for (name in names(...future.x_jj)) {
  [13:34:43.122]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:43.122]                         inherits = FALSE)
  [13:34:43.122]                     }
  [13:34:43.122]                   })
  [13:34:43.122]                   tryCatch({
  [13:34:43.122]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:43.122]                       plan = future::plan())
  [13:34:43.122]                   }, error = identity)
  [13:34:43.122]                 })
  [13:34:43.122]             }))
  [13:34:43.122]             future::FutureResult(value = ...future.value$value, 
  [13:34:43.122]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:43.122]                 version = "1.8")
  [13:34:43.122]         }, condition = local({
  [13:34:43.122]             inherits <- base::inherits
  [13:34:43.122]             invokeRestart <- base::invokeRestart
  [13:34:43.122]             length <- base::length
  [13:34:43.122]             seq.int <- base::seq.int
  [13:34:43.122]             sys.calls <- base::sys.calls
  [13:34:43.122]             `[[` <- base::`[[`
  [13:34:43.122]             `+` <- base::`+`
  [13:34:43.122]             `<<-` <- base::`<<-`
  [13:34:43.122]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:43.122]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:43.122]                   3L)]
  [13:34:43.122]             }
  [13:34:43.122]             function(cond) {
  [13:34:43.122]                 if (inherits(cond, "error")) {
  [13:34:43.122]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:43.122]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:43.122]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:43.122]                     signaled = 0L)
  [13:34:43.122]                   signalCondition(cond)
  [13:34:43.122]                 }
  [13:34:43.122]                 else if (inherits(cond, "condition")) {
  [13:34:43.122]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:43.122]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:43.122]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:43.122]                   if (!signal) {
  [13:34:43.122]                     muffleCondition <- function (cond) 
  [13:34:43.122]                     {
  [13:34:43.122]                       inherits <- base::inherits
  [13:34:43.122]                       invokeRestart <- base::invokeRestart
  [13:34:43.122]                       muffled <- FALSE
  [13:34:43.122]                       if (inherits(cond, "message")) {
  [13:34:43.122]                         invokeRestart("muffleMessage")
  [13:34:43.122]                         muffled <- TRUE
  [13:34:43.122]                       }
  [13:34:43.122]                       else if (inherits(cond, "warning")) {
  [13:34:43.122]                         invokeRestart("muffleWarning")
  [13:34:43.122]                         muffled <- TRUE
  [13:34:43.122]                       }
  [13:34:43.122]                       else if (inherits(cond, "condition")) {
  [13:34:43.122]                         computeRestarts <- base::computeRestarts
  [13:34:43.122]                         grepl <- base::grepl
  [13:34:43.122]                         is.null <- base::is.null
  [13:34:43.122]                         restarts <- computeRestarts(cond)
  [13:34:43.122]                         for (restart in restarts) {
  [13:34:43.122]                           name <- restart$name
  [13:34:43.122]                           if (is.null(name)) 
  [13:34:43.122]                             next
  [13:34:43.122]                           if (!grepl("^muffle", name)) 
  [13:34:43.122]                             next
  [13:34:43.122]                           invokeRestart(restart)
  [13:34:43.122]                           muffled <- TRUE
  [13:34:43.122]                           break
  [13:34:43.122]                         }
  [13:34:43.122]                       }
  [13:34:43.122]                       invisible(muffled)
  [13:34:43.122]                     }
  [13:34:43.122]                     muffleCondition(cond)
  [13:34:43.122]                   }
  [13:34:43.122]                 }
  [13:34:43.122]             }
  [13:34:43.122]         }))
  [13:34:43.122]     }, error = function(ex) {
  [13:34:43.122]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:43.122]             version = "1.8"), class = "FutureResult")
  [13:34:43.122]     }, finally = {
  [13:34:43.122]         {
  [13:34:43.122]             {
  [13:34:43.122]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:43.122]             }
  [13:34:43.122]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:43.122]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:43.122]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:43.122]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:43.122]                 ...) 
  [13:34:43.122]             {
  [13:34:43.122]                 if (substitute) 
  [13:34:43.122]                   expr <- substitute(expr)
  [13:34:43.122]                 if (is.function(workers)) 
  [13:34:43.122]                   workers <- workers()
  [13:34:43.122]                 workers <- as.integer(workers)
  [13:34:43.122]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.122]                   workers >= 1)
  [13:34:43.122]                 if (workers == 1L) {
  [13:34:43.122]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.122]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.122]                     local = TRUE, label = label, ...))
  [13:34:43.122]                 }
  [13:34:43.122]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.122]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.122]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.122]                   globals = globals, persistent = persistent, 
  [13:34:43.122]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.122]                   label = label, ...)
  [13:34:43.122]                 if (!future$lazy) 
  [13:34:43.122]                   future <- run(future)
  [13:34:43.122]                 invisible(future)
  [13:34:43.122]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:43.122]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:34:43.122]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:34:43.122]                 label = NULL, ...) 
  [13:34:43.122]             {
  [13:34:43.122]                 if (substitute) 
  [13:34:43.122]                   expr <- substitute(expr)
  [13:34:43.122]                 if (is.function(workers)) 
  [13:34:43.122]                   workers <- workers()
  [13:34:43.122]                 workers <- as.integer(workers)
  [13:34:43.122]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.122]                   workers >= 1)
  [13:34:43.122]                 if (workers == 1L) {
  [13:34:43.122]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.122]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.122]                     local = TRUE, label = label, ...))
  [13:34:43.122]                 }
  [13:34:43.122]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.122]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.122]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.122]                   globals = globals, persistent = persistent, 
  [13:34:43.122]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.122]                   label = label, ...)
  [13:34:43.122]                 if (!future$lazy) 
  [13:34:43.122]                   future <- run(future)
  [13:34:43.122]                 invisible(future)
  [13:34:43.122]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:43.122]         }
  [13:34:43.122]         options(...future.oldOptions)
  [13:34:43.122]     })
  [13:34:43.122]     if (is.na(TRUE)) {
  [13:34:43.122]     }
  [13:34:43.122]     else {
  [13:34:43.122]         sink(type = "output", split = FALSE)
  [13:34:43.122]         if (TRUE) {
  [13:34:43.122]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:43.122]         }
  [13:34:43.122]         else {
  [13:34:43.122]             ...future.result["stdout"] <- list(NULL)
  [13:34:43.122]         }
  [13:34:43.122]         close(...future.stdout)
  [13:34:43.122]         ...future.stdout <- NULL
  [13:34:43.122]     }
  [13:34:43.122]     ...future.result$conditions <- ...future.conditions
  [13:34:43.122]     ...future.result
  [13:34:43.122] }
  [13:34:43.128] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [13:34:43.129] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [13:34:43.130] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [13:34:43.130] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [13:34:43.131] MultisessionFuture started
  [13:34:43.132] Chunk #1 of 2 ... DONE
  [13:34:43.132] Chunk #2 of 2 ...
  [13:34:43.132]  - Finding globals in 'args_list' chunk #2 ...
  [13:34:43.133] getGlobalsAndPackages() ...
  [13:34:43.133] Searching for globals...
  [13:34:43.134] 
  [13:34:43.134] Searching for globals ... DONE
  [13:34:43.135] - globals: [0] <none>
  [13:34:43.135] getGlobalsAndPackages() ... DONE
  [13:34:43.135] 
  [13:34:43.135] 
  [13:34:43.136]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:34:43.145] getGlobalsAndPackages() ...
  [13:34:43.146] - globals passed as-is: [1] '...future.x_ii'
  [13:34:43.146] Resolving globals: FALSE
  [13:34:43.163] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:43.164] - globals: [1] '...future.x_ii'
  [13:34:43.164] 
  [13:34:43.164] getGlobalsAndPackages() ... DONE
  [13:34:43.166] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:43.167] Packages needed by future strategies (n = 1): 'future'
  [13:34:43.200] {
  [13:34:43.200]     {
  [13:34:43.200]         ...future.startTime <- Sys.time()
  [13:34:43.200]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:43.200]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:43.200]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:43.200]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:43.200]             future.resolve.recursive = NULL, width = 80L)
  [13:34:43.200]         {
  [13:34:43.200]             {
  [13:34:43.200]                 {
  [13:34:43.200]                   {
  [13:34:43.200]                     has_future <- requireNamespace("future", 
  [13:34:43.200]                       quietly = TRUE)
  [13:34:43.200]                     version <- if (has_future) 
  [13:34:43.200]                       packageVersion("future")
  [13:34:43.200]                     else NULL
  [13:34:43.200]                     if (!has_future || version < "1.8.0") {
  [13:34:43.200]                       info <- c(r_version = gsub("R version ", 
  [13:34:43.200]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:43.200]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:43.200]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:43.200]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:43.200]                       info <- sprintf("%s: %s", names(info), 
  [13:34:43.200]                         info)
  [13:34:43.200]                       info <- paste(info, collapse = "; ")
  [13:34:43.200]                       if (!has_future) {
  [13:34:43.200]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:43.200]                           info)
  [13:34:43.200]                       }
  [13:34:43.200]                       else {
  [13:34:43.200]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:43.200]                           info, version)
  [13:34:43.200]                       }
  [13:34:43.200]                       stop(msg)
  [13:34:43.200]                     }
  [13:34:43.200]                   }
  [13:34:43.200]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:43.200]                   options(mc.cores = 1L)
  [13:34:43.200]                 }
  [13:34:43.200]                 local({
  [13:34:43.200]                   for (pkg in c("doFuture", "future")) {
  [13:34:43.200]                     loadNamespace(pkg)
  [13:34:43.200]                     library(pkg, character.only = TRUE)
  [13:34:43.200]                   }
  [13:34:43.200]                 })
  [13:34:43.200]             }
  [13:34:43.200]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:43.200]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:43.200]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:43.200]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:43.200]                 ...) 
  [13:34:43.200]             {
  [13:34:43.200]                 if (substitute) 
  [13:34:43.200]                   expr <- substitute(expr)
  [13:34:43.200]                 if (is.function(workers)) 
  [13:34:43.200]                   workers <- workers()
  [13:34:43.200]                 workers <- as.integer(workers)
  [13:34:43.200]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.200]                   workers >= 1)
  [13:34:43.200]                 if (workers == 1L) {
  [13:34:43.200]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.200]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.200]                     local = TRUE, label = label, ...))
  [13:34:43.200]                 }
  [13:34:43.200]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.200]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.200]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.200]                   globals = globals, persistent = persistent, 
  [13:34:43.200]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.200]                   label = label, ...)
  [13:34:43.200]                 if (!future$lazy) 
  [13:34:43.200]                   future <- run(future)
  [13:34:43.200]                 invisible(future)
  [13:34:43.200]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:43.200]         }
  [13:34:43.200]     }
  [13:34:43.200]     if (is.na(TRUE)) {
  [13:34:43.200]     }
  [13:34:43.200]     else {
  [13:34:43.200]         if (TRUE) {
  [13:34:43.200]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:43.200]         }
  [13:34:43.200]         else {
  [13:34:43.200]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:43.200]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:43.200]         }
  [13:34:43.200]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:43.200]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:43.200]             sink(type = "output", split = FALSE)
  [13:34:43.200]             close(...future.stdout)
  [13:34:43.200]         }, add = TRUE)
  [13:34:43.200]     }
  [13:34:43.200]     ...future.frame <- sys.nframe()
  [13:34:43.200]     ...future.conditions <- list()
  [13:34:43.200]     ...future.result <- tryCatch({
  [13:34:43.200]         withCallingHandlers({
  [13:34:43.200]             ...future.value <- withVisible(local({
  [13:34:43.200]                 doFuture::registerDoFuture()
  [13:34:43.200]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:43.200]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:43.200]                   {
  [13:34:43.200]                     a <- NULL
  [13:34:43.200]                     b <- NULL
  [13:34:43.200]                   }
  [13:34:43.200]                   ...future.env <- environment()
  [13:34:43.200]                   local({
  [13:34:43.200]                     for (name in names(...future.x_jj)) {
  [13:34:43.200]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:43.200]                         inherits = FALSE)
  [13:34:43.200]                     }
  [13:34:43.200]                   })
  [13:34:43.200]                   tryCatch({
  [13:34:43.200]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:43.200]                       plan = future::plan())
  [13:34:43.200]                   }, error = identity)
  [13:34:43.200]                 })
  [13:34:43.200]             }))
  [13:34:43.200]             future::FutureResult(value = ...future.value$value, 
  [13:34:43.200]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:43.200]                 version = "1.8")
  [13:34:43.200]         }, condition = local({
  [13:34:43.200]             inherits <- base::inherits
  [13:34:43.200]             invokeRestart <- base::invokeRestart
  [13:34:43.200]             length <- base::length
  [13:34:43.200]             seq.int <- base::seq.int
  [13:34:43.200]             sys.calls <- base::sys.calls
  [13:34:43.200]             `[[` <- base::`[[`
  [13:34:43.200]             `+` <- base::`+`
  [13:34:43.200]             `<<-` <- base::`<<-`
  [13:34:43.200]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:43.200]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:43.200]                   3L)]
  [13:34:43.200]             }
  [13:34:43.200]             function(cond) {
  [13:34:43.200]                 if (inherits(cond, "error")) {
  [13:34:43.200]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:43.200]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:43.200]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:43.200]                     signaled = 0L)
  [13:34:43.200]                   signalCondition(cond)
  [13:34:43.200]                 }
  [13:34:43.200]                 else if (inherits(cond, "condition")) {
  [13:34:43.200]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:43.200]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:43.200]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:43.200]                   if (!signal) {
  [13:34:43.200]                     muffleCondition <- function (cond) 
  [13:34:43.200]                     {
  [13:34:43.200]                       inherits <- base::inherits
  [13:34:43.200]                       invokeRestart <- base::invokeRestart
  [13:34:43.200]                       muffled <- FALSE
  [13:34:43.200]                       if (inherits(cond, "message")) {
  [13:34:43.200]                         invokeRestart("muffleMessage")
  [13:34:43.200]                         muffled <- TRUE
  [13:34:43.200]                       }
  [13:34:43.200]                       else if (inherits(cond, "warning")) {
  [13:34:43.200]                         invokeRestart("muffleWarning")
  [13:34:43.200]                         muffled <- TRUE
  [13:34:43.200]                       }
  [13:34:43.200]                       else if (inherits(cond, "condition")) {
  [13:34:43.200]                         computeRestarts <- base::computeRestarts
  [13:34:43.200]                         grepl <- base::grepl
  [13:34:43.200]                         is.null <- base::is.null
  [13:34:43.200]                         restarts <- computeRestarts(cond)
  [13:34:43.200]                         for (restart in restarts) {
  [13:34:43.200]                           name <- restart$name
  [13:34:43.200]                           if (is.null(name)) 
  [13:34:43.200]                             next
  [13:34:43.200]                           if (!grepl("^muffle", name)) 
  [13:34:43.200]                             next
  [13:34:43.200]                           invokeRestart(restart)
  [13:34:43.200]                           muffled <- TRUE
  [13:34:43.200]                           break
  [13:34:43.200]                         }
  [13:34:43.200]                       }
  [13:34:43.200]                       invisible(muffled)
  [13:34:43.200]                     }
  [13:34:43.200]                     muffleCondition(cond)
  [13:34:43.200]                   }
  [13:34:43.200]                 }
  [13:34:43.200]             }
  [13:34:43.200]         }))
  [13:34:43.200]     }, error = function(ex) {
  [13:34:43.200]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:43.200]             version = "1.8"), class = "FutureResult")
  [13:34:43.200]     }, finally = {
  [13:34:43.200]         {
  [13:34:43.200]             {
  [13:34:43.200]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:43.200]             }
  [13:34:43.200]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:43.200]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:43.200]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:43.200]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:43.200]                 ...) 
  [13:34:43.200]             {
  [13:34:43.200]                 if (substitute) 
  [13:34:43.200]                   expr <- substitute(expr)
  [13:34:43.200]                 if (is.function(workers)) 
  [13:34:43.200]                   workers <- workers()
  [13:34:43.200]                 workers <- as.integer(workers)
  [13:34:43.200]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.200]                   workers >= 1)
  [13:34:43.200]                 if (workers == 1L) {
  [13:34:43.200]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.200]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.200]                     local = TRUE, label = label, ...))
  [13:34:43.200]                 }
  [13:34:43.200]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.200]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.200]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.200]                   globals = globals, persistent = persistent, 
  [13:34:43.200]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.200]                   label = label, ...)
  [13:34:43.200]                 if (!future$lazy) 
  [13:34:43.200]                   future <- run(future)
  [13:34:43.200]                 invisible(future)
  [13:34:43.200]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:43.200]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:34:43.200]                 workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
  [13:34:43.200]                 label = NULL, ...) 
  [13:34:43.200]             {
  [13:34:43.200]                 if (substitute) 
  [13:34:43.200]                   expr <- substitute(expr)
  [13:34:43.200]                 if (is.function(workers)) 
  [13:34:43.200]                   workers <- workers()
  [13:34:43.200]                 workers <- as.integer(workers)
  [13:34:43.200]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:43.200]                   workers >= 1)
  [13:34:43.200]                 if (workers == 1L) {
  [13:34:43.200]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:43.200]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:43.200]                     local = TRUE, label = label, ...))
  [13:34:43.200]                 }
  [13:34:43.200]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:43.200]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:43.200]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:43.200]                   globals = globals, persistent = persistent, 
  [13:34:43.200]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:43.200]                   label = label, ...)
  [13:34:43.200]                 if (!future$lazy) 
  [13:34:43.200]                   future <- run(future)
  [13:34:43.200]                 invisible(future)
  [13:34:43.200]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:43.200]         }
  [13:34:43.200]         options(...future.oldOptions)
  [13:34:43.200]     })
  [13:34:43.200]     if (is.na(TRUE)) {
  [13:34:43.200]     }
  [13:34:43.200]     else {
  [13:34:43.200]         sink(type = "output", split = FALSE)
  [13:34:43.200]         if (TRUE) {
  [13:34:43.200]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:43.200]         }
  [13:34:43.200]         else {
  [13:34:43.200]             ...future.result["stdout"] <- list(NULL)
  [13:34:43.200]         }
  [13:34:43.200]         close(...future.stdout)
  [13:34:43.200]         ...future.stdout <- NULL
  [13:34:43.200]     }
  [13:34:43.200]     ...future.result$conditions <- ...future.conditions
  [13:34:43.200]     ...future.result
  [13:34:43.200] }
  [13:34:43.227] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [13:34:43.227] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [13:34:43.228] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [13:34:43.229] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [13:34:43.230] MultisessionFuture started
  [13:34:43.236] Chunk #2 of 2 ... DONE
  [13:34:43.236] Launching 2 futures (chunks) ... DONE
  [13:34:43.237] - resolving futures
  [13:34:43.237]   - gathering results & relaying conditions (except errors)
  [13:34:43.237] resolve() on list ...
  [13:34:43.238]  recursive: 0
  [13:34:43.238]  length: 2
  [13:34:43.238] 
  [13:34:43.375] Future #1
  [13:34:43.375] result() for ClusterFuture ...
  [13:34:43.376] - Validating connection of MultisessionFuture
  [13:34:43.419] - class(result): FutureResult
  [13:34:43.420] result() for ClusterFuture ...
  [13:34:43.420] - result already collected: FutureResult
  [13:34:43.421] result() for ClusterFuture ... done
  [13:34:43.421] result() for ClusterFuture ... done
  [13:34:43.421] result() for ClusterFuture ...
  [13:34:43.422] - result already collected: FutureResult
  [13:34:43.422] result() for ClusterFuture ... done
  [13:34:43.422] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [13:34:43.423] - nx: 2
  [13:34:43.423] - relay: TRUE
  [13:34:43.423] - stdout: TRUE
  [13:34:43.423] - signal: TRUE
  [13:34:43.424] - resignal: FALSE
  [13:34:43.424] - force: FALSE
  [13:34:43.424] - relayed: [n=2] FALSE, FALSE
  [13:34:43.425] - queued futures: [n=2] FALSE, FALSE
  [13:34:43.425]  - until=1
  [13:34:43.425]  - relaying element #1
  [13:34:43.426] result() for ClusterFuture ...
  [13:34:43.426] - result already collected: FutureResult
  [13:34:43.426] result() for ClusterFuture ... done
  [13:34:43.427] result() for ClusterFuture ...
  [13:34:43.427] - result already collected: FutureResult
  [13:34:43.427] result() for ClusterFuture ... done
  [13:34:43.428] result() for ClusterFuture ...
  [13:34:43.428] - result already collected: FutureResult
  [13:34:43.428] result() for ClusterFuture ... done
  [13:34:43.429] result() for ClusterFuture ...
  [13:34:43.429] - result already collected: FutureResult
  [13:34:43.429] result() for ClusterFuture ... done
  [13:34:43.430] - relayed: [n=2] TRUE, FALSE
  [13:34:43.430] - queued futures: [n=2] TRUE, FALSE
  [13:34:43.430] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [13:34:43.431]  length: 1 (resolved future 1)
  [13:34:43.607] Future #2
  [13:34:43.608] result() for ClusterFuture ...
  [13:34:43.608] - Validating connection of MultisessionFuture
  [13:34:43.655] - class(result): FutureResult
  [13:34:43.656] result() for ClusterFuture ...
  [13:34:43.656] - result already collected: FutureResult
  [13:34:43.657] result() for ClusterFuture ... done
  [13:34:43.657] result() for ClusterFuture ... done
  [13:34:43.657] result() for ClusterFuture ...
  [13:34:43.658] - result already collected: FutureResult
  [13:34:43.658] result() for ClusterFuture ... done
  [13:34:43.659] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [13:34:43.659] - nx: 2
  [13:34:43.659] - relay: TRUE
  [13:34:43.660] - stdout: TRUE
  [13:34:43.660] - signal: TRUE
  [13:34:43.660] - resignal: FALSE
  [13:34:43.661] - force: FALSE
  [13:34:43.661] - relayed: [n=2] TRUE, FALSE
  [13:34:43.661] - queued futures: [n=2] TRUE, FALSE
  [13:34:43.662]  - until=2
  [13:34:43.662]  - relaying element #2
  [13:34:43.662] result() for ClusterFuture ...
  [13:34:43.663] - result already collected: FutureResult
  [13:34:43.663] result() for ClusterFuture ... done
  [13:34:43.663] result() for ClusterFuture ...
  [13:34:43.664] - result already collected: FutureResult
  [13:34:43.664] result() for ClusterFuture ... done
  [13:34:43.664] result() for ClusterFuture ...
  [13:34:43.665] - result already collected: FutureResult
  [13:34:43.665] result() for ClusterFuture ... done
  [13:34:43.665] result() for ClusterFuture ...
  [13:34:43.666] - result already collected: FutureResult
  [13:34:43.666] result() for ClusterFuture ... done
  [13:34:43.666] - relayed: [n=2] TRUE, TRUE
  [13:34:43.667] - queued futures: [n=2] TRUE, TRUE
  [13:34:43.667] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [13:34:43.667]  length: 0 (resolved future 2)
  [13:34:43.668] Relaying remaining futures
  [13:34:43.668] signalConditionsASAP(NULL, pos=0) ...
  [13:34:43.668] - nx: 2
  [13:34:43.669] - relay: TRUE
  [13:34:43.669] - stdout: TRUE
  [13:34:43.669] - signal: TRUE
  [13:34:43.669] - resignal: FALSE
  [13:34:43.670] - force: FALSE
  [13:34:43.670] - relayed: [n=2] TRUE, TRUE
  [13:34:43.670] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:34:43.671] - relayed: [n=2] TRUE, TRUE
  [13:34:43.671] - queued futures: [n=2] TRUE, TRUE
  [13:34:43.671] signalConditionsASAP(NULL, pos=0) ... done
  [13:34:43.672] resolve() on list ... DONE
  [13:34:43.672] - collecting values of futures
  [13:34:43.672] result() for ClusterFuture ...
  [13:34:43.673] - result already collected: FutureResult
  [13:34:43.673] result() for ClusterFuture ... done
  [13:34:43.673] result() for ClusterFuture ...
  [13:34:43.674] - result already collected: FutureResult
  [13:34:43.674] result() for ClusterFuture ... done
  [13:34:43.674] result() for ClusterFuture ...
  [13:34:43.675] - result already collected: FutureResult
  [13:34:43.675] result() for ClusterFuture ... done
  [13:34:43.675] result() for ClusterFuture ...
  [13:34:43.676] - result already collected: FutureResult
  [13:34:43.676] result() for ClusterFuture ... done
  [13:34:43.676] - accumulating results
  [13:34:43.679] - processing errors (handler = 'stop')
  [13:34:43.679] - extracting results
  [13:34:43.680] doFuture() ... DONE
  - plan(list('multisession', 'multisession')) ... DONE
  - plan(list('multisession', 'cluster')) ...
  [13:34:43.681] plan(): Setting new future strategy stack:
  [13:34:43.681] List of future strategies:
  [13:34:43.681] 1. multisession:
  [13:34:43.681]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:43.681]    - tweaked: FALSE
  [13:34:43.681]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:43.681] 2. cluster:
  [13:34:43.681]    - 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, ...)
  [13:34:43.681]    - tweaked: FALSE
  [13:34:43.681]    - call: plan(list(a = strategy1, b = strategy2))
  [13:34:43.684] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [13:34:43.684] multisession:
  [13:34:43.684] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [13:34:43.684] - tweaked: FALSE
  [13:34:43.684] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 30274
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d7205e4ee.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d7205e4ee.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d7205e4ee.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=30274 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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d274d300b.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d274d300b.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d274d300b.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=30274 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
  [13:34:59.569] getGlobalsAndPackages() ...
  [13:34:59.570] Not searching for globals
  [13:34:59.570] - globals: [0] <none>
  [13:34:59.571] getGlobalsAndPackages() ... DONE
  [13:34:59.573] Packages needed by the future expression (n = 0): <none>
  [13:34:59.573] Packages needed by future strategies (n = 1): 'future'
  [13:34:59.594] {
  [13:34:59.594]     {
  [13:34:59.594]         ...future.startTime <- Sys.time()
  [13:34:59.594]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:59.594]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:59.594]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:59.594]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:59.594]             future.resolve.recursive = NULL, width = 80L)
  [13:34:59.594]         {
  [13:34:59.594]             {
  [13:34:59.594]                 {
  [13:34:59.594]                   {
  [13:34:59.594]                     has_future <- requireNamespace("future", 
  [13:34:59.594]                       quietly = TRUE)
  [13:34:59.594]                     version <- if (has_future) 
  [13:34:59.594]                       packageVersion("future")
  [13:34:59.594]                     else NULL
  [13:34:59.594]                     if (!has_future || version < "1.8.0") {
  [13:34:59.594]                       info <- c(r_version = gsub("R version ", 
  [13:34:59.594]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:59.594]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:59.594]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:59.594]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:59.594]                       info <- sprintf("%s: %s", names(info), 
  [13:34:59.594]                         info)
  [13:34:59.594]                       info <- paste(info, collapse = "; ")
  [13:34:59.594]                       if (!has_future) {
  [13:34:59.594]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:59.594]                           info)
  [13:34:59.594]                       }
  [13:34:59.594]                       else {
  [13:34:59.594]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:59.594]                           info, version)
  [13:34:59.594]                       }
  [13:34:59.594]                       stop(msg)
  [13:34:59.594]                     }
  [13:34:59.594]                   }
  [13:34:59.594]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:59.594]                   options(mc.cores = 1L)
  [13:34:59.594]                 }
  [13:34:59.594]                 local({
  [13:34:59.594]                   for (pkg in "future") {
  [13:34:59.594]                     loadNamespace(pkg)
  [13:34:59.594]                     library(pkg, character.only = TRUE)
  [13:34:59.594]                   }
  [13:34:59.594]                 })
  [13:34:59.594]             }
  [13:34:59.594]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:59.594]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:59.594]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:34:59.594]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:34:59.594]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:59.594]                 ...) 
  [13:34:59.594]             {
  [13:34:59.594]                 if (substitute) 
  [13:34:59.594]                   expr <- substitute(expr)
  [13:34:59.594]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:34:59.594]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.594]                   globals = globals, persistent = persistent, 
  [13:34:59.594]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:34:59.594]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:34:59.594]                   label = label, ...)
  [13:34:59.594]                 if (!future$lazy) 
  [13:34:59.594]                   future <- run(future)
  [13:34:59.594]                 invisible(future)
  [13:34:59.594]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:59.594]         }
  [13:34:59.594]     }
  [13:34:59.594]     if (is.na(TRUE)) {
  [13:34:59.594]     }
  [13:34:59.594]     else {
  [13:34:59.594]         if (TRUE) {
  [13:34:59.594]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:59.594]         }
  [13:34:59.594]         else {
  [13:34:59.594]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:59.594]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:59.594]         }
  [13:34:59.594]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:59.594]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:59.594]             sink(type = "output", split = FALSE)
  [13:34:59.594]             close(...future.stdout)
  [13:34:59.594]         }, add = TRUE)
  [13:34:59.594]     }
  [13:34:59.594]     ...future.frame <- sys.nframe()
  [13:34:59.594]     ...future.conditions <- list()
  [13:34:59.594]     ...future.result <- tryCatch({
  [13:34:59.594]         withCallingHandlers({
  [13:34:59.594]             ...future.value <- withVisible(local(NA))
  [13:34:59.594]             future::FutureResult(value = ...future.value$value, 
  [13:34:59.594]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:59.594]                 version = "1.8")
  [13:34:59.594]         }, condition = local({
  [13:34:59.594]             inherits <- base::inherits
  [13:34:59.594]             invokeRestart <- base::invokeRestart
  [13:34:59.594]             length <- base::length
  [13:34:59.594]             seq.int <- base::seq.int
  [13:34:59.594]             sys.calls <- base::sys.calls
  [13:34:59.594]             `[[` <- base::`[[`
  [13:34:59.594]             `+` <- base::`+`
  [13:34:59.594]             `<<-` <- base::`<<-`
  [13:34:59.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:59.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:59.594]                   3L)]
  [13:34:59.594]             }
  [13:34:59.594]             function(cond) {
  [13:34:59.594]                 if (inherits(cond, "error")) {
  [13:34:59.594]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:59.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:59.594]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:59.594]                     signaled = 0L)
  [13:34:59.594]                   signalCondition(cond)
  [13:34:59.594]                 }
  [13:34:59.594]                 else if (inherits(cond, "condition")) {
  [13:34:59.594]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:59.594]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:59.594]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:59.594]                   if (!signal) {
  [13:34:59.594]                     muffleCondition <- function (cond) 
  [13:34:59.594]                     {
  [13:34:59.594]                       inherits <- base::inherits
  [13:34:59.594]                       invokeRestart <- base::invokeRestart
  [13:34:59.594]                       muffled <- FALSE
  [13:34:59.594]                       if (inherits(cond, "message")) {
  [13:34:59.594]                         invokeRestart("muffleMessage")
  [13:34:59.594]                         muffled <- TRUE
  [13:34:59.594]                       }
  [13:34:59.594]                       else if (inherits(cond, "warning")) {
  [13:34:59.594]                         invokeRestart("muffleWarning")
  [13:34:59.594]                         muffled <- TRUE
  [13:34:59.594]                       }
  [13:34:59.594]                       else if (inherits(cond, "condition")) {
  [13:34:59.594]                         computeRestarts <- base::computeRestarts
  [13:34:59.594]                         grepl <- base::grepl
  [13:34:59.594]                         is.null <- base::is.null
  [13:34:59.594]                         restarts <- computeRestarts(cond)
  [13:34:59.594]                         for (restart in restarts) {
  [13:34:59.594]                           name <- restart$name
  [13:34:59.594]                           if (is.null(name)) 
  [13:34:59.594]                             next
  [13:34:59.594]                           if (!grepl("^muffle", name)) 
  [13:34:59.594]                             next
  [13:34:59.594]                           invokeRestart(restart)
  [13:34:59.594]                           muffled <- TRUE
  [13:34:59.594]                           break
  [13:34:59.594]                         }
  [13:34:59.594]                       }
  [13:34:59.594]                       invisible(muffled)
  [13:34:59.594]                     }
  [13:34:59.594]                     muffleCondition(cond)
  [13:34:59.594]                   }
  [13:34:59.594]                 }
  [13:34:59.594]             }
  [13:34:59.594]         }))
  [13:34:59.594]     }, error = function(ex) {
  [13:34:59.594]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:59.594]             version = "1.8"), class = "FutureResult")
  [13:34:59.594]     }, finally = {
  [13:34:59.594]         {
  [13:34:59.594]             {
  [13:34:59.594]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:59.594]             }
  [13:34:59.594]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:59.594]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:59.594]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:59.594]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:59.594]                 ...) 
  [13:34:59.594]             {
  [13:34:59.594]                 if (substitute) 
  [13:34:59.594]                   expr <- substitute(expr)
  [13:34:59.594]                 if (is.function(workers)) 
  [13:34:59.594]                   workers <- workers()
  [13:34:59.594]                 workers <- as.integer(workers)
  [13:34:59.594]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:59.594]                   workers >= 1)
  [13:34:59.594]                 if (workers == 1L) {
  [13:34:59.594]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:59.594]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:59.594]                     local = TRUE, label = label, ...))
  [13:34:59.594]                 }
  [13:34:59.594]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:59.594]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:59.594]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.594]                   globals = globals, persistent = persistent, 
  [13:34:59.594]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:59.594]                   label = label, ...)
  [13:34:59.594]                 if (!future$lazy) 
  [13:34:59.594]                   future <- run(future)
  [13:34:59.594]                 invisible(future)
  [13:34:59.594]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:59.594]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:34:59.594]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:34:59.594]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:34:59.594]                 label = NULL, ...) 
  [13:34:59.594]             {
  [13:34:59.594]                 if (substitute) 
  [13:34:59.594]                   expr <- substitute(expr)
  [13:34:59.594]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:34:59.594]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.594]                   globals = globals, persistent = persistent, 
  [13:34:59.594]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:34:59.594]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:34:59.594]                   label = label, ...)
  [13:34:59.594]                 if (!future$lazy) 
  [13:34:59.594]                   future <- run(future)
  [13:34:59.594]                 invisible(future)
  [13:34:59.594]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:59.594]         }
  [13:34:59.594]         options(...future.oldOptions)
  [13:34:59.594]     })
  [13:34:59.594]     if (is.na(TRUE)) {
  [13:34:59.594]     }
  [13:34:59.594]     else {
  [13:34:59.594]         sink(type = "output", split = FALSE)
  [13:34:59.594]         if (TRUE) {
  [13:34:59.594]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:59.594]         }
  [13:34:59.594]         else {
  [13:34:59.594]             ...future.result["stdout"] <- list(NULL)
  [13:34:59.594]         }
  [13:34:59.594]         close(...future.stdout)
  [13:34:59.594]         ...future.stdout <- NULL
  [13:34:59.594]     }
  [13:34:59.594]     ...future.result$conditions <- ...future.conditions
  [13:34:59.594]     ...future.result
  [13:34:59.594] }
  [13:34:59.600] MultisessionFuture started
  [13:34:59.601] result() for ClusterFuture ...
  [13:34:59.601] - Validating connection of MultisessionFuture
  [13:34:59.851] - class(result): FutureResult
  [13:34:59.851] result() for ClusterFuture ...
  [13:34:59.852] - result already collected: FutureResult
  [13:34:59.852] result() for ClusterFuture ... done
  [13:34:59.852] result() for ClusterFuture ... done
  [13:34:59.853] result() for ClusterFuture ...
  [13:34:59.853] - result already collected: FutureResult
  [13:34:59.853] result() for ClusterFuture ... done
  [13:34:59.854] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [13:34:59.855] plan(): nbrOfWorkers() = 2
  [13:34:59.855] doFuture() ...
  [13:34:59.860] - dummy globals (as locals): [2] 'a', 'b'
  [13:34:59.861] - R expression:
  [13:34:59.861] {
  [13:34:59.861]     doFuture::registerDoFuture()
  [13:34:59.861]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:59.861]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:59.861]         {
  [13:34:59.861]             a <- NULL
  [13:34:59.861]             b <- NULL
  [13:34:59.861]         }
  [13:34:59.861]         ...future.env <- environment()
  [13:34:59.861]         local({
  [13:34:59.861]             for (name in names(...future.x_jj)) {
  [13:34:59.861]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:59.861]                   inherits = FALSE)
  [13:34:59.861]             }
  [13:34:59.861]         })
  [13:34:59.861]         tryCatch({
  [13:34:59.861]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:59.861]                 plan = future::plan())
  [13:34:59.861]         }, error = identity)
  [13:34:59.861]     })
  [13:34:59.861] }
  [13:34:59.862] - identifying globals and packages ...
  [13:34:59.862] getGlobalsAndPackages() ...
  [13:34:59.863] Searching for globals...
  [13:34:59.894] - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  [13:34:59.894] Searching for globals ... DONE
  [13:34:59.894] Resolving globals: FALSE
  [13:34:59.896] The total size of the 1 globals is 0 bytes (0 bytes)
  [13:34:59.896] - globals: [1] '...future.x_ii'
  [13:34:59.897] 
  [13:34:59.897] getGlobalsAndPackages() ... DONE
  [13:34:59.897] List of 1
  [13:34:59.897]  $ ...future.x_ii: NULL
  [13:34:59.897]  - attr(*, "where")=List of 1
  [13:34:59.897]   ..$ ...future.x_ii:<environment: 0x563b846aaa48> 
  [13:34:59.897]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:59.897]  - attr(*, "resolved")= logi FALSE
  [13:34:59.897]  - attr(*, "total_size")= num 0
  [13:34:59.924]   - R expression:
  [13:34:59.924] {
  [13:34:59.924]     doFuture::registerDoFuture()
  [13:34:59.924]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:59.924]         ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:59.924]         {
  [13:34:59.924]             a <- NULL
  [13:34:59.924]             b <- NULL
  [13:34:59.924]         }
  [13:34:59.924]         ...future.env <- environment()
  [13:34:59.924]         local({
  [13:34:59.924]             for (name in names(...future.x_jj)) {
  [13:34:59.924]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:59.924]                   inherits = FALSE)
  [13:34:59.924]             }
  [13:34:59.924]         })
  [13:34:59.924]         tryCatch({
  [13:34:59.924]             list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:59.924]                 plan = future::plan())
  [13:34:59.924]         }, error = identity)
  [13:34:59.924]     })
  [13:34:59.924] }
  [13:34:59.925]   - globals: [1] '...future.x_ii'
  [13:34:59.925] List of 1
  [13:34:59.925]  $ ...future.x_ii: NULL
  [13:34:59.925]  - attr(*, "where")=List of 1
  [13:34:59.925]   ..$ ...future.x_ii:<environment: 0x563b846aaa48> 
  [13:34:59.925]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [13:34:59.925]  - attr(*, "resolved")= logi FALSE
  [13:34:59.925]  - attr(*, "total_size")= num 0
  [13:34:59.948]   - packages: [1] 'doFuture'
  [13:34:59.948] - identifying globals and packages ... DONE
  [13:34:59.949] Number of chunks: 2
  [13:34:59.949] Number of futures (= number of chunks): 2
  [13:34:59.950] Launching 2 futures (chunks) ...
  [13:34:59.950] Chunk #1 of 2 ...
  [13:34:59.950]  - Finding globals in 'args_list' chunk #1 ...
  [13:34:59.951] getGlobalsAndPackages() ...
  [13:34:59.951] Searching for globals...
  [13:34:59.952] 
  [13:34:59.952] Searching for globals ... DONE
  [13:34:59.952] - globals: [0] <none>
  [13:34:59.953] getGlobalsAndPackages() ... DONE
  [13:34:59.953] 
  [13:34:59.953] 
  [13:34:59.953]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [13:34:59.961] getGlobalsAndPackages() ...
  [13:34:59.962] - globals passed as-is: [1] '...future.x_ii'
  [13:34:59.962] Resolving globals: FALSE
  [13:34:59.979] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:34:59.980] - globals: [1] '...future.x_ii'
  [13:34:59.980] 
  [13:34:59.980] getGlobalsAndPackages() ... DONE
  [13:34:59.982] Packages needed by the future expression (n = 1): 'doFuture'
  [13:34:59.983] Packages needed by future strategies (n = 1): 'future'
  [13:34:59.987] {
  [13:34:59.987]     {
  [13:34:59.987]         ...future.startTime <- Sys.time()
  [13:34:59.987]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:34:59.987]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:34:59.987]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:34:59.987]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:34:59.987]             future.resolve.recursive = NULL, width = 80L)
  [13:34:59.987]         {
  [13:34:59.987]             {
  [13:34:59.987]                 {
  [13:34:59.987]                   {
  [13:34:59.987]                     has_future <- requireNamespace("future", 
  [13:34:59.987]                       quietly = TRUE)
  [13:34:59.987]                     version <- if (has_future) 
  [13:34:59.987]                       packageVersion("future")
  [13:34:59.987]                     else NULL
  [13:34:59.987]                     if (!has_future || version < "1.8.0") {
  [13:34:59.987]                       info <- c(r_version = gsub("R version ", 
  [13:34:59.987]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:34:59.987]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:34:59.987]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:34:59.987]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:34:59.987]                       info <- sprintf("%s: %s", names(info), 
  [13:34:59.987]                         info)
  [13:34:59.987]                       info <- paste(info, collapse = "; ")
  [13:34:59.987]                       if (!has_future) {
  [13:34:59.987]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:34:59.987]                           info)
  [13:34:59.987]                       }
  [13:34:59.987]                       else {
  [13:34:59.987]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:34:59.987]                           info, version)
  [13:34:59.987]                       }
  [13:34:59.987]                       stop(msg)
  [13:34:59.987]                     }
  [13:34:59.987]                   }
  [13:34:59.987]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:34:59.987]                   options(mc.cores = 1L)
  [13:34:59.987]                 }
  [13:34:59.987]                 local({
  [13:34:59.987]                   for (pkg in c("doFuture", "future")) {
  [13:34:59.987]                     loadNamespace(pkg)
  [13:34:59.987]                     library(pkg, character.only = TRUE)
  [13:34:59.987]                   }
  [13:34:59.987]                 })
  [13:34:59.987]             }
  [13:34:59.987]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:34:59.987]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:59.987]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:34:59.987]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:34:59.987]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:59.987]                 ...) 
  [13:34:59.987]             {
  [13:34:59.987]                 if (substitute) 
  [13:34:59.987]                   expr <- substitute(expr)
  [13:34:59.987]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:34:59.987]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.987]                   globals = globals, persistent = persistent, 
  [13:34:59.987]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:34:59.987]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:34:59.987]                   label = label, ...)
  [13:34:59.987]                 if (!future$lazy) 
  [13:34:59.987]                   future <- run(future)
  [13:34:59.987]                 invisible(future)
  [13:34:59.987]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:59.987]         }
  [13:34:59.987]     }
  [13:34:59.987]     if (is.na(TRUE)) {
  [13:34:59.987]     }
  [13:34:59.987]     else {
  [13:34:59.987]         if (TRUE) {
  [13:34:59.987]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:34:59.987]         }
  [13:34:59.987]         else {
  [13:34:59.987]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:34:59.987]                 windows = "NUL", "/dev/null"), open = "w")
  [13:34:59.987]         }
  [13:34:59.987]         sink(...future.stdout, type = "output", split = FALSE)
  [13:34:59.987]         on.exit(if (!is.null(...future.stdout)) {
  [13:34:59.987]             sink(type = "output", split = FALSE)
  [13:34:59.987]             close(...future.stdout)
  [13:34:59.987]         }, add = TRUE)
  [13:34:59.987]     }
  [13:34:59.987]     ...future.frame <- sys.nframe()
  [13:34:59.987]     ...future.conditions <- list()
  [13:34:59.987]     ...future.result <- tryCatch({
  [13:34:59.987]         withCallingHandlers({
  [13:34:59.987]             ...future.value <- withVisible(local({
  [13:34:59.987]                 doFuture::registerDoFuture()
  [13:34:59.987]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:34:59.987]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:34:59.987]                   {
  [13:34:59.987]                     a <- NULL
  [13:34:59.987]                     b <- NULL
  [13:34:59.987]                   }
  [13:34:59.987]                   ...future.env <- environment()
  [13:34:59.987]                   local({
  [13:34:59.987]                     for (name in names(...future.x_jj)) {
  [13:34:59.987]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:34:59.987]                         inherits = FALSE)
  [13:34:59.987]                     }
  [13:34:59.987]                   })
  [13:34:59.987]                   tryCatch({
  [13:34:59.987]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:34:59.987]                       plan = future::plan())
  [13:34:59.987]                   }, error = identity)
  [13:34:59.987]                 })
  [13:34:59.987]             }))
  [13:34:59.987]             future::FutureResult(value = ...future.value$value, 
  [13:34:59.987]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:34:59.987]                 version = "1.8")
  [13:34:59.987]         }, condition = local({
  [13:34:59.987]             inherits <- base::inherits
  [13:34:59.987]             invokeRestart <- base::invokeRestart
  [13:34:59.987]             length <- base::length
  [13:34:59.987]             seq.int <- base::seq.int
  [13:34:59.987]             sys.calls <- base::sys.calls
  [13:34:59.987]             `[[` <- base::`[[`
  [13:34:59.987]             `+` <- base::`+`
  [13:34:59.987]             `<<-` <- base::`<<-`
  [13:34:59.987]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:34:59.987]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:34:59.987]                   3L)]
  [13:34:59.987]             }
  [13:34:59.987]             function(cond) {
  [13:34:59.987]                 if (inherits(cond, "error")) {
  [13:34:59.987]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:59.987]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:34:59.987]                     cond$call), timestamp = base::Sys.time(), 
  [13:34:59.987]                     signaled = 0L)
  [13:34:59.987]                   signalCondition(cond)
  [13:34:59.987]                 }
  [13:34:59.987]                 else if (inherits(cond, "condition")) {
  [13:34:59.987]                   signal <- FALSE && inherits(cond, character(0))
  [13:34:59.987]                   ...future.conditions[[length(...future.conditions) + 
  [13:34:59.987]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:34:59.987]                   if (!signal) {
  [13:34:59.987]                     muffleCondition <- function (cond) 
  [13:34:59.987]                     {
  [13:34:59.987]                       inherits <- base::inherits
  [13:34:59.987]                       invokeRestart <- base::invokeRestart
  [13:34:59.987]                       muffled <- FALSE
  [13:34:59.987]                       if (inherits(cond, "message")) {
  [13:34:59.987]                         invokeRestart("muffleMessage")
  [13:34:59.987]                         muffled <- TRUE
  [13:34:59.987]                       }
  [13:34:59.987]                       else if (inherits(cond, "warning")) {
  [13:34:59.987]                         invokeRestart("muffleWarning")
  [13:34:59.987]                         muffled <- TRUE
  [13:34:59.987]                       }
  [13:34:59.987]                       else if (inherits(cond, "condition")) {
  [13:34:59.987]                         computeRestarts <- base::computeRestarts
  [13:34:59.987]                         grepl <- base::grepl
  [13:34:59.987]                         is.null <- base::is.null
  [13:34:59.987]                         restarts <- computeRestarts(cond)
  [13:34:59.987]                         for (restart in restarts) {
  [13:34:59.987]                           name <- restart$name
  [13:34:59.987]                           if (is.null(name)) 
  [13:34:59.987]                             next
  [13:34:59.987]                           if (!grepl("^muffle", name)) 
  [13:34:59.987]                             next
  [13:34:59.987]                           invokeRestart(restart)
  [13:34:59.987]                           muffled <- TRUE
  [13:34:59.987]                           break
  [13:34:59.987]                         }
  [13:34:59.987]                       }
  [13:34:59.987]                       invisible(muffled)
  [13:34:59.987]                     }
  [13:34:59.987]                     muffleCondition(cond)
  [13:34:59.987]                   }
  [13:34:59.987]                 }
  [13:34:59.987]             }
  [13:34:59.987]         }))
  [13:34:59.987]     }, error = function(ex) {
  [13:34:59.987]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:34:59.987]             version = "1.8"), class = "FutureResult")
  [13:34:59.987]     }, finally = {
  [13:34:59.987]         {
  [13:34:59.987]             {
  [13:34:59.987]                 options(mc.cores = ...future.mc.cores.old)
  [13:34:59.987]             }
  [13:34:59.987]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:34:59.987]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:34:59.987]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:34:59.987]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:34:59.987]                 ...) 
  [13:34:59.987]             {
  [13:34:59.987]                 if (substitute) 
  [13:34:59.987]                   expr <- substitute(expr)
  [13:34:59.987]                 if (is.function(workers)) 
  [13:34:59.987]                   workers <- workers()
  [13:34:59.987]                 workers <- as.integer(workers)
  [13:34:59.987]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:34:59.987]                   workers >= 1)
  [13:34:59.987]                 if (workers == 1L) {
  [13:34:59.987]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:34:59.987]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:34:59.987]                     local = TRUE, label = label, ...))
  [13:34:59.987]                 }
  [13:34:59.987]                 workers <- ClusterRegistry("start", workers = workers)
  [13:34:59.987]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:34:59.987]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.987]                   globals = globals, persistent = persistent, 
  [13:34:59.987]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:34:59.987]                   label = label, ...)
  [13:34:59.987]                 if (!future$lazy) 
  [13:34:59.987]                   future <- run(future)
  [13:34:59.987]                 invisible(future)
  [13:34:59.987]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:34:59.987]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:34:59.987]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:34:59.987]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:34:59.987]                 label = NULL, ...) 
  [13:34:59.987]             {
  [13:34:59.987]                 if (substitute) 
  [13:34:59.987]                   expr <- substitute(expr)
  [13:34:59.987]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:34:59.987]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:34:59.987]                   globals = globals, persistent = persistent, 
  [13:34:59.987]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:34:59.987]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:34:59.987]                   label = label, ...)
  [13:34:59.987]                 if (!future$lazy) 
  [13:34:59.987]                   future <- run(future)
  [13:34:59.987]                 invisible(future)
  [13:34:59.987]             }), .cleanup = FALSE, .init = FALSE)
  [13:34:59.987]         }
  [13:34:59.987]         options(...future.oldOptions)
  [13:34:59.987]     })
  [13:34:59.987]     if (is.na(TRUE)) {
  [13:34:59.987]     }
  [13:34:59.987]     else {
  [13:34:59.987]         sink(type = "output", split = FALSE)
  [13:34:59.987]         if (TRUE) {
  [13:34:59.987]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:34:59.987]         }
  [13:34:59.987]         else {
  [13:34:59.987]             ...future.result["stdout"] <- list(NULL)
  [13:34:59.987]         }
  [13:34:59.987]         close(...future.stdout)
  [13:34:59.987]         ...future.stdout <- NULL
  [13:34:59.987]     }
  [13:34:59.987]     ...future.result$conditions <- ...future.conditions
  [13:34:59.987]     ...future.result
  [13:34:59.987] }
  [13:34:59.994] Exporting 1 global objects (336 bytes) to cluster node #1 ...
  [13:34:59.994] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ...
  [13:34:59.995] Exporting '...future.x_ii' (336 bytes) to cluster node #1 ... DONE
  [13:34:59.996] Exporting 1 global objects (336 bytes) to cluster node #1 ... DONE
  [13:34:59.997] MultisessionFuture started
  [13:34:59.997] Chunk #1 of 2 ... DONE
  [13:34:59.997] Chunk #2 of 2 ...
  [13:34:59.998]  - Finding globals in 'args_list' chunk #2 ...
  [13:34:59.998] getGlobalsAndPackages() ...
  [13:34:59.998] Searching for globals...
  [13:34:59.999] 
  [13:35:00.000] Searching for globals ... DONE
  [13:35:00.000] - globals: [0] <none>
  [13:35:00.000] getGlobalsAndPackages() ... DONE
  [13:35:00.000] 
  [13:35:00.001] 
  [13:35:00.001]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [13:35:00.010] getGlobalsAndPackages() ...
  [13:35:00.010] - globals passed as-is: [1] '...future.x_ii'
  [13:35:00.011] Resolving globals: FALSE
  [13:35:00.012] The total size of the 1 globals is 336 bytes (336 bytes)
  [13:35:00.012] - globals: [1] '...future.x_ii'
  [13:35:00.013] 
  [13:35:00.013] getGlobalsAndPackages() ... DONE
  [13:35:00.015] Packages needed by the future expression (n = 1): 'doFuture'
  [13:35:00.015] Packages needed by future strategies (n = 1): 'future'
  [13:35:00.020] {
  [13:35:00.020]     {
  [13:35:00.020]         ...future.startTime <- Sys.time()
  [13:35:00.020]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [13:35:00.020]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [13:35:00.020]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [13:35:00.020]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [13:35:00.020]             future.resolve.recursive = NULL, width = 80L)
  [13:35:00.020]         {
  [13:35:00.020]             {
  [13:35:00.020]                 {
  [13:35:00.020]                   {
  [13:35:00.020]                     has_future <- requireNamespace("future", 
  [13:35:00.020]                       quietly = TRUE)
  [13:35:00.020]                     version <- if (has_future) 
  [13:35:00.020]                       packageVersion("future")
  [13:35:00.020]                     else NULL
  [13:35:00.020]                     if (!has_future || version < "1.8.0") {
  [13:35:00.020]                       info <- c(r_version = gsub("R version ", 
  [13:35:00.020]                         "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [13:35:00.020]                         R.version$platform, 8 * .Machine$sizeof.pointer), 
  [13:35:00.020]                         os = paste(Sys.info()[c("sysname", "release", 
  [13:35:00.020]                           "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [13:35:00.020]                       info <- sprintf("%s: %s", names(info), 
  [13:35:00.020]                         info)
  [13:35:00.020]                       info <- paste(info, collapse = "; ")
  [13:35:00.020]                       if (!has_future) {
  [13:35:00.020]                         msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [13:35:00.020]                           info)
  [13:35:00.020]                       }
  [13:35:00.020]                       else {
  [13:35:00.020]                         msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [13:35:00.020]                           info, version)
  [13:35:00.020]                       }
  [13:35:00.020]                       stop(msg)
  [13:35:00.020]                     }
  [13:35:00.020]                   }
  [13:35:00.020]                   ...future.mc.cores.old <- getOption("mc.cores")
  [13:35:00.020]                   options(mc.cores = 1L)
  [13:35:00.020]                 }
  [13:35:00.020]                 local({
  [13:35:00.020]                   for (pkg in c("doFuture", "future")) {
  [13:35:00.020]                     loadNamespace(pkg)
  [13:35:00.020]                     library(pkg, character.only = TRUE)
  [13:35:00.020]                   }
  [13:35:00.020]                 })
  [13:35:00.020]             }
  [13:35:00.020]             future::plan(list(b = function (expr, envir = parent.frame(), 
  [13:35:00.020]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:35:00.020]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [13:35:00.020]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [13:35:00.020]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:35:00.020]                 ...) 
  [13:35:00.020]             {
  [13:35:00.020]                 if (substitute) 
  [13:35:00.020]                   expr <- substitute(expr)
  [13:35:00.020]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:35:00.020]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:35:00.020]                   globals = globals, persistent = persistent, 
  [13:35:00.020]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:35:00.020]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:35:00.020]                   label = label, ...)
  [13:35:00.020]                 if (!future$lazy) 
  [13:35:00.020]                   future <- run(future)
  [13:35:00.020]                 invisible(future)
  [13:35:00.020]             }), .cleanup = FALSE, .init = FALSE)
  [13:35:00.020]         }
  [13:35:00.020]     }
  [13:35:00.020]     if (is.na(TRUE)) {
  [13:35:00.020]     }
  [13:35:00.020]     else {
  [13:35:00.020]         if (TRUE) {
  [13:35:00.020]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [13:35:00.020]         }
  [13:35:00.020]         else {
  [13:35:00.020]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [13:35:00.020]                 windows = "NUL", "/dev/null"), open = "w")
  [13:35:00.020]         }
  [13:35:00.020]         sink(...future.stdout, type = "output", split = FALSE)
  [13:35:00.020]         on.exit(if (!is.null(...future.stdout)) {
  [13:35:00.020]             sink(type = "output", split = FALSE)
  [13:35:00.020]             close(...future.stdout)
  [13:35:00.020]         }, add = TRUE)
  [13:35:00.020]     }
  [13:35:00.020]     ...future.frame <- sys.nframe()
  [13:35:00.020]     ...future.conditions <- list()
  [13:35:00.020]     ...future.result <- tryCatch({
  [13:35:00.020]         withCallingHandlers({
  [13:35:00.020]             ...future.value <- withVisible(local({
  [13:35:00.020]                 doFuture::registerDoFuture()
  [13:35:00.020]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [13:35:00.020]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [13:35:00.020]                   {
  [13:35:00.020]                     a <- NULL
  [13:35:00.020]                     b <- NULL
  [13:35:00.020]                   }
  [13:35:00.020]                   ...future.env <- environment()
  [13:35:00.020]                   local({
  [13:35:00.020]                     for (name in names(...future.x_jj)) {
  [13:35:00.020]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [13:35:00.020]                         inherits = FALSE)
  [13:35:00.020]                     }
  [13:35:00.020]                   })
  [13:35:00.020]                   tryCatch({
  [13:35:00.020]                     list(a = a, b = b, plan_b = future::plan("list"), 
  [13:35:00.020]                       plan = future::plan())
  [13:35:00.020]                   }, error = identity)
  [13:35:00.020]                 })
  [13:35:00.020]             }))
  [13:35:00.020]             future::FutureResult(value = ...future.value$value, 
  [13:35:00.020]                 visible = ...future.value$visible, started = ...future.startTime, 
  [13:35:00.020]                 version = "1.8")
  [13:35:00.020]         }, condition = local({
  [13:35:00.020]             inherits <- base::inherits
  [13:35:00.020]             invokeRestart <- base::invokeRestart
  [13:35:00.020]             length <- base::length
  [13:35:00.020]             seq.int <- base::seq.int
  [13:35:00.020]             sys.calls <- base::sys.calls
  [13:35:00.020]             `[[` <- base::`[[`
  [13:35:00.020]             `+` <- base::`+`
  [13:35:00.020]             `<<-` <- base::`<<-`
  [13:35:00.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [13:35:00.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [13:35:00.020]                   3L)]
  [13:35:00.020]             }
  [13:35:00.020]             function(cond) {
  [13:35:00.020]                 if (inherits(cond, "error")) {
  [13:35:00.020]                   ...future.conditions[[length(...future.conditions) + 
  [13:35:00.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [13:35:00.020]                     cond$call), timestamp = base::Sys.time(), 
  [13:35:00.020]                     signaled = 0L)
  [13:35:00.020]                   signalCondition(cond)
  [13:35:00.020]                 }
  [13:35:00.020]                 else if (inherits(cond, "condition")) {
  [13:35:00.020]                   signal <- FALSE && inherits(cond, character(0))
  [13:35:00.020]                   ...future.conditions[[length(...future.conditions) + 
  [13:35:00.020]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [13:35:00.020]                   if (!signal) {
  [13:35:00.020]                     muffleCondition <- function (cond) 
  [13:35:00.020]                     {
  [13:35:00.020]                       inherits <- base::inherits
  [13:35:00.020]                       invokeRestart <- base::invokeRestart
  [13:35:00.020]                       muffled <- FALSE
  [13:35:00.020]                       if (inherits(cond, "message")) {
  [13:35:00.020]                         invokeRestart("muffleMessage")
  [13:35:00.020]                         muffled <- TRUE
  [13:35:00.020]                       }
  [13:35:00.020]                       else if (inherits(cond, "warning")) {
  [13:35:00.020]                         invokeRestart("muffleWarning")
  [13:35:00.020]                         muffled <- TRUE
  [13:35:00.020]                       }
  [13:35:00.020]                       else if (inherits(cond, "condition")) {
  [13:35:00.020]                         computeRestarts <- base::computeRestarts
  [13:35:00.020]                         grepl <- base::grepl
  [13:35:00.020]                         is.null <- base::is.null
  [13:35:00.020]                         restarts <- computeRestarts(cond)
  [13:35:00.020]                         for (restart in restarts) {
  [13:35:00.020]                           name <- restart$name
  [13:35:00.020]                           if (is.null(name)) 
  [13:35:00.020]                             next
  [13:35:00.020]                           if (!grepl("^muffle", name)) 
  [13:35:00.020]                             next
  [13:35:00.020]                           invokeRestart(restart)
  [13:35:00.020]                           muffled <- TRUE
  [13:35:00.020]                           break
  [13:35:00.020]                         }
  [13:35:00.020]                       }
  [13:35:00.020]                       invisible(muffled)
  [13:35:00.020]                     }
  [13:35:00.020]                     muffleCondition(cond)
  [13:35:00.020]                   }
  [13:35:00.020]                 }
  [13:35:00.020]             }
  [13:35:00.020]         }))
  [13:35:00.020]     }, error = function(ex) {
  [13:35:00.020]         structure(list(value = NULL, visible = NULL, conditions = ...future.conditions, 
  [13:35:00.020]             version = "1.8"), class = "FutureResult")
  [13:35:00.020]     }, finally = {
  [13:35:00.020]         {
  [13:35:00.020]             {
  [13:35:00.020]                 options(mc.cores = ...future.mc.cores.old)
  [13:35:00.020]             }
  [13:35:00.020]             future::plan(list(a = function (expr, envir = parent.frame(), 
  [13:35:00.020]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [13:35:00.020]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [13:35:00.020]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [13:35:00.020]                 ...) 
  [13:35:00.020]             {
  [13:35:00.020]                 if (substitute) 
  [13:35:00.020]                   expr <- substitute(expr)
  [13:35:00.020]                 if (is.function(workers)) 
  [13:35:00.020]                   workers <- workers()
  [13:35:00.020]                 workers <- as.integer(workers)
  [13:35:00.020]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [13:35:00.020]                   workers >= 1)
  [13:35:00.020]                 if (workers == 1L) {
  [13:35:00.020]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [13:35:00.020]                     lazy = TRUE, seed = seed, globals = globals, 
  [13:35:00.020]                     local = TRUE, label = label, ...))
  [13:35:00.020]                 }
  [13:35:00.020]                 workers <- ClusterRegistry("start", workers = workers)
  [13:35:00.020]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [13:35:00.020]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:35:00.020]                   globals = globals, persistent = persistent, 
  [13:35:00.020]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [13:35:00.020]                   label = label, ...)
  [13:35:00.020]                 if (!future$lazy) 
  [13:35:00.020]                   future <- run(future)
  [13:35:00.020]                 invisible(future)
  [13:35:00.020]             }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
  [13:35:00.020]                 lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
  [13:35:00.020]                 workers = availableWorkers(), user = NULL, revtunnel = TRUE, 
  [13:35:00.020]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [13:35:00.020]                 label = NULL, ...) 
  [13:35:00.020]             {
  [13:35:00.020]                 if (substitute) 
  [13:35:00.020]                   expr <- substitute(expr)
  [13:35:00.020]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [13:35:00.020]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [13:35:00.020]                   globals = globals, persistent = persistent, 
  [13:35:00.020]                   workers = workers, user = user, revtunnel = revtunnel, 
  [13:35:00.020]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [13:35:00.020]                   label = label, ...)
  [13:35:00.020]                 if (!future$lazy) 
  [13:35:00.020]                   future <- run(future)
  [13:35:00.020]                 invisible(future)
  [13:35:00.020]             }), .cleanup = FALSE, .init = FALSE)
  [13:35:00.020]         }
  [13:35:00.020]         options(...future.oldOptions)
  [13:35:00.020]     })
  [13:35:00.020]     if (is.na(TRUE)) {
  [13:35:00.020]     }
  [13:35:00.020]     else {
  [13:35:00.020]         sink(type = "output", split = FALSE)
  [13:35:00.020]         if (TRUE) {
  [13:35:00.020]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [13:35:00.020]         }
  [13:35:00.020]         else {
  [13:35:00.020]             ...future.result["stdout"] <- list(NULL)
  [13:35:00.020]         }
  [13:35:00.020]         close(...future.stdout)
  [13:35:00.020]         ...future.stdout <- NULL
  [13:35:00.020]     }
  [13:35:00.020]     ...future.result$conditions <- ...future.conditions
  [13:35:00.020]     ...future.result
  [13:35:00.020] }
  [13:35:00.026] Exporting 1 global objects (336 bytes) to cluster node #2 ...
  [13:35:00.026] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ...
  [13:35:00.055] Exporting '...future.x_ii' (336 bytes) to cluster node #2 ... DONE
  [13:35:00.055] Exporting 1 global objects (336 bytes) to cluster node #2 ... DONE
  [13:35:00.057] MultisessionFuture started
  [13:35:00.057] Chunk #2 of 2 ... DONE
  [13:35:00.057] Launching 2 futures (chunks) ... DONE
  [13:35:00.058] - resolving futures
  [13:35:00.058]   - gathering results & relaying conditions (except errors)
  [13:35:00.058] resolve() on list ...
  [13:35:00.059]  recursive: 0
  [13:35:00.059]  length: 2
  [13:35:00.059] 
  [13:35:00.458] Future #2
  [13:35:00.458] result() for ClusterFuture ...
  [13:35:00.459] - Validating connection of MultisessionFuture
  [13:35:00.499] - class(result): FutureResult
  [13:35:00.500] result() for ClusterFuture ...
  [13:35:00.500] - result already collected: FutureResult
  [13:35:00.500] result() for ClusterFuture ... done
  [13:35:00.501] result() for ClusterFuture ... done
  [13:35:00.501] result() for ClusterFuture ...
  [13:35:00.502] - result already collected: FutureResult
  [13:35:00.502] result() for ClusterFuture ... done
  [13:35:00.502] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [13:35:00.503] - nx: 2
  [13:35:00.503] - relay: TRUE
  [13:35:00.503] - stdout: TRUE
  [13:35:00.503] - signal: TRUE
  [13:35:00.504] - resignal: FALSE
  [13:35:00.504] - force: FALSE
  [13:35:00.504] - relayed: [n=2] FALSE, FALSE
  [13:35:00.505] - queued futures: [n=2] FALSE, FALSE
  [13:35:00.505]  - until=1
  [13:35:00.505]  - relaying element #1
  [13:35:00.506] - relayed: [n=2] FALSE, FALSE
  [13:35:00.506] - queued futures: [n=2] FALSE, TRUE
  [13:35:00.506] signalConditionsASAP(NULL, pos=2) ... done
  [13:35:00.507]  length: 1 (resolved future 2)
  [13:35:00.609] Future #1
  [13:35:00.609] result() for ClusterFuture ...
  [13:35:00.609] - Validating connection of MultisessionFuture
  [13:35:00.611] - class(result): FutureResult
  [13:35:00.611] result() for ClusterFuture ...
  [13:35:00.611] - result already collected: FutureResult
  [13:35:00.612] result() for ClusterFuture ... done
  [13:35:00.612] result() for ClusterFuture ... done
  [13:35:00.612] result() for ClusterFuture ...
  [13:35:00.613] - result already collected: FutureResult
  [13:35:00.613] result() for ClusterFuture ... done
  [13:35:00.613] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [13:35:00.614] - nx: 2
  [13:35:00.614] - relay: TRUE
  [13:35:00.614] - stdout: TRUE
  [13:35:00.615] - signal: TRUE
  [13:35:00.615] - resignal: FALSE
  [13:35:00.615] - force: FALSE
  [13:35:00.615] - relayed: [n=2] FALSE, FALSE
  [13:35:00.616] - queued futures: [n=2] FALSE, TRUE
  [13:35:00.616]  - until=1
  [13:35:00.616]  - relaying element #1
  [13:35:00.617] result() for ClusterFuture ...
  [13:35:00.617] - result already collected: FutureResult
  [13:35:00.617] result() for ClusterFuture ... done
  [13:35:00.618] result() for ClusterFuture ...
  [13:35:00.618] - result already collected: FutureResult
  [13:35:00.619] result() for ClusterFuture ... done
  [13:35:00.619] result() for ClusterFuture ...
  [13:35:00.619] - result already collected: FutureResult
  [13:35:00.620] result() for ClusterFuture ... done
  [13:35:00.620] result() for ClusterFuture ...
  [13:35:00.620] - result already collected: FutureResult
  [13:35:00.621] result() for ClusterFuture ... done
  [13:35:00.621] - relayed: [n=2] TRUE, FALSE
  [13:35:00.621] - queued futures: [n=2] TRUE, TRUE
  [13:35:00.621] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [13:35:00.622]  length: 0 (resolved future 1)
  [13:35:00.622] Relaying remaining futures
  [13:35:00.639] signalConditionsASAP(NULL, pos=0) ...
  [13:35:00.639] - nx: 2
  [13:35:00.639] - relay: TRUE
  [13:35:00.640] - stdout: TRUE
  [13:35:00.640] - signal: TRUE
  [13:35:00.640] - resignal: FALSE
  [13:35:00.640] - force: FALSE
  [13:35:00.641] - relayed: [n=2] TRUE, FALSE
  [13:35:00.641] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [13:35:00.642]  - relaying element #2
  [13:35:00.642] result() for ClusterFuture ...
  [13:35:00.642] - result already collected: FutureResult
  [13:35:00.643] result() for ClusterFuture ... done
  [13:35:00.643] result() for ClusterFuture ...
  [13:35:00.643] - result already collected: FutureResult
  [13:35:00.644] result() for ClusterFuture ... done
  [13:35:00.644] result() for ClusterFuture ...
  [13:35:00.644] - result already collected: FutureResult
  [13:35:00.645] result() for ClusterFuture ... done
  [13:35:00.645] result() for ClusterFuture ...
  [13:35:00.645] - result already collected: FutureResult
  [13:35:00.646] result() for ClusterFuture ... done
  [13:35:00.646] - relayed: [n=2] TRUE, TRUE
  [13:35:00.646] - queued futures: [n=2] TRUE, TRUE
  [13:35:00.647] signalConditionsASAP(MultisessionFuture, pos=0) ... done
  [13:35:00.647] resolve() on list ... DONE
  [13:35:00.647] - collecting values of futures
  [13:35:00.648] result() for ClusterFuture ...
  [13:35:00.648] - result already collected: FutureResult
  [13:35:00.648] result() for ClusterFuture ... done
  [13:35:00.649] result() for ClusterFuture ...
  [13:35:00.649] - result already collected: FutureResult
  [13:35:00.649] result() for ClusterFuture ... done
  [13:35:00.650] result() for ClusterFuture ...
  [13:35:00.650] - result already collected: FutureResult
  [13:35:00.650] result() for ClusterFuture ... done
  [13:35:00.650] result() for ClusterFuture ...
  [13:35:00.651] - result already collected: FutureResult
  [13:35:00.651] result() for ClusterFuture ... done
  [13:35:00.652] - accumulating results
  [13:35:00.654] - processing errors (handler = 'stop')
  [13:35:00.655] - extracting results
  [13:35:00.655] doFuture() ... DONE
  - plan(list('multisession', 'cluster')) ... DONE
  - plan(list('cluster', 'sequential')) ...
  [13:35:00.656] plan(): Setting new future strategy stack:
  [13:35:00.657] List of future strategies:
  [13:35:00.657] 1. cluster:
  [13:35:00.657]    - 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, ...)
  [13:35:00.657]    - tweaked: FALSE
  [13:35:00.657]    - call: plan(list(a = strategy1, b = strategy2))
  [13:35:00.657] 2. sequential:
  [13:35:00.657]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [13:35:00.657]    - tweaked: FALSE
  [13:35:00.657]    - call: plan(list(a = strategy1, b = strategy2))
  [13:35:00.659] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [13:35:00.660] cluster:
  [13:35:00.660] - 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, ...)
  [13:35:00.660] - tweaked: FALSE
  [13:35:00.660] - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 35156
  [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-patched-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d5c8d9592.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpHaTPbq/future.parent=17965.462d5c8d9592.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d5c8d9592.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35156 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 35156 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 35156 cannot be opened
  Killing worker process (PID 11139) if still alive
  [13:35:02.632] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(17965, signal = 0L)
  [1] TRUE
  Call: tools::pskill(17965, signal = 0L)
  [1] TRUE
  [13:35:02.633] - success
  [13:35:02.634] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 11139) 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 'gimli'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 35156 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 35156 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:17965:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpHaTPbq/future.parent=17965.462d5c8d9592.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35156 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 11139) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted