Running 'DEPRECATED.R' [1s/1s]
  Running 'cluster-missing-doFuture-pkg.R' [1s/3s]
  Running 'doRNG,dopar.R' [3s/33s]
  Running 'doRNG,dorng.R' [6s/37s]
  Running 'foreach,errors.R' [7s/100s]
  Running 'foreach,globals.R' [8s/100s]
  Running 'foreach,nested.R' [2s/11s]
  Running 'foreach,nested_dopar.R' [14s/216s]
  Running 'foreach.R' [10s/48s]
  Running 'future.BatchJobs.R' [28s/36s]
  Running 'future.batchtools.R' [46s/36s]
  Running 'options.R' [3s/20s]
  Running 'registerDoFuture.R' [2s/32s]
  Running 'times.R' [3s/33s]
  Running 'zzz_opt-in,NMF.R' [0s/1s]
  Running 'zzz_opt-in,TSP.R' [0s/0s]
  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
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: future::plan(future::sequential)
  
  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')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  [21:05:54.955] doFuture() ...
  [21:05:54.962] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:54.967] - R expression:
  [21:05:54.967] {
  [21:05:54.967]     doFuture::registerDoFuture()
  [21:05:54.967]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:54.967]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:54.967]         {
  [21:05:54.967]             a <- NULL
  [21:05:54.967]             b <- NULL
  [21:05:54.967]         }
  [21:05:54.967]         ...future.env <- environment()
  [21:05:54.967]         local({
  [21:05:54.967]             for (name in names(...future.x_jj)) {
  [21:05:54.967]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:54.967]                   inherits = FALSE)
  [21:05:54.967]             }
  [21:05:54.967]         })
  [21:05:54.967]         tryCatch({
  [21:05:54.967]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:54.967]                 plan = future::plan())
  [21:05:54.967]         }, error = identity)
  [21:05:54.967]     })
  [21:05:54.967] }
  [21:05:54.968] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.002] List of 1
  [21:05:55.002]  $ ...future.x_ii: NULL
  [21:05:55.002]  - attr(*, "where")=List of 1
  [21:05:55.002]   ..$ ...future.x_ii:<environment: 0x1cef458> 
  [21:05:55.002]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.002]  - attr(*, "resolved")= logi FALSE
  [21:05:55.002]  - attr(*, "total_size")= num 0
  [21:05:55.013]   - R expression:
  [21:05:55.013] {
  [21:05:55.013]     doFuture::registerDoFuture()
  [21:05:55.013]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.013]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.013]         {
  [21:05:55.013]             a <- NULL
  [21:05:55.013]             b <- NULL
  [21:05:55.013]         }
  [21:05:55.013]         ...future.env <- environment()
  [21:05:55.013]         local({
  [21:05:55.013]             for (name in names(...future.x_jj)) {
  [21:05:55.013]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.013]                   inherits = FALSE)
  [21:05:55.013]             }
  [21:05:55.013]         })
  [21:05:55.013]         tryCatch({
  [21:05:55.013]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.013]                 plan = future::plan())
  [21:05:55.013]         }, error = identity)
  [21:05:55.013]     })
  [21:05:55.013] }
  [21:05:55.014]   - globals: [1] '...future.x_ii'
  [21:05:55.014] List of 1
  [21:05:55.014]  $ ...future.x_ii: NULL
  [21:05:55.014]  - attr(*, "where")=List of 1
  [21:05:55.014]   ..$ ...future.x_ii:<environment: 0x1cef458> 
  [21:05:55.014]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.014]  - attr(*, "resolved")= logi FALSE
  [21:05:55.014]  - attr(*, "total_size")= num 0
  [21:05:55.019]   - packages: [1] 'doFuture'
  [21:05:55.020] - identifying globals and packages ... DONE
  [21:05:55.020] Number of chunks: 1
  [21:05:55.021] Number of futures (= number of chunks): 1
  [21:05:55.021] Launching 1 futures (chunks) ...
  [21:05:55.022] Chunk #1 of 1 ...
  [21:05:55.022]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.024] 
  [21:05:55.025] 
  [21:05:55.025]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 672 bytes (672 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = NULL, 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  [21:05:55.072] Chunk #1 of 1 ... DONE
  [21:05:55.073] Launching 1 futures (chunks) ... DONE
  [21:05:55.073] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  [21:05:55.076] - relaying conditions of futures
  [21:05:55.077] - collecting values of futures
  [21:05:55.077] - accumulating results
  [21:05:55.082] - processing errors (handler = 'stop')
  [21:05:55.082] - extracting results
  [21:05:55.082] doFuture() ... DONE
  - plan(list('sequential', 'sequential')) ... DONE
  - plan(list('sequential', 'multicore')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  [21:05:55.086] doFuture() ...
  [21:05:55.090] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.091] - R expression:
  [21:05:55.091] {
  [21:05:55.091]     doFuture::registerDoFuture()
  [21:05:55.091]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.091]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.091]         {
  [21:05:55.091]             a <- NULL
  [21:05:55.091]             b <- NULL
  [21:05:55.091]         }
  [21:05:55.091]         ...future.env <- environment()
  [21:05:55.091]         local({
  [21:05:55.091]             for (name in names(...future.x_jj)) {
  [21:05:55.091]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.091]                   inherits = FALSE)
  [21:05:55.091]             }
  [21:05:55.091]         })
  [21:05:55.091]         tryCatch({
  [21:05:55.091]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.091]                 plan = future::plan())
  [21:05:55.091]         }, error = identity)
  [21:05:55.091]     })
  [21:05:55.091] }
  [21:05:55.092] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.110] List of 1
  [21:05:55.110]  $ ...future.x_ii: NULL
  [21:05:55.110]  - attr(*, "where")=List of 1
  [21:05:55.110]   ..$ ...future.x_ii:<environment: 0x2c61f00> 
  [21:05:55.110]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.110]  - attr(*, "resolved")= logi FALSE
  [21:05:55.110]  - attr(*, "total_size")= num 0
  [21:05:55.116]   - R expression:
  [21:05:55.116] {
  [21:05:55.116]     doFuture::registerDoFuture()
  [21:05:55.116]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.116]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.116]         {
  [21:05:55.116]             a <- NULL
  [21:05:55.116]             b <- NULL
  [21:05:55.116]         }
  [21:05:55.116]         ...future.env <- environment()
  [21:05:55.116]         local({
  [21:05:55.116]             for (name in names(...future.x_jj)) {
  [21:05:55.116]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.116]                   inherits = FALSE)
  [21:05:55.116]             }
  [21:05:55.116]         })
  [21:05:55.116]         tryCatch({
  [21:05:55.116]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.116]                 plan = future::plan())
  [21:05:55.116]         }, error = identity)
  [21:05:55.116]     })
  [21:05:55.116] }
  [21:05:55.117]   - globals: [1] '...future.x_ii'
  [21:05:55.117] List of 1
  [21:05:55.117]  $ ...future.x_ii: NULL
  [21:05:55.117]  - attr(*, "where")=List of 1
  [21:05:55.117]   ..$ ...future.x_ii:<environment: 0x2c61f00> 
  [21:05:55.117]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.117]  - attr(*, "resolved")= logi FALSE
  [21:05:55.117]  - attr(*, "total_size")= num 0
  [21:05:55.127]   - packages: [1] 'doFuture'
  [21:05:55.127] - identifying globals and packages ... DONE
  [21:05:55.128] Number of chunks: 1
  [21:05:55.128] Number of futures (= number of chunks): 1
  [21:05:55.128] Launching 1 futures (chunks) ...
  [21:05:55.128] Chunk #1 of 1 ...
  [21:05:55.129]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.131] 
  [21:05:55.132] 
  [21:05:55.132]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 672 bytes (672 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  [21:05:55.180] Chunk #1 of 1 ... DONE
  [21:05:55.180] Launching 1 futures (chunks) ... DONE
  [21:05:55.180] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  [21:05:55.182] - relaying conditions of futures
  [21:05:55.183] - collecting values of futures
  [21:05:55.183] - accumulating results
  [21:05:55.186] - processing errors (handler = 'stop')
  [21:05:55.202] - extracting results
  [21:05:55.203] doFuture() ... DONE
  - plan(list('sequential', 'multicore')) ... DONE
  - plan(list('sequential', 'multisession')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  [21:05:55.207] doFuture() ...
  [21:05:55.212] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.213] - R expression:
  [21:05:55.213] {
  [21:05:55.213]     doFuture::registerDoFuture()
  [21:05:55.213]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.213]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.213]         {
  [21:05:55.213]             a <- NULL
  [21:05:55.213]             b <- NULL
  [21:05:55.213]         }
  [21:05:55.213]         ...future.env <- environment()
  [21:05:55.213]         local({
  [21:05:55.213]             for (name in names(...future.x_jj)) {
  [21:05:55.213]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.213]                   inherits = FALSE)
  [21:05:55.213]             }
  [21:05:55.213]         })
  [21:05:55.213]         tryCatch({
  [21:05:55.213]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.213]                 plan = future::plan())
  [21:05:55.213]         }, error = identity)
  [21:05:55.213]     })
  [21:05:55.213] }
  [21:05:55.214] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.261] List of 1
  [21:05:55.261]  $ ...future.x_ii: NULL
  [21:05:55.261]  - attr(*, "where")=List of 1
  [21:05:55.261]   ..$ ...future.x_ii:<environment: 0x2dc74a0> 
  [21:05:55.261]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.261]  - attr(*, "resolved")= logi FALSE
  [21:05:55.261]  - attr(*, "total_size")= num 0
  [21:05:55.288]   - R expression:
  [21:05:55.288] {
  [21:05:55.288]     doFuture::registerDoFuture()
  [21:05:55.288]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.288]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.288]         {
  [21:05:55.288]             a <- NULL
  [21:05:55.288]             b <- NULL
  [21:05:55.288]         }
  [21:05:55.288]         ...future.env <- environment()
  [21:05:55.288]         local({
  [21:05:55.288]             for (name in names(...future.x_jj)) {
  [21:05:55.288]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.288]                   inherits = FALSE)
  [21:05:55.288]             }
  [21:05:55.288]         })
  [21:05:55.288]         tryCatch({
  [21:05:55.288]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.288]                 plan = future::plan())
  [21:05:55.288]         }, error = identity)
  [21:05:55.288]     })
  [21:05:55.288] }
  [21:05:55.289]   - globals: [1] '...future.x_ii'
  [21:05:55.290] List of 1
  [21:05:55.290]  $ ...future.x_ii: NULL
  [21:05:55.290]  - attr(*, "where")=List of 1
  [21:05:55.290]   ..$ ...future.x_ii:<environment: 0x2dc74a0> 
  [21:05:55.290]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.290]  - attr(*, "resolved")= logi FALSE
  [21:05:55.290]  - attr(*, "total_size")= num 0
  [21:05:55.296]   - packages: [1] 'doFuture'
  [21:05:55.296] - identifying globals and packages ... DONE
  [21:05:55.297] Number of chunks: 1
  [21:05:55.297] Number of futures (= number of chunks): 1
  [21:05:55.297] Launching 1 futures (chunks) ...
  [21:05:55.298] Chunk #1 of 1 ...
  [21:05:55.298]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.301] 
  [21:05:55.301] 
  [21:05:55.302]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 672 bytes (672 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
                  workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  [21:05:55.321] Chunk #1 of 1 ... DONE
  [21:05:55.321] Launching 1 futures (chunks) ... DONE
  [21:05:55.321] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  [21:05:55.323] - relaying conditions of futures
  [21:05:55.323] - collecting values of futures
  [21:05:55.324] - accumulating results
  [21:05:55.327] - processing errors (handler = 'stop')
  [21:05:55.327] - extracting results
  [21:05:55.327] doFuture() ... DONE
  - plan(list('sequential', 'multisession')) ... DONE
  - plan(list('sequential', 'cluster')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  [21:05:55.331] doFuture() ...
  [21:05:55.335] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.336] - R expression:
  [21:05:55.336] {
  [21:05:55.336]     doFuture::registerDoFuture()
  [21:05:55.336]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.336]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.336]         {
  [21:05:55.336]             a <- NULL
  [21:05:55.336]             b <- NULL
  [21:05:55.336]         }
  [21:05:55.336]         ...future.env <- environment()
  [21:05:55.336]         local({
  [21:05:55.336]             for (name in names(...future.x_jj)) {
  [21:05:55.336]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.336]                   inherits = FALSE)
  [21:05:55.336]             }
  [21:05:55.336]         })
  [21:05:55.336]         tryCatch({
  [21:05:55.336]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.336]                 plan = future::plan())
  [21:05:55.336]         }, error = identity)
  [21:05:55.336]     })
  [21:05:55.336] }
  [21:05:55.337] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.360] List of 1
  [21:05:55.360]  $ ...future.x_ii: NULL
  [21:05:55.360]  - attr(*, "where")=List of 1
  [21:05:55.360]   ..$ ...future.x_ii:<environment: 0x2f0a100> 
  [21:05:55.360]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.360]  - attr(*, "resolved")= logi FALSE
  [21:05:55.360]  - attr(*, "total_size")= num 0
  [21:05:55.367]   - R expression:
  [21:05:55.367] {
  [21:05:55.367]     doFuture::registerDoFuture()
  [21:05:55.367]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.367]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.367]         {
  [21:05:55.367]             a <- NULL
  [21:05:55.367]             b <- NULL
  [21:05:55.367]         }
  [21:05:55.367]         ...future.env <- environment()
  [21:05:55.367]         local({
  [21:05:55.367]             for (name in names(...future.x_jj)) {
  [21:05:55.367]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.367]                   inherits = FALSE)
  [21:05:55.367]             }
  [21:05:55.367]         })
  [21:05:55.367]         tryCatch({
  [21:05:55.367]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.367]                 plan = future::plan())
  [21:05:55.367]         }, error = identity)
  [21:05:55.367]     })
  [21:05:55.367] }
  [21:05:55.368]   - globals: [1] '...future.x_ii'
  [21:05:55.368] List of 1
  [21:05:55.368]  $ ...future.x_ii: NULL
  [21:05:55.368]  - attr(*, "where")=List of 1
  [21:05:55.368]   ..$ ...future.x_ii:<environment: 0x2f0a100> 
  [21:05:55.368]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.368]  - attr(*, "resolved")= logi FALSE
  [21:05:55.368]  - attr(*, "total_size")= num 0
  [21:05:55.374]   - packages: [1] 'doFuture'
  [21:05:55.374] - identifying globals and packages ... DONE
  [21:05:55.375] Number of chunks: 1
  [21:05:55.375] Number of futures (= number of chunks): 1
  [21:05:55.375] Launching 1 futures (chunks) ...
  [21:05:55.376] Chunk #1 of 1 ...
  [21:05:55.376]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.379] 
  [21:05:55.379] 
  [21:05:55.379]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 672 bytes (672 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = 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, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = 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, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  [21:05:55.399] Chunk #1 of 1 ... DONE
  [21:05:55.400] Launching 1 futures (chunks) ... DONE
  [21:05:55.400] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 1
  
   length: 0 (resolved future 1)
  resolve() on list ... DONE
  [21:05:55.402] - relaying conditions of futures
  [21:05:55.402] - collecting values of futures
  [21:05:55.403] - accumulating results
  [21:05:55.405] - processing errors (handler = 'stop')
  [21:05:55.406] - extracting results
  [21:05:55.406] doFuture() ... DONE
  - plan(list('sequential', 'cluster')) ... DONE
  - plan(list('multicore', 'sequential')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  [21:05:55.410] doFuture() ...
  [21:05:55.414] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.415] - R expression:
  [21:05:55.415] {
  [21:05:55.415]     doFuture::registerDoFuture()
  [21:05:55.415]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.415]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.415]         {
  [21:05:55.415]             a <- NULL
  [21:05:55.415]             b <- NULL
  [21:05:55.415]         }
  [21:05:55.415]         ...future.env <- environment()
  [21:05:55.415]         local({
  [21:05:55.415]             for (name in names(...future.x_jj)) {
  [21:05:55.415]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.415]                   inherits = FALSE)
  [21:05:55.415]             }
  [21:05:55.415]         })
  [21:05:55.415]         tryCatch({
  [21:05:55.415]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.415]                 plan = future::plan())
  [21:05:55.415]         }, error = identity)
  [21:05:55.415]     })
  [21:05:55.415] }
  [21:05:55.416] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.437] List of 1
  [21:05:55.437]  $ ...future.x_ii: NULL
  [21:05:55.437]  - attr(*, "where")=List of 1
  [21:05:55.437]   ..$ ...future.x_ii:<environment: 0x30b5d50> 
  [21:05:55.437]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.437]  - attr(*, "resolved")= logi FALSE
  [21:05:55.437]  - attr(*, "total_size")= num 0
  [21:05:55.443]   - R expression:
  [21:05:55.443] {
  [21:05:55.443]     doFuture::registerDoFuture()
  [21:05:55.443]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.443]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.443]         {
  [21:05:55.443]             a <- NULL
  [21:05:55.443]             b <- NULL
  [21:05:55.443]         }
  [21:05:55.443]         ...future.env <- environment()
  [21:05:55.443]         local({
  [21:05:55.443]             for (name in names(...future.x_jj)) {
  [21:05:55.443]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.443]                   inherits = FALSE)
  [21:05:55.443]             }
  [21:05:55.443]         })
  [21:05:55.443]         tryCatch({
  [21:05:55.443]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.443]                 plan = future::plan())
  [21:05:55.443]         }, error = identity)
  [21:05:55.443]     })
  [21:05:55.443] }
  [21:05:55.444]   - globals: [1] '...future.x_ii'
  [21:05:55.444] List of 1
  [21:05:55.444]  $ ...future.x_ii: NULL
  [21:05:55.444]  - attr(*, "where")=List of 1
  [21:05:55.444]   ..$ ...future.x_ii:<environment: 0x30b5d50> 
  [21:05:55.444]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.444]  - attr(*, "resolved")= logi FALSE
  [21:05:55.444]  - attr(*, "total_size")= num 0
  [21:05:55.450]   - packages: [1] 'doFuture'
  [21:05:55.450] - identifying globals and packages ... DONE
  [21:05:55.454] Number of chunks: 2
  [21:05:55.454] Number of futures (= number of chunks): 2
  [21:05:55.454] Launching 2 futures (chunks) ...
  [21:05:55.454] Chunk #1 of 2 ...
  [21:05:55.455]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.457] 
  [21:05:55.457] 
  [21:05:55.458]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.475] Chunk #1 of 2 ... DONE
  [21:05:55.476] Chunk #2 of 2 ...
  [21:05:55.476]  - Finding globals in 'args_list' chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.479] 
  [21:05:55.480] 
  [21:05:55.480]  - Finding globals in 'args_list' for chunk #2 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  plan(): nbrOfWorkers() = 2
  MulticoreFuture started
  [21:05:55.508] Chunk #2 of 2 ... DONE
  [21:05:55.509] Launching 2 futures (chunks) ... DONE
  [21:05:55.509] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  [21:05:55.541] - relaying conditions of futures
  [21:05:55.549] - collecting values of futures
  [21:05:55.550] - accumulating results
  [21:05:55.554] - processing errors (handler = 'stop')
  [21:05:55.561] - extracting results
  [21:05:55.562] doFuture() ... DONE
  - plan(list('multicore', 'sequential')) ... DONE
  - plan(list('multicore', 'multicore')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  [21:05:55.581] doFuture() ...
  [21:05:55.585] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.587] - R expression:
  [21:05:55.587] {
  [21:05:55.587]     doFuture::registerDoFuture()
  [21:05:55.587]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.587]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.587]         {
  [21:05:55.587]             a <- NULL
  [21:05:55.587]             b <- NULL
  [21:05:55.587]         }
  [21:05:55.587]         ...future.env <- environment()
  [21:05:55.587]         local({
  [21:05:55.587]             for (name in names(...future.x_jj)) {
  [21:05:55.587]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.587]                   inherits = FALSE)
  [21:05:55.587]             }
  [21:05:55.587]         })
  [21:05:55.587]         tryCatch({
  [21:05:55.587]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.587]                 plan = future::plan())
  [21:05:55.587]         }, error = identity)
  [21:05:55.587]     })
  [21:05:55.587] }
  [21:05:55.588] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.621] List of 1
  [21:05:55.621]  $ ...future.x_ii: NULL
  [21:05:55.621]  - attr(*, "where")=List of 1
  [21:05:55.621]   ..$ ...future.x_ii:<environment: 0x1237a90> 
  [21:05:55.621]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.621]  - attr(*, "resolved")= logi FALSE
  [21:05:55.621]  - attr(*, "total_size")= num 0
  [21:05:55.628]   - R expression:
  [21:05:55.628] {
  [21:05:55.628]     doFuture::registerDoFuture()
  [21:05:55.628]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.628]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.628]         {
  [21:05:55.628]             a <- NULL
  [21:05:55.628]             b <- NULL
  [21:05:55.628]         }
  [21:05:55.628]         ...future.env <- environment()
  [21:05:55.628]         local({
  [21:05:55.628]             for (name in names(...future.x_jj)) {
  [21:05:55.628]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.628]                   inherits = FALSE)
  [21:05:55.628]             }
  [21:05:55.628]         })
  [21:05:55.628]         tryCatch({
  [21:05:55.628]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.628]                 plan = future::plan())
  [21:05:55.628]         }, error = identity)
  [21:05:55.628]     })
  [21:05:55.628] }
  [21:05:55.629]   - globals: [1] '...future.x_ii'
  [21:05:55.630] List of 1
  [21:05:55.630]  $ ...future.x_ii: NULL
  [21:05:55.630]  - attr(*, "where")=List of 1
  [21:05:55.630]   ..$ ...future.x_ii:<environment: 0x1237a90> 
  [21:05:55.630]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.630]  - attr(*, "resolved")= logi FALSE
  [21:05:55.630]  - attr(*, "total_size")= num 0
  [21:05:55.636]   - packages: [1] 'doFuture'
  [21:05:55.637] - identifying globals and packages ... DONE
  [21:05:55.638] Number of chunks: 2
  [21:05:55.639] Number of futures (= number of chunks): 2
  [21:05:55.639] Launching 2 futures (chunks) ...
  [21:05:55.639] Chunk #1 of 2 ...
  [21:05:55.640]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.642] 
  [21:05:55.643] 
  [21:05:55.643]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.663] Chunk #1 of 2 ... DONE
  [21:05:55.663] Chunk #2 of 2 ...
  [21:05:55.664]  - Finding globals in 'args_list' chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.667] 
  [21:05:55.668] 
  [21:05:55.668]  - Finding globals in 'args_list' for chunk #2 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.690] Chunk #2 of 2 ... DONE
  [21:05:55.691] Launching 2 futures (chunks) ... DONE
  [21:05:55.691] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  [21:05:55.708] - relaying conditions of futures
  [21:05:55.714] - collecting values of futures
  [21:05:55.714] - accumulating results
  [21:05:55.718] - processing errors (handler = 'stop')
  [21:05:55.719] - extracting results
  [21:05:55.719] doFuture() ... DONE
  - plan(list('multicore', 'multicore')) ... DONE
  - plan(list('multicore', 'multisession')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  [21:05:55.724] doFuture() ...
  [21:05:55.733] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.734] - R expression:
  [21:05:55.735] {
  [21:05:55.735]     doFuture::registerDoFuture()
  [21:05:55.735]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.735]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.735]         {
  [21:05:55.735]             a <- NULL
  [21:05:55.735]             b <- NULL
  [21:05:55.735]         }
  [21:05:55.735]         ...future.env <- environment()
  [21:05:55.735]         local({
  [21:05:55.735]             for (name in names(...future.x_jj)) {
  [21:05:55.735]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.735]                   inherits = FALSE)
  [21:05:55.735]             }
  [21:05:55.735]         })
  [21:05:55.735]         tryCatch({
  [21:05:55.735]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.735]                 plan = future::plan())
  [21:05:55.735]         }, error = identity)
  [21:05:55.735]     })
  [21:05:55.735] }
  [21:05:55.735] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.761] List of 1
  [21:05:55.761]  $ ...future.x_ii: NULL
  [21:05:55.761]  - attr(*, "where")=List of 1
  [21:05:55.761]   ..$ ...future.x_ii:<environment: 0x2f9d978> 
  [21:05:55.761]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.761]  - attr(*, "resolved")= logi FALSE
  [21:05:55.761]  - attr(*, "total_size")= num 0
  [21:05:55.768]   - R expression:
  [21:05:55.768] {
  [21:05:55.768]     doFuture::registerDoFuture()
  [21:05:55.768]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.768]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.768]         {
  [21:05:55.768]             a <- NULL
  [21:05:55.768]             b <- NULL
  [21:05:55.768]         }
  [21:05:55.768]         ...future.env <- environment()
  [21:05:55.768]         local({
  [21:05:55.768]             for (name in names(...future.x_jj)) {
  [21:05:55.768]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.768]                   inherits = FALSE)
  [21:05:55.768]             }
  [21:05:55.768]         })
  [21:05:55.768]         tryCatch({
  [21:05:55.768]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.768]                 plan = future::plan())
  [21:05:55.768]         }, error = identity)
  [21:05:55.768]     })
  [21:05:55.768] }
  [21:05:55.769]   - globals: [1] '...future.x_ii'
  [21:05:55.769] List of 1
  [21:05:55.769]  $ ...future.x_ii: NULL
  [21:05:55.769]  - attr(*, "where")=List of 1
  [21:05:55.769]   ..$ ...future.x_ii:<environment: 0x2f9d978> 
  [21:05:55.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.769]  - attr(*, "resolved")= logi FALSE
  [21:05:55.769]  - attr(*, "total_size")= num 0
  [21:05:55.776]   - packages: [1] 'doFuture'
  [21:05:55.776] - identifying globals and packages ... DONE
  [21:05:55.777] Number of chunks: 2
  [21:05:55.778] Number of futures (= number of chunks): 2
  [21:05:55.778] Launching 2 futures (chunks) ...
  [21:05:55.778] Chunk #1 of 2 ...
  [21:05:55.779]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.781] 
  [21:05:55.782] 
  [21:05:55.782]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
                  workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.798] Chunk #1 of 2 ... DONE
  [21:05:55.799] Chunk #2 of 2 ...
  [21:05:55.799]  - Finding globals in 'args_list' chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.803] 
  [21:05:55.803] 
  [21:05:55.803]  - Finding globals in 'args_list' for chunk #2 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
                  workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  MulticoreFuture started
  [21:05:55.824] Chunk #2 of 2 ... DONE
  [21:05:55.824] Launching 2 futures (chunks) ... DONE
  [21:05:55.824] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  [21:05:55.853] - relaying conditions of futures
  [21:05:55.857] - collecting values of futures
  [21:05:55.858] - accumulating results
  [21:05:55.866] - processing errors (handler = 'stop')
  [21:05:55.883] - extracting results
  [21:05:55.883] doFuture() ... DONE
  - plan(list('multicore', 'multisession')) ... DONE
  - plan(list('multicore', 'cluster')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  [21:05:55.888] doFuture() ...
  [21:05:55.893] - dummy globals (as locals): [2] 'a', 'b'
  [21:05:55.895] - R expression:
  [21:05:55.895] {
  [21:05:55.895]     doFuture::registerDoFuture()
  [21:05:55.895]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.895]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.895]         {
  [21:05:55.895]             a <- NULL
  [21:05:55.895]             b <- NULL
  [21:05:55.895]         }
  [21:05:55.895]         ...future.env <- environment()
  [21:05:55.895]         local({
  [21:05:55.895]             for (name in names(...future.x_jj)) {
  [21:05:55.895]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.895]                   inherits = FALSE)
  [21:05:55.895]             }
  [21:05:55.895]         })
  [21:05:55.895]         tryCatch({
  [21:05:55.895]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.895]                 plan = future::plan())
  [21:05:55.895]         }, error = identity)
  [21:05:55.895]     })
  [21:05:55.895] }
  [21:05:55.896] - identifying globals and packages ...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [15] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'list', 'identity'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 0 bytes (0 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  [21:05:55.919] List of 1
  [21:05:55.919]  $ ...future.x_ii: NULL
  [21:05:55.919]  - attr(*, "where")=List of 1
  [21:05:55.919]   ..$ ...future.x_ii:<environment: 0xf61298> 
  [21:05:55.919]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.919]  - attr(*, "resolved")= logi FALSE
  [21:05:55.919]  - attr(*, "total_size")= num 0
  [21:05:55.926]   - R expression:
  [21:05:55.926] {
  [21:05:55.926]     doFuture::registerDoFuture()
  [21:05:55.926]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [21:05:55.926]         ...future.x_jj <- ...future.x_ii[[jj]]
  [21:05:55.926]         {
  [21:05:55.926]             a <- NULL
  [21:05:55.926]             b <- NULL
  [21:05:55.926]         }
  [21:05:55.926]         ...future.env <- environment()
  [21:05:55.926]         local({
  [21:05:55.926]             for (name in names(...future.x_jj)) {
  [21:05:55.926]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [21:05:55.926]                   inherits = FALSE)
  [21:05:55.926]             }
  [21:05:55.926]         })
  [21:05:55.926]         tryCatch({
  [21:05:55.926]             list(a = a, b = b, plan_b = future::plan("list"), 
  [21:05:55.926]                 plan = future::plan())
  [21:05:55.926]         }, error = identity)
  [21:05:55.926]     })
  [21:05:55.926] }
  [21:05:55.927]   - globals: [1] '...future.x_ii'
  [21:05:55.927] List of 1
  [21:05:55.927]  $ ...future.x_ii: NULL
  [21:05:55.927]  - attr(*, "where")=List of 1
  [21:05:55.927]   ..$ ...future.x_ii:<environment: 0xf61298> 
  [21:05:55.927]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [21:05:55.927]  - attr(*, "resolved")= logi FALSE
  [21:05:55.927]  - attr(*, "total_size")= num 0
  [21:05:55.934]   - packages: [1] 'doFuture'
  [21:05:55.935] - identifying globals and packages ... DONE
  [21:05:55.936] Number of chunks: 2
  [21:05:55.937] Number of futures (= number of chunks): 2
  [21:05:55.937] Launching 2 futures (chunks) ...
  [21:05:55.937] Chunk #1 of 2 ...
  [21:05:55.938]  - Finding globals in 'args_list' chunk #1 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.940] 
  [21:05:55.941] 
  [21:05:55.941]  - Finding globals in 'args_list' for chunk #1 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  The total size of the 1 globals is 336 bytes (336 bytes)
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = 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, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = 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, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.961] Chunk #1 of 2 ... DONE
  [21:05:55.962] Chunk #2 of 2 ...
  [21:05:55.962]  - Finding globals in 'args_list' chunk #2 ...
  getGlobalsAndPackages() ...
  Searching for globals...
  
  Searching for globals ... DONE
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  [21:05:55.967] 
  [21:05:55.967] 
  [21:05:55.968]  - Finding globals in 'args_list' for chunk #2 ... DONE
  getGlobalsAndPackages() ...
  - globals passed as-is: [1] '...future.x_ii'
  Resolving globals: FALSE
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  The total size of the 1 globals is 336 bytes (336 bytes)
  plan(): nbrOfWorkers() = 1
  - globals: [1] '...future.x_ii'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'doFuture'
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    {
                      has_future <- requireNamespace("future", 
                        quietly = TRUE)
                      version <- if (has_future) 
                        packageVersion("future")
                      else NULL
                      if (!has_future || version < "1.8.0") {
                        info <- c(r_version = gsub("R version ", 
                          "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                          R.version$platform, 8 * .Machine$sizeof.pointer), 
                          os = paste(Sys.info()[c("sysname", "release", 
                            "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                        info <- sprintf("%s: %s", names(info), 
                          info)
                        info <- paste(info, collapse = "; ")
                        if (!has_future) {
                          msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                            info)
                        }
                        else {
                          msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                            info, version)
                        }
                        stop(msg)
                      }
                    }
                    ...future.mc.cores.old <- getOption("mc.cores")
                    options(mc.cores = 1L)
                  }
                  local({
                    for (pkg in c("future", "doFuture")) {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(b = 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, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  doFuture::registerDoFuture()
                  lapply(seq_along(...future.x_ii), FUN = function(jj) {
                    ...future.x_jj <- ...future.x_ii[[jj]]
                    {
                      a <- NULL
                      b <- NULL
                    }
                    ...future.env <- environment()
                    local({
                      for (name in names(...future.x_jj)) {
                        assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                          inherits = FALSE)
                      }
                    })
                    tryCatch({
                      list(a = a, b = b, plan_b = future::plan("list"), 
                        plan = future::plan())
                    }, error = identity)
                  })
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              {
                  options(mc.cores = ...future.mc.cores.old)
              }
              future::plan(list(a = function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(is.finite(workers), workers >= 1L)
                  if (workers == 1L || !supportsMulticore()) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = lazy, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  oopts <- options(mc.cores = workers)
                  on.exit(options(oopts))
                  future <- MulticoreFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, workers = workers, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, b = 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, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  future <- ClusterFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, user = user, revtunnel = revtunnel, 
                    homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .cleanup = FALSE, .init = FALSE)
          }
          options(...future.oldOptions)
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  [21:05:55.990] Chunk #2 of 2 ... DONE
  [21:05:55.991] Launching 2 futures (chunks) ... DONE
  [21:05:55.991] - resolving futures
  resolve() on list ...
   recursive: 0
   length: 2
  
   length: 1 (resolved future 1)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. cluster:
     - 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, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): nbrOfWorkers() = 2
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  [21:05:56.004] - relaying conditions of futures
  [21:05:56.009] - collecting values of futures
  [21:05:56.010] - accumulating results
  [21:05:56.013] - processing errors (handler = 'stop')
  [21:05:56.014] - extracting results
  [21:05:56.014] doFuture() ... DONE
  - plan(list('multicore', 'cluster')) ... DONE
  - plan(list('multisession', 'sequential')) ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(a = strategy1, b = strategy2))
  
  plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  multisession:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: FALSE
  - call: plan(list(a = strategy1, b = strategy2))
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11408
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript -e 'try(cat(Sys.getpid(),file="/tmp/RtmpfRdlQy/future.parent=6775.1a77f5bb0fc.pid"), silent = TRUE)' -e "file.exists('/tmp/RtmpfRdlQy/future.parent=6775.1a77f5bb0fc.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:6775:gimli:hornik' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpfRdlQy/future.parent=6775.1a77f5bb0fc.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11408 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript -e 'try(cat(Sys.getpid(),file="/tmp/RtmpfRdlQy/future.parent=6775.1a7716df8b43.pid"), silent = TRUE)' -e "file.exists('/tmp/RtmpfRdlQy/future.parent=6775.1a7716df8b43.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:6775:gimli:hornik' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpfRdlQy/future.parent=6775.1a7716df8b43.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11408 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] Detected a warning from socketConnection(): 'port 11408 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11408 cannot be opened
  Killing worker process (PID 10600) if still alive
  Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(6775, signal = 0L)
  [1] TRUE
  Call: tools::pskill(6775, signal = 0L)
  [1] TRUE
  - success
  Attempting to find a working pid_exists_*() function ... done
  Worker (PID 10600) 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 11408 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 11408 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,nested.R:6775:gimli:hornik' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpfRdlQy/future.parent=6775.1a7716df8b43.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11408 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 10600) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted