Running ‘DEPRECATED.R’ [1s/1s]
  Running ‘cluster-missing-doFuture-pkg.R’ [1s/3s]
  Running ‘doRNG,dopar.R’ [3s/8s]
  Running ‘doRNG,dorng.R’ [7s/15s]
  Running ‘foreach,errors.R’ [7s/22s]
  Running ‘foreach,globals.R’ [9s/26s]
  Running ‘foreach,nested.R’ [9s/30s]
  Running ‘foreach,nested_dopar.R’ [19s/58s]
  Running ‘foreach.R’ [3s/9s]
  Running ‘future.BatchJobs.R’ [1s/1s]
  Running ‘future.batchtools.R’ [1s/1s]
  Running ‘options.R’ [3s/8s]
  Running ‘registerDoFuture.R’ [2s/6s]
  Running ‘times.R’ [3s/9s]
  Running ‘zzz_opt-in,NMF.R’ [0s/1s]
  Running ‘zzz_opt-in,TSP.R’ [0s/0s]
  Running ‘zzz_opt-in,caret.R’ [0s/1s]
  Running ‘zzz_opt-in,foreach.R’ [0s/1s]
  Running ‘zzz_opt-in,glmnet.R’ [0s/1s]
  Running ‘zzz_opt-in,plyr.R’ [0s/1s]
Running the tests in ‘tests/foreach,errors.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
  [06:53:31.916] plan(): Setting new future strategy stack:
  [06:53:31.916] List of future strategies:
  [06:53:31.916] 1. sequential:
  [06:53:31.916]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:31.916]    - tweaked: FALSE
  [06:53:31.916]    - call: future::plan(future::sequential)
  [06:53:31.919] plan(): nbrOfWorkers() = 1
  > 
  > strategies <- future:::supportedStrategies()
  > strategies <- setdiff(strategies, "multiprocess")
  > 
  > message("*** doFuture() - error handling w/ 'stop' ...")
  *** doFuture() - error handling w/ 'stop' ...
  > 
  > for (strategy in strategies) {
  +   message(sprintf("- plan('%s') ...", strategy))
  +   plan(strategy)
  + 
  +   mu <- 1.0
  +   sigma <- 2.0
  + 
  +   res <- tryCatch({
  +     foreach(i = 1:10, .errorhandling = "stop") %dopar% {
  +       if (i %% 2 == 0) stop(sprintf("Index error ('stop'), because i = %d", i))
  +       dnorm(i, mean = mu, sd = sigma)
  +     }
  +   }, error = identity)
  +   print(res)
  +   stopifnot(inherits(res, "error"),
  +             grepl("Index error", conditionMessage(res)))
  + 
  +   message(sprintf("- plan('%s') ... DONE", strategy))
  + } ## for (strategy ...)
  - plan('sequential') ...
  [06:53:31.963] plan(): Setting new future strategy stack:
  [06:53:31.963] List of future strategies:
  [06:53:31.963] 1. sequential:
  [06:53:31.963]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:31.963]    - tweaked: FALSE
  [06:53:31.963]    - call: plan(strategy)
  [06:53:31.999] plan(): nbrOfWorkers() = 1
  [06:53:32.000] doFuture() ...
  [06:53:32.004] - dummy globals (as locals): [1] 'i'
  [06:53:32.005] - R expression:
  [06:53:32.006] {
  [06:53:32.006]     doFuture::registerDoFuture()
  [06:53:32.006]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.006]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.006]         i <- NULL
  [06:53:32.006]         ...future.env <- environment()
  [06:53:32.006]         local({
  [06:53:32.006]             for (name in names(...future.x_jj)) {
  [06:53:32.006]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.006]                   inherits = FALSE)
  [06:53:32.006]             }
  [06:53:32.006]         })
  [06:53:32.006]         tryCatch({
  [06:53:32.006]             if (i%%2 == 0) 
  [06:53:32.006]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.006]                   i))
  [06:53:32.006]             dnorm(i, mean = mu, sd = sigma)
  [06:53:32.006]         }, error = identity)
  [06:53:32.006]     })
  [06:53:32.006] }
  [06:53:32.007] - identifying globals and packages ...
  [06:53:32.009] getGlobalsAndPackages() ...
  [06:53:32.010] Searching for globals...
  [06:53:32.050] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:32.050] Searching for globals ... DONE
  [06:53:32.051] Resolving globals: FALSE
  [06:53:32.054] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:32.055] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.055] - packages: [1] 'stats'
  [06:53:32.056] getGlobalsAndPackages() ... DONE
  [06:53:32.056] List of 3
  [06:53:32.056]  $ ...future.x_ii: NULL
  [06:53:32.056]  $ mu            : num 1
  [06:53:32.056]  $ sigma         : num 2
  [06:53:32.056]  - attr(*, "where")=List of 3
  [06:53:32.056]   ..$ ...future.x_ii:<environment: 0x557600a83dd8> 
  [06:53:32.056]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:32.056]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:32.056]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:32.056]  - attr(*, "resolved")= logi FALSE
  [06:53:32.056]  - attr(*, "total_size")= num 112
  [06:53:32.074]   - R expression:
  [06:53:32.074] {
  [06:53:32.074]     doFuture::registerDoFuture()
  [06:53:32.074]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.074]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.074]         i <- NULL
  [06:53:32.074]         ...future.env <- environment()
  [06:53:32.074]         local({
  [06:53:32.074]             for (name in names(...future.x_jj)) {
  [06:53:32.074]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.074]                   inherits = FALSE)
  [06:53:32.074]             }
  [06:53:32.074]         })
  [06:53:32.074]         tryCatch({
  [06:53:32.074]             if (i%%2 == 0) 
  [06:53:32.074]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.074]                   i))
  [06:53:32.074]             dnorm(i, mean = mu, sd = sigma)
  [06:53:32.074]         }, error = identity)
  [06:53:32.074]     })
  [06:53:32.074] }
  [06:53:32.075]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.076] List of 3
  [06:53:32.076]  $ ...future.x_ii: NULL
  [06:53:32.076]  $ mu            : num 1
  [06:53:32.076]  $ sigma         : num 2
  [06:53:32.076]  - attr(*, "where")=List of 3
  [06:53:32.076]   ..$ ...future.x_ii:<environment: 0x557600a83dd8> 
  [06:53:32.076]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:32.076]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:32.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:32.076]  - attr(*, "resolved")= logi FALSE
  [06:53:32.076]  - attr(*, "total_size")= num 112
  [06:53:32.088]   - packages: [2] 'doFuture', 'stats'
  [06:53:32.088] - identifying globals and packages ... DONE
  [06:53:32.089] Number of chunks: 1
  [06:53:32.090] Number of futures (= number of chunks): 1
  [06:53:32.092] Launching 1 futures (chunks) ...
  [06:53:32.092] Chunk #1 of 1 ...
  [06:53:32.092]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:32.093] getGlobalsAndPackages() ...
  [06:53:32.093] Searching for globals...
  [06:53:32.095] 
  [06:53:32.095] Searching for globals ... DONE
  [06:53:32.096] - globals: [0] <none>
  [06:53:32.096] getGlobalsAndPackages() ... DONE
  [06:53:32.096] 
  [06:53:32.097] 
  [06:53:32.097]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:32.098] getGlobalsAndPackages() ...
  [06:53:32.099] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.099] Resolving globals: FALSE
  [06:53:32.101] The total size of the 3 globals is 672 bytes (672 bytes)
  [06:53:32.101] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.102] 
  [06:53:32.102] getGlobalsAndPackages() ... DONE
  [06:53:32.106] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:32.106] Packages needed by future strategies (n = 0): <none>
  [06:53:32.114] {
  [06:53:32.114]     {
  [06:53:32.114]         ...future.startTime <- base::Sys.time()
  [06:53:32.114]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:32.114]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:32.114]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [06:53:32.114]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:32.114]             future.resolve.recursive = NULL, width = 80L)
  [06:53:32.114]         {
  [06:53:32.114]             {
  [06:53:32.114]                 {
  [06:53:32.114]                   base::local({
  [06:53:32.114]                     has_future <- base::requireNamespace("future", 
  [06:53:32.114]                       quietly = TRUE)
  [06:53:32.114]                     version <- if (has_future) 
  [06:53:32.114]                       utils::packageVersion("future")
  [06:53:32.114]                     else NULL
  [06:53:32.114]                     if (!has_future || version < "1.8.0") {
  [06:53:32.114]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:32.114]                         "", base::R.version$version.string), 
  [06:53:32.114]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:32.114]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:32.114]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:32.114]                           "release", "version")], collapse = " "), 
  [06:53:32.114]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:32.114]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:32.114]                         info)
  [06:53:32.114]                       info <- base::paste(info, collapse = "; ")
  [06:53:32.114]                       if (!has_future) {
  [06:53:32.114]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:32.114]                           info)
  [06:53:32.114]                       }
  [06:53:32.114]                       else {
  [06:53:32.114]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:32.114]                           info, version)
  [06:53:32.114]                       }
  [06:53:32.114]                       base::stop(msg)
  [06:53:32.114]                     }
  [06:53:32.114]                   })
  [06:53:32.114]                 }
  [06:53:32.114]                 base::local({
  [06:53:32.114]                   for (pkg in c("doFuture", "stats")) {
  [06:53:32.114]                     base::loadNamespace(pkg)
  [06:53:32.114]                     base::library(pkg, character.only = TRUE)
  [06:53:32.114]                   }
  [06:53:32.114]                 })
  [06:53:32.114]             }
  [06:53:32.114]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:32.114]         }
  [06:53:32.114]     }
  [06:53:32.114]     if (base::is.na(TRUE)) {
  [06:53:32.114]     }
  [06:53:32.114]     else {
  [06:53:32.114]         if (TRUE) {
  [06:53:32.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:32.114]                 open = "w")
  [06:53:32.114]         }
  [06:53:32.114]         else {
  [06:53:32.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:32.114]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:32.114]         }
  [06:53:32.114]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:32.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:32.114]             base::sink(type = "output", split = FALSE)
  [06:53:32.114]             base::close(...future.stdout)
  [06:53:32.114]         }, add = TRUE)
  [06:53:32.114]     }
  [06:53:32.114]     ...future.frame <- base::sys.nframe()
  [06:53:32.114]     ...future.conditions <- base::list()
  [06:53:32.114]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:32.114]     ...future.result <- base::tryCatch({
  [06:53:32.114]         base::withCallingHandlers({
  [06:53:32.114]             ...future.value <- base::withVisible(base::local({
  [06:53:32.114]                 doFuture::registerDoFuture()
  [06:53:32.114]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.114]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.114]                   i <- NULL
  [06:53:32.114]                   ...future.env <- environment()
  [06:53:32.114]                   local({
  [06:53:32.114]                     for (name in names(...future.x_jj)) {
  [06:53:32.114]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.114]                         inherits = FALSE)
  [06:53:32.114]                     }
  [06:53:32.114]                   })
  [06:53:32.114]                   tryCatch({
  [06:53:32.114]                     if (i%%2 == 0) 
  [06:53:32.114]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.114]                         i))
  [06:53:32.114]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:32.114]                   }, error = identity)
  [06:53:32.114]                 })
  [06:53:32.114]             }))
  [06:53:32.114]             future::FutureResult(value = ...future.value$value, 
  [06:53:32.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.114]                   ...future.rng), started = ...future.startTime, 
  [06:53:32.114]                 version = "1.8")
  [06:53:32.114]         }, condition = base::local({
  [06:53:32.114]             c <- base::c
  [06:53:32.114]             inherits <- base::inherits
  [06:53:32.114]             invokeRestart <- base::invokeRestart
  [06:53:32.114]             length <- base::length
  [06:53:32.114]             list <- base::list
  [06:53:32.114]             seq.int <- base::seq.int
  [06:53:32.114]             signalCondition <- base::signalCondition
  [06:53:32.114]             sys.calls <- base::sys.calls
  [06:53:32.114]             Sys.time <- base::Sys.time
  [06:53:32.114]             `[[` <- base::`[[`
  [06:53:32.114]             `+` <- base::`+`
  [06:53:32.114]             `<<-` <- base::`<<-`
  [06:53:32.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:32.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:32.114]                   3L)]
  [06:53:32.114]             }
  [06:53:32.114]             function(cond) {
  [06:53:32.114]                 if (inherits(cond, "error")) {
  [06:53:32.114]                   sessionInformation <- function() {
  [06:53:32.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:32.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:32.114]                       search = base::search(), system = base::Sys.info())
  [06:53:32.114]                   }
  [06:53:32.114]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:32.114]                     cond$call), session = sessionInformation(), 
  [06:53:32.114]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:32.114]                   signalCondition(cond)
  [06:53:32.114]                 }
  [06:53:32.114]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:32.114]                 ))) {
  [06:53:32.114]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:32.114]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:32.114]                   if (!signal) {
  [06:53:32.114]                     muffleCondition <- function (cond) 
  [06:53:32.114]                     {
  [06:53:32.114]                       inherits <- base::inherits
  [06:53:32.114]                       invokeRestart <- base::invokeRestart
  [06:53:32.114]                       muffled <- FALSE
  [06:53:32.114]                       if (inherits(cond, "message")) {
  [06:53:32.114]                         invokeRestart("muffleMessage")
  [06:53:32.114]                         muffled <- TRUE
  [06:53:32.114]                       }
  [06:53:32.114]                       else if (inherits(cond, "warning")) {
  [06:53:32.114]                         invokeRestart("muffleWarning")
  [06:53:32.114]                         muffled <- TRUE
  [06:53:32.114]                       }
  [06:53:32.114]                       else if (inherits(cond, "condition")) {
  [06:53:32.114]                         computeRestarts <- base::computeRestarts
  [06:53:32.114]                         grepl <- base::grepl
  [06:53:32.114]                         is.null <- base::is.null
  [06:53:32.114]                         restarts <- computeRestarts(cond)
  [06:53:32.114]                         for (restart in restarts) {
  [06:53:32.114]                           name <- restart$name
  [06:53:32.114]                           if (is.null(name)) 
  [06:53:32.114]                             next
  [06:53:32.114]                           if (!grepl("^muffle", name)) 
  [06:53:32.114]                             next
  [06:53:32.114]                           invokeRestart(restart)
  [06:53:32.114]                           muffled <- TRUE
  [06:53:32.114]                           break
  [06:53:32.114]                         }
  [06:53:32.114]                       }
  [06:53:32.114]                       invisible(muffled)
  [06:53:32.114]                     }
  [06:53:32.114]                     muffleCondition(cond)
  [06:53:32.114]                   }
  [06:53:32.114]                 }
  [06:53:32.114]             }
  [06:53:32.114]         }))
  [06:53:32.114]     }, error = function(ex) {
  [06:53:32.114]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:32.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.114]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:32.114]     }, finally = {
  [06:53:32.114]         {
  [06:53:32.114]             NULL
  [06:53:32.114]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:32.114]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:32.114]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [06:53:32.114]                 label = NULL, ...) 
  [06:53:32.114]             {
  [06:53:32.114]                 if (substitute) 
  [06:53:32.114]                   expr <- substitute(expr)
  [06:53:32.114]                 local <- as.logical(local)
  [06:53:32.114]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [06:53:32.114]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:32.114]                   globals = globals, local = local, earlySignal = earlySignal, 
  [06:53:32.114]                   label = label, ...)
  [06:53:32.114]                 if (!future$lazy) 
  [06:53:32.114]                   future <- run(future)
  [06:53:32.114]                 invisible(future)
  [06:53:32.114]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:32.114]         }
  [06:53:32.114]         base::options(...future.oldOptions)
  [06:53:32.114]     })
  [06:53:32.114]     Sys.time
  [06:53:32.114]     if (base::is.na(TRUE)) {
  [06:53:32.114]     }
  [06:53:32.114]     else {
  [06:53:32.114]         base::sink(type = "output", split = FALSE)
  [06:53:32.114]         if (TRUE) {
  [06:53:32.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:32.114]         }
  [06:53:32.114]         else {
  [06:53:32.114]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:32.114]         }
  [06:53:32.114]         base::close(...future.stdout)
  [06:53:32.114]         ...future.stdout <- NULL
  [06:53:32.114]     }
  [06:53:32.114]     ...future.result$conditions <- ...future.conditions
  [06:53:32.114]     ...future.result
  [06:53:32.114] }
  [06:53:32.121] plan(): Setting new future strategy stack:
  [06:53:32.121] List of future strategies:
  [06:53:32.121] 1. sequential:
  [06:53:32.121]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.121]    - tweaked: FALSE
  [06:53:32.121]    - call: NULL
  [06:53:32.123] plan(): nbrOfWorkers() = 1
  [06:53:32.152] plan(): Setting new future strategy stack:
  [06:53:32.153] List of future strategies:
  [06:53:32.153] 1. sequential:
  [06:53:32.153]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.153]    - tweaked: FALSE
  [06:53:32.153]    - call: plan(strategy)
  [06:53:32.154] plan(): nbrOfWorkers() = 1
  [06:53:32.155] SequentialFuture started (and completed)
  [06:53:32.156] Chunk #1 of 1 ... DONE
  [06:53:32.157] Launching 1 futures (chunks) ... DONE
  [06:53:32.157] - resolving futures
  [06:53:32.157]   - gathering results & relaying conditions (except errors)
  [06:53:32.158] resolve() on list ...
  [06:53:32.159]  recursive: 0
  [06:53:32.160]  length: 1
  [06:53:32.160] 
  [06:53:32.161] Future #1
  [06:53:32.161] signalConditionsASAP(SequentialFuture, pos=1) ...
  [06:53:32.162] - nx: 1
  [06:53:32.162] - relay: TRUE
  [06:53:32.163] - stdout: TRUE
  [06:53:32.163] - signal: TRUE
  [06:53:32.163] - resignal: FALSE
  [06:53:32.164] - force: FALSE
  [06:53:32.164] - relayed: [n=1] FALSE
  [06:53:32.164] - queued futures: [n=1] FALSE
  [06:53:32.165]  - until=1
  [06:53:32.165]  - relaying element #1
  [06:53:32.166] - relayed: [n=1] TRUE
  [06:53:32.166] - queued futures: [n=1] TRUE
  [06:53:32.166] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [06:53:32.167]  length: 0 (resolved future 1)
  [06:53:32.167] Relaying remaining futures
  [06:53:32.168] signalConditionsASAP(NULL, pos=0) ...
  [06:53:32.168] - nx: 1
  [06:53:32.168] - relay: TRUE
  [06:53:32.169] - stdout: TRUE
  [06:53:32.169] - signal: TRUE
  [06:53:32.169] - resignal: FALSE
  [06:53:32.170] - force: FALSE
  [06:53:32.170] - relayed: [n=1] TRUE
  [06:53:32.170] - queued futures: [n=1] TRUE
   - flush all
  [06:53:32.171] - relayed: [n=1] TRUE
  [06:53:32.171] - queued futures: [n=1] TRUE
  [06:53:32.172] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:32.172] resolve() on list ... DONE
  [06:53:32.172] - collecting values of futures
  [06:53:32.173] - accumulating results
  [06:53:32.177] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('sequential') ... DONE
  - plan('multicore') ...
  [06:53:32.179] plan(): Setting new future strategy stack:
  [06:53:32.180] List of future strategies:
  [06:53:32.180] 1. multicore:
  [06:53:32.180]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:32.180]    - tweaked: FALSE
  [06:53:32.180]    - call: plan(strategy)
  [06:53:32.206] plan(): nbrOfWorkers() = 2
  [06:53:32.207] doFuture() ...
  [06:53:32.210] - dummy globals (as locals): [1] 'i'
  [06:53:32.211] - R expression:
  [06:53:32.211] {
  [06:53:32.211]     doFuture::registerDoFuture()
  [06:53:32.211]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.211]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.211]         i <- NULL
  [06:53:32.211]         ...future.env <- environment()
  [06:53:32.211]         local({
  [06:53:32.211]             for (name in names(...future.x_jj)) {
  [06:53:32.211]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.211]                   inherits = FALSE)
  [06:53:32.211]             }
  [06:53:32.211]         })
  [06:53:32.211]         tryCatch({
  [06:53:32.211]             if (i%%2 == 0) 
  [06:53:32.211]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.211]                   i))
  [06:53:32.211]             dnorm(i, mean = mu, sd = sigma)
  [06:53:32.211]         }, error = identity)
  [06:53:32.211]     })
  [06:53:32.211] }
  [06:53:32.212] - identifying globals and packages ...
  [06:53:32.213] getGlobalsAndPackages() ...
  [06:53:32.213] Searching for globals...
  [06:53:32.243] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:32.244] Searching for globals ... DONE
  [06:53:32.244] Resolving globals: FALSE
  [06:53:32.246] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:32.247] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.248] - packages: [1] 'stats'
  [06:53:32.248] getGlobalsAndPackages() ... DONE
  [06:53:32.248] List of 3
  [06:53:32.248]  $ ...future.x_ii: NULL
  [06:53:32.248]  $ mu            : num 1
  [06:53:32.248]  $ sigma         : num 2
  [06:53:32.248]  - attr(*, "where")=List of 3
  [06:53:32.248]   ..$ ...future.x_ii:<environment: 0x5575feed87f8> 
  [06:53:32.248]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:32.248]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:32.248]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:32.248]  - attr(*, "resolved")= logi FALSE
  [06:53:32.248]  - attr(*, "total_size")= num 112
  [06:53:32.265]   - R expression:
  [06:53:32.265] {
  [06:53:32.265]     doFuture::registerDoFuture()
  [06:53:32.265]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.265]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.265]         i <- NULL
  [06:53:32.265]         ...future.env <- environment()
  [06:53:32.265]         local({
  [06:53:32.265]             for (name in names(...future.x_jj)) {
  [06:53:32.265]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.265]                   inherits = FALSE)
  [06:53:32.265]             }
  [06:53:32.265]         })
  [06:53:32.265]         tryCatch({
  [06:53:32.265]             if (i%%2 == 0) 
  [06:53:32.265]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.265]                   i))
  [06:53:32.265]             dnorm(i, mean = mu, sd = sigma)
  [06:53:32.265]         }, error = identity)
  [06:53:32.265]     })
  [06:53:32.265] }
  [06:53:32.266]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.267] List of 3
  [06:53:32.267]  $ ...future.x_ii: NULL
  [06:53:32.267]  $ mu            : num 1
  [06:53:32.267]  $ sigma         : num 2
  [06:53:32.267]  - attr(*, "where")=List of 3
  [06:53:32.267]   ..$ ...future.x_ii:<environment: 0x5575feed87f8> 
  [06:53:32.267]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:32.267]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:32.267]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:32.267]  - attr(*, "resolved")= logi FALSE
  [06:53:32.267]  - attr(*, "total_size")= num 112
  [06:53:32.280]   - packages: [2] 'doFuture', 'stats'
  [06:53:32.280] - identifying globals and packages ... DONE
  [06:53:32.284] Number of chunks: 2
  [06:53:32.285] Number of futures (= number of chunks): 2
  [06:53:32.286] Launching 2 futures (chunks) ...
  [06:53:32.286] Chunk #1 of 2 ...
  [06:53:32.286]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:32.287] getGlobalsAndPackages() ...
  [06:53:32.287] Searching for globals...
  [06:53:32.288] 
  [06:53:32.289] Searching for globals ... DONE
  [06:53:32.289] - globals: [0] <none>
  [06:53:32.290] getGlobalsAndPackages() ... DONE
  [06:53:32.290] 
  [06:53:32.290] 
  [06:53:32.291]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:32.292] getGlobalsAndPackages() ...
  [06:53:32.292] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.293] Resolving globals: FALSE
  [06:53:32.294] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:32.295] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.295] 
  [06:53:32.295] getGlobalsAndPackages() ... DONE
  [06:53:32.299] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:32.300] Packages needed by future strategies (n = 0): <none>
  [06:53:32.307] {
  [06:53:32.307]     {
  [06:53:32.307]         ...future.startTime <- base::Sys.time()
  [06:53:32.307]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:32.307]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:32.307]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:32.307]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:32.307]             future.resolve.recursive = NULL, width = 80L)
  [06:53:32.307]         {
  [06:53:32.307]             {
  [06:53:32.307]                 {
  [06:53:32.307]                   {
  [06:53:32.307]                     base::local({
  [06:53:32.307]                       has_future <- base::requireNamespace("future", 
  [06:53:32.307]                         quietly = TRUE)
  [06:53:32.307]                       version <- if (has_future) 
  [06:53:32.307]                         utils::packageVersion("future")
  [06:53:32.307]                       else NULL
  [06:53:32.307]                       if (!has_future || version < "1.8.0") {
  [06:53:32.307]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:32.307]                           "", base::R.version$version.string), 
  [06:53:32.307]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:32.307]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:32.307]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:32.307]                             "release", "version")], collapse = " "), 
  [06:53:32.307]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:32.307]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:32.307]                           info)
  [06:53:32.307]                         info <- base::paste(info, collapse = "; ")
  [06:53:32.307]                         if (!has_future) {
  [06:53:32.307]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:32.307]                             info)
  [06:53:32.307]                         }
  [06:53:32.307]                         else {
  [06:53:32.307]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:32.307]                             info, version)
  [06:53:32.307]                         }
  [06:53:32.307]                         base::stop(msg)
  [06:53:32.307]                       }
  [06:53:32.307]                     })
  [06:53:32.307]                   }
  [06:53:32.307]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:32.307]                   base::options(mc.cores = 1L)
  [06:53:32.307]                 }
  [06:53:32.307]                 base::local({
  [06:53:32.307]                   for (pkg in c("doFuture", "stats")) {
  [06:53:32.307]                     base::loadNamespace(pkg)
  [06:53:32.307]                     base::library(pkg, character.only = TRUE)
  [06:53:32.307]                   }
  [06:53:32.307]                 })
  [06:53:32.307]             }
  [06:53:32.307]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:32.307]         }
  [06:53:32.307]     }
  [06:53:32.307]     if (base::is.na(TRUE)) {
  [06:53:32.307]     }
  [06:53:32.307]     else {
  [06:53:32.307]         if (TRUE) {
  [06:53:32.307]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:32.307]                 open = "w")
  [06:53:32.307]         }
  [06:53:32.307]         else {
  [06:53:32.307]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:32.307]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:32.307]         }
  [06:53:32.307]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:32.307]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:32.307]             base::sink(type = "output", split = FALSE)
  [06:53:32.307]             base::close(...future.stdout)
  [06:53:32.307]         }, add = TRUE)
  [06:53:32.307]     }
  [06:53:32.307]     ...future.frame <- base::sys.nframe()
  [06:53:32.307]     ...future.conditions <- base::list()
  [06:53:32.307]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:32.307]     ...future.result <- base::tryCatch({
  [06:53:32.307]         base::withCallingHandlers({
  [06:53:32.307]             ...future.value <- base::withVisible(base::local({
  [06:53:32.307]                 doFuture::registerDoFuture()
  [06:53:32.307]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.307]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.307]                   i <- NULL
  [06:53:32.307]                   ...future.env <- environment()
  [06:53:32.307]                   local({
  [06:53:32.307]                     for (name in names(...future.x_jj)) {
  [06:53:32.307]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.307]                         inherits = FALSE)
  [06:53:32.307]                     }
  [06:53:32.307]                   })
  [06:53:32.307]                   tryCatch({
  [06:53:32.307]                     if (i%%2 == 0) 
  [06:53:32.307]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.307]                         i))
  [06:53:32.307]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:32.307]                   }, error = identity)
  [06:53:32.307]                 })
  [06:53:32.307]             }))
  [06:53:32.307]             future::FutureResult(value = ...future.value$value, 
  [06:53:32.307]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.307]                   ...future.rng), started = ...future.startTime, 
  [06:53:32.307]                 version = "1.8")
  [06:53:32.307]         }, condition = base::local({
  [06:53:32.307]             c <- base::c
  [06:53:32.307]             inherits <- base::inherits
  [06:53:32.307]             invokeRestart <- base::invokeRestart
  [06:53:32.307]             length <- base::length
  [06:53:32.307]             list <- base::list
  [06:53:32.307]             seq.int <- base::seq.int
  [06:53:32.307]             signalCondition <- base::signalCondition
  [06:53:32.307]             sys.calls <- base::sys.calls
  [06:53:32.307]             Sys.time <- base::Sys.time
  [06:53:32.307]             `[[` <- base::`[[`
  [06:53:32.307]             `+` <- base::`+`
  [06:53:32.307]             `<<-` <- base::`<<-`
  [06:53:32.307]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:32.307]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:32.307]                   3L)]
  [06:53:32.307]             }
  [06:53:32.307]             function(cond) {
  [06:53:32.307]                 if (inherits(cond, "error")) {
  [06:53:32.307]                   sessionInformation <- function() {
  [06:53:32.307]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:32.307]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:32.307]                       search = base::search(), system = base::Sys.info())
  [06:53:32.307]                   }
  [06:53:32.307]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.307]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:32.307]                     cond$call), session = sessionInformation(), 
  [06:53:32.307]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:32.307]                   signalCondition(cond)
  [06:53:32.307]                 }
  [06:53:32.307]                 else if (inherits(cond, "condition")) {
  [06:53:32.307]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:32.307]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.307]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:32.307]                   if (!signal) {
  [06:53:32.307]                     muffleCondition <- function (cond) 
  [06:53:32.307]                     {
  [06:53:32.307]                       inherits <- base::inherits
  [06:53:32.307]                       invokeRestart <- base::invokeRestart
  [06:53:32.307]                       muffled <- FALSE
  [06:53:32.307]                       if (inherits(cond, "message")) {
  [06:53:32.307]                         invokeRestart("muffleMessage")
  [06:53:32.307]                         muffled <- TRUE
  [06:53:32.307]                       }
  [06:53:32.307]                       else if (inherits(cond, "warning")) {
  [06:53:32.307]                         invokeRestart("muffleWarning")
  [06:53:32.307]                         muffled <- TRUE
  [06:53:32.307]                       }
  [06:53:32.307]                       else if (inherits(cond, "condition")) {
  [06:53:32.307]                         computeRestarts <- base::computeRestarts
  [06:53:32.307]                         grepl <- base::grepl
  [06:53:32.307]                         is.null <- base::is.null
  [06:53:32.307]                         restarts <- computeRestarts(cond)
  [06:53:32.307]                         for (restart in restarts) {
  [06:53:32.307]                           name <- restart$name
  [06:53:32.307]                           if (is.null(name)) 
  [06:53:32.307]                             next
  [06:53:32.307]                           if (!grepl("^muffle", name)) 
  [06:53:32.307]                             next
  [06:53:32.307]                           invokeRestart(restart)
  [06:53:32.307]                           muffled <- TRUE
  [06:53:32.307]                           break
  [06:53:32.307]                         }
  [06:53:32.307]                       }
  [06:53:32.307]                       invisible(muffled)
  [06:53:32.307]                     }
  [06:53:32.307]                     muffleCondition(cond)
  [06:53:32.307]                   }
  [06:53:32.307]                 }
  [06:53:32.307]             }
  [06:53:32.307]         }))
  [06:53:32.307]     }, error = function(ex) {
  [06:53:32.307]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:32.307]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.307]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:32.307]     }, finally = {
  [06:53:32.307]         {
  [06:53:32.307]             {
  [06:53:32.307]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:32.307]             }
  [06:53:32.307]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:32.307]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:32.307]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:32.307]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:32.307]             {
  [06:53:32.307]                 if (substitute) 
  [06:53:32.307]                   expr <- substitute(expr)
  [06:53:32.307]                 if (is.function(workers)) 
  [06:53:32.307]                   workers <- workers()
  [06:53:32.307]                 workers <- as.integer(workers)
  [06:53:32.307]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:32.307]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:32.307]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:32.307]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:32.307]                     local = TRUE, label = label, ...))
  [06:53:32.307]                 }
  [06:53:32.307]                 oopts <- options(mc.cores = workers)
  [06:53:32.307]                 on.exit(options(oopts))
  [06:53:32.307]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:32.307]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:32.307]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:32.307]                   label = label, ...)
  [06:53:32.307]                 if (!future$lazy) 
  [06:53:32.307]                   future <- run(future)
  [06:53:32.307]                 invisible(future)
  [06:53:32.307]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:32.307]         }
  [06:53:32.307]         base::options(...future.oldOptions)
  [06:53:32.307]     })
  [06:53:32.307]     Sys.time
  [06:53:32.307]     if (base::is.na(TRUE)) {
  [06:53:32.307]     }
  [06:53:32.307]     else {
  [06:53:32.307]         base::sink(type = "output", split = FALSE)
  [06:53:32.307]         if (TRUE) {
  [06:53:32.307]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:32.307]         }
  [06:53:32.307]         else {
  [06:53:32.307]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:32.307]         }
  [06:53:32.307]         base::close(...future.stdout)
  [06:53:32.307]         ...future.stdout <- NULL
  [06:53:32.307]     }
  [06:53:32.307]     ...future.result$conditions <- ...future.conditions
  [06:53:32.307]     ...future.result
  [06:53:32.307] }
  [06:53:32.312] requestCore(): workers = 2
  [06:53:32.317] MulticoreFuture started
  [06:53:32.319] Chunk #1 of 2 ... DONE
  [06:53:32.319] Chunk #2 of 2 ...
  [06:53:32.320]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:32.320] getGlobalsAndPackages() ...
  [06:53:32.321] Searching for globals...
  [06:53:32.323] 
  [06:53:32.324] Searching for globals ... DONE
  [06:53:32.324] - globals: [0] <none>
  [06:53:32.325] getGlobalsAndPackages() ... DONE
  [06:53:32.325] 
  [06:53:32.325] 
  [06:53:32.326]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:32.328] getGlobalsAndPackages() ...
  [06:53:32.329] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.330] Resolving globals: FALSE
  [06:53:32.332] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:32.332] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:32.332] plan(): Setting new future strategy stack:
  [06:53:32.333] 
  [06:53:32.333] getGlobalsAndPackages() ... DONE
  [06:53:32.333] List of future strategies:
  [06:53:32.333] 1. sequential:
  [06:53:32.333]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.333]    - tweaked: FALSE
  [06:53:32.333]    - call: NULL
  [06:53:32.335] plan(): nbrOfWorkers() = 1
  [06:53:32.337] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:32.338] Packages needed by future strategies (n = 0): <none>
  [06:53:32.351] plan(): Setting new future strategy stack:
  [06:53:32.347] {
  [06:53:32.347]     {
  [06:53:32.347]         ...future.startTime <- base::Sys.time()
  [06:53:32.347]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:32.347]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:32.347]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:32.347]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:32.347]             future.resolve.recursive = NULL, width = 80L)
  [06:53:32.347]         {
  [06:53:32.347]             {
  [06:53:32.347]                 {
  [06:53:32.347]                   {
  [06:53:32.347]                     base::local({
  [06:53:32.347]                       has_future <- base::requireNamespace("future", 
  [06:53:32.347]                         quietly = TRUE)
  [06:53:32.347]                       version <- if (has_future) 
  [06:53:32.347]                         utils::packageVersion("future")
  [06:53:32.347]                       else NULL
  [06:53:32.347]                       if (!has_future || version < "1.8.0") {
  [06:53:32.347]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:32.347]                           "", base::R.version$version.string), 
  [06:53:32.347]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:32.347]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:32.347]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:32.347]                             "release", "version")], collapse = " "), 
  [06:53:32.347]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:32.347]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:32.347]                           info)
  [06:53:32.347]                         info <- base::paste(info, collapse = "; ")
  [06:53:32.347]                         if (!has_future) {
  [06:53:32.347]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:32.347]                             info)
  [06:53:32.347]                         }
  [06:53:32.347]                         else {
  [06:53:32.347]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:32.347]                             info, version)
  [06:53:32.347]                         }
  [06:53:32.347]                         base::stop(msg)
  [06:53:32.347]                       }
  [06:53:32.347]                     })
  [06:53:32.347]                   }
  [06:53:32.347]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:32.347]                   base::options(mc.cores = 1L)
  [06:53:32.347]                 }
  [06:53:32.347]                 base::local({
  [06:53:32.347]                   for (pkg in c("doFuture", "stats")) {
  [06:53:32.347]                     base::loadNamespace(pkg)
  [06:53:32.347]                     base::library(pkg, character.only = TRUE)
  [06:53:32.347]                   }
  [06:53:32.347]                 })
  [06:53:32.347]             }
  [06:53:32.347]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:32.347]         }
  [06:53:32.347]     }
  [06:53:32.347]     if (base::is.na(TRUE)) {
  [06:53:32.347]     }
  [06:53:32.347]     else {
  [06:53:32.347]         if (TRUE) {
  [06:53:32.347]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:32.347]                 open = "w")
  [06:53:32.347]         }
  [06:53:32.347]         else {
  [06:53:32.347]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:32.347]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:32.347]         }
  [06:53:32.347]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:32.347]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:32.347]             base::sink(type = "output", split = FALSE)
  [06:53:32.347]             base::close(...future.stdout)
  [06:53:32.347]         }, add = TRUE)
  [06:53:32.347]     }
  [06:53:32.347]     ...future.frame <- base::sys.nframe()
  [06:53:32.347]     ...future.conditions <- base::list()
  [06:53:32.347]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:32.347]     ...future.result <- base::tryCatch({
  [06:53:32.347]         base::withCallingHandlers({
  [06:53:32.347]             ...future.value <- base::withVisible(base::local({
  [06:53:32.347]                 doFuture::registerDoFuture()
  [06:53:32.347]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:32.347]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:32.347]                   i <- NULL
  [06:53:32.347]                   ...future.env <- environment()
  [06:53:32.347]                   local({
  [06:53:32.347]                     for (name in names(...future.x_jj)) {
  [06:53:32.347]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:32.347]                         inherits = FALSE)
  [06:53:32.347]                     }
  [06:53:32.347]                   })
  [06:53:32.347]                   tryCatch({
  [06:53:32.347]                     if (i%%2 == 0) 
  [06:53:32.347]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:32.347]                         i))
  [06:53:32.347]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:32.347]                   }, error = identity)
  [06:53:32.347]                 })
  [06:53:32.347]             }))
  [06:53:32.347]             future::FutureResult(value = ...future.value$value, 
  [06:53:32.347]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.347]                   ...future.rng), started = ...future.startTime, 
  [06:53:32.347]                 version = "1.8")
  [06:53:32.347]         }, condition = base::local({
  [06:53:32.347]             c <- base::c
  [06:53:32.347]             inherits <- base::inherits
  [06:53:32.347]             invokeRestart <- base::invokeRestart
  [06:53:32.347]             length <- base::length
  [06:53:32.347]             list <- base::list
  [06:53:32.347]             seq.int <- base::seq.int
  [06:53:32.347]             signalCondition <- base::signalCondition
  [06:53:32.347]             sys.calls <- base::sys.calls
  [06:53:32.347]             Sys.time <- base::Sys.time
  [06:53:32.347]             `[[` <- base::`[[`
  [06:53:32.347]             `+` <- base::`+`
  [06:53:32.347]             `<<-` <- base::`<<-`
  [06:53:32.347]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:32.347]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:32.347]                   3L)]
  [06:53:32.347]             }
  [06:53:32.347]             function(cond) {
  [06:53:32.347]                 if (inherits(cond, "error")) {
  [06:53:32.347]                   sessionInformation <- function() {
  [06:53:32.347]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:32.347]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:32.347]                       search = base::search(), system = base::Sys.info())
  [06:53:32.347]                   }
  [06:53:32.347]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.347]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:32.347]                     cond$call), session = sessionInformation(), 
  [06:53:32.347]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:32.347]                   signalCondition(cond)
  [06:53:32.347]                 }
  [06:53:32.347]                 else if (inherits(cond, "condition")) {
  [06:53:32.347]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:32.347]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:32.347]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:32.347]                   if (!signal) {
  [06:53:32.347]                     muffleCondition <- function (cond) 
  [06:53:32.347]                     {
  [06:53:32.347]                       inherits <- base::inherits
  [06:53:32.347]                       invokeRestart <- base::invokeRestart
  [06:53:32.347]                       muffled <- FALSE
  [06:53:32.347]                       if (inherits(cond, "message")) {
  [06:53:32.347]                         invokeRestart("muffleMessage")
  [06:53:32.347]                         muffled <- TRUE
  [06:53:32.347]                       }
  [06:53:32.347]                       else if (inherits(cond, "warning")) {
  [06:53:32.347]                         invokeRestart("muffleWarning")
  [06:53:32.347]                         muffled <- TRUE
  [06:53:32.347]                       }
  [06:53:32.347]                       else if (inherits(cond, "condition")) {
  [06:53:32.347]                         computeRestarts <- base::computeRestarts
  [06:53:32.347]                         grepl <- base::grepl
  [06:53:32.347]                         is.null <- base::is.null
  [06:53:32.347]                         restarts <- computeRestarts(cond)
  [06:53:32.347]                         for (restart in restarts) {
  [06:53:32.347]                           name <- restart$name
  [06:53:32.347]                           if (is.null(name)) 
  [06:53:32.347]                             next
  [06:53:32.347]                           if (!grepl("^muffle", name)) 
  [06:53:32.347]                             next
  [06:53:32.347]                           invokeRestart(restart)
  [06:53:32.347]                           muffled <- TRUE
  [06:53:32.347]                           break
  [06:53:32.347]                         }
  [06:53:32.347]                       }
  [06:53:32.347]                       invisible(muffled)
  [06:53:32.347]                     }
  [06:53:32.347]                     muffleCondition(cond)
  [06:53:32.347]                   }
  [06:53:32.347]                 }
  [06:53:32.347]             }
  [06:53:32.347]         }))
  [06:53:32.347]     }, error = function(ex) {
  [06:53:32.347]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:32.347]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:32.347]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:32.347]     }, finally = {
  [06:53:32.347]         {
  [06:53:32.347]             {
  [06:53:32.347]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:32.347]             }
  [06:53:32.347]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:32.347]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:32.347]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:32.347]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:32.347]             {
  [06:53:32.347]                 if (substitute) 
  [06:53:32.347]                   expr <- substitute(expr)
  [06:53:32.347]                 if (is.function(workers)) 
  [06:53:32.347]                   workers <- workers()
  [06:53:32.347]                 workers <- as.integer(workers)
  [06:53:32.347]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:32.347]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:32.347]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:32.347]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:32.347]                     local = TRUE, label = label, ...))
  [06:53:32.347]                 }
  [06:53:32.347]                 oopts <- options(mc.cores = workers)
  [06:53:32.347]                 on.exit(options(oopts))
  [06:53:32.347]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:32.347]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:32.347]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:32.347]                   label = label, ...)
  [06:53:32.347]                 if (!future$lazy) 
  [06:53:32.347]                   future <- run(future)
  [06:53:32.347]                 invisible(future)
  [06:53:32.347]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:32.347]         }
  [06:53:32.347]         base::options(...future.oldOptions)
  [06:53:32.347]     })
  [06:53:32.347]     Sys.time
  [06:53:32.347]     if (base::is.na(TRUE)) {
  [06:53:32.347]     }
  [06:53:32.347]     else {
  [06:53:32.347]         base::sink(type = "output", split = FALSE)
  [06:53:32.347]         if (TRUE) {
  [06:53:32.347]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:32.347]         }
  [06:53:32.347]         else {
  [06:53:32.347]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:32.347]         }
  [06:53:32.347]         base::close(...future.stdout)
  [06:53:32.347]         ...future.stdout <- NULL
  [06:53:32.347]     }
  [06:53:32.347]     ...future.result$conditions <- ...future.conditions
  [06:53:32.347]     ...future.result
  [06:53:32.347] }
  [06:53:32.352] List of future strategies:
  [06:53:32.352] 1. multicore:
  [06:53:32.352]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:32.352]    - tweaked: FALSE
  [06:53:32.352]    - call: plan(strategy)
  [06:53:32.353] requestCore(): workers = 2
  [06:53:32.354] plan(): nbrOfWorkers() = 2
  [06:53:32.366] MulticoreFuture started
  [06:53:32.368] Chunk #2 of 2 ... DONE
  [06:53:32.368] Launching 2 futures (chunks) ... DONE
  [06:53:32.369] - resolving futures
  [06:53:32.377]   - gathering results & relaying conditions (except errors)
  [06:53:32.378] resolve() on list ...
  [06:53:32.379]  recursive: 0
  [06:53:32.379]  length: 2
  [06:53:32.380] 
  [06:53:32.384] Future #1
  [06:53:32.388] plan(): Setting new future strategy stack:
  [06:53:32.389] List of future strategies:
  [06:53:32.389] 1. sequential:
  [06:53:32.389]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.389]    - tweaked: FALSE
  [06:53:32.389]    - call: NULL
  [06:53:32.391] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [06:53:32.391] plan(): nbrOfWorkers() = 1
  [06:53:32.391] - nx: 2
  [06:53:32.392] - relay: TRUE
  [06:53:32.392] - stdout: TRUE
  [06:53:32.393] - signal: TRUE
  [06:53:32.393] - resignal: FALSE
  [06:53:32.393] - force: FALSE
  [06:53:32.394] - relayed: [n=2] FALSE, FALSE
  [06:53:32.394] - queued futures: [n=2] FALSE, FALSE
  [06:53:32.395] plan(): Setting new future strategy stack:
  [06:53:32.395]  - until=1
  [06:53:32.395]  - relaying element #1
  [06:53:32.396] - relayed: [n=2] TRUE, FALSE
  [06:53:32.395] List of future strategies:
  [06:53:32.395] 1. multicore:
  [06:53:32.395]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:32.395]    - tweaked: FALSE
  [06:53:32.395]    - call: plan(strategy)
  [06:53:32.396] - queued futures: [n=2] TRUE, FALSE
  [06:53:32.397] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [06:53:32.397]  length: 1 (resolved future 1)
  [06:53:32.397] plan(): nbrOfWorkers() = 2
  [06:53:32.399] Future #2
  [06:53:32.401] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [06:53:32.401] - nx: 2
  [06:53:32.402] - relay: TRUE
  [06:53:32.402] - stdout: TRUE
  [06:53:32.403] - signal: TRUE
  [06:53:32.403] - resignal: FALSE
  [06:53:32.403] - force: FALSE
  [06:53:32.404] - relayed: [n=2] TRUE, FALSE
  [06:53:32.404] - queued futures: [n=2] TRUE, FALSE
  [06:53:32.405]  - until=2
  [06:53:32.405]  - relaying element #2
  [06:53:32.406] - relayed: [n=2] TRUE, TRUE
  [06:53:32.406] - queued futures: [n=2] TRUE, TRUE
  [06:53:32.407] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [06:53:32.407]  length: 0 (resolved future 2)
  [06:53:32.408] Relaying remaining futures
  [06:53:32.408] signalConditionsASAP(NULL, pos=0) ...
  [06:53:32.408] - nx: 2
  [06:53:32.409] - relay: TRUE
  [06:53:32.409] - stdout: TRUE
  [06:53:32.410] - signal: TRUE
  [06:53:32.410] - resignal: FALSE
  [06:53:32.410] - force: FALSE
  [06:53:32.411] - relayed: [n=2] TRUE, TRUE
  [06:53:32.411] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:32.412] - relayed: [n=2] TRUE, TRUE
  [06:53:32.412] - queued futures: [n=2] TRUE, TRUE
  [06:53:32.412] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:32.413] resolve() on list ... DONE
  [06:53:32.413] - collecting values of futures
  [06:53:32.414] - accumulating results
  [06:53:32.421] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('multicore') ... DONE
  - plan('multisession') ...
  [06:53:32.423] plan(): Setting new future strategy stack:
  [06:53:32.424] List of future strategies:
  [06:53:32.424] 1. multisession:
  [06:53:32.424]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.424]    - tweaked: FALSE
  [06:53:32.424]    - call: plan(strategy)
  [06:53:32.425] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:32.425] multisession:
  [06:53:32.425] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:32.425] - tweaked: FALSE
  [06:53:32.425] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 37351
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75896952d9ce.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.75896952d9ce.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75896952d9ce.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37351 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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758962a7468b.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.758962a7468b.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758962a7468b.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37351 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [06:53:34.929] getGlobalsAndPackages() ...
  [06:53:34.930] Not searching for globals
  [06:53:34.931] - globals: [0] <none>
  [06:53:34.931] getGlobalsAndPackages() ... DONE
  [06:53:34.937] Packages needed by the future expression (n = 0): <none>
  [06:53:34.937] Packages needed by future strategies (n = 0): <none>
  [06:53:34.944] {
  [06:53:34.944]     {
  [06:53:34.944]         ...future.startTime <- base::Sys.time()
  [06:53:34.944]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:34.944]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:34.944]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:34.944]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:34.944]             future.resolve.recursive = NULL, width = 80L)
  [06:53:34.944]         {
  [06:53:34.944]             {
  [06:53:34.944]                 {
  [06:53:34.944]                   base::local({
  [06:53:34.944]                     has_future <- base::requireNamespace("future", 
  [06:53:34.944]                       quietly = TRUE)
  [06:53:34.944]                     version <- if (has_future) 
  [06:53:34.944]                       utils::packageVersion("future")
  [06:53:34.944]                     else NULL
  [06:53:34.944]                     if (!has_future || version < "1.8.0") {
  [06:53:34.944]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:34.944]                         "", base::R.version$version.string), 
  [06:53:34.944]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:34.944]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:34.944]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:34.944]                           "release", "version")], collapse = " "), 
  [06:53:34.944]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:34.944]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:34.944]                         info)
  [06:53:34.944]                       info <- base::paste(info, collapse = "; ")
  [06:53:34.944]                       if (!has_future) {
  [06:53:34.944]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:34.944]                           info)
  [06:53:34.944]                       }
  [06:53:34.944]                       else {
  [06:53:34.944]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:34.944]                           info, version)
  [06:53:34.944]                       }
  [06:53:34.944]                       base::stop(msg)
  [06:53:34.944]                     }
  [06:53:34.944]                   })
  [06:53:34.944]                 }
  [06:53:34.944]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:34.944]                 base::options(mc.cores = 1L)
  [06:53:34.944]             }
  [06:53:34.944]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:34.944]         }
  [06:53:34.944]     }
  [06:53:34.944]     if (base::is.na(TRUE)) {
  [06:53:34.944]     }
  [06:53:34.944]     else {
  [06:53:34.944]         if (TRUE) {
  [06:53:34.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:34.944]                 open = "w")
  [06:53:34.944]         }
  [06:53:34.944]         else {
  [06:53:34.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:34.944]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:34.944]         }
  [06:53:34.944]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:34.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:34.944]             base::sink(type = "output", split = FALSE)
  [06:53:34.944]             base::close(...future.stdout)
  [06:53:34.944]         }, add = TRUE)
  [06:53:34.944]     }
  [06:53:34.944]     ...future.frame <- base::sys.nframe()
  [06:53:34.944]     ...future.conditions <- base::list()
  [06:53:34.944]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:34.944]     ...future.result <- base::tryCatch({
  [06:53:34.944]         base::withCallingHandlers({
  [06:53:34.944]             ...future.value <- base::withVisible(base::local({
  [06:53:34.944]                 ...future.sendCondition <- local({
  [06:53:34.944]                   sendCondition <- NULL
  [06:53:34.944]                   function(frame = 1L) {
  [06:53:34.944]                     if (is.function(sendCondition)) 
  [06:53:34.944]                       return(sendCondition)
  [06:53:34.944]                     ns <- getNamespace("parallel")
  [06:53:34.944]                     if (exists("sendData", mode = "function", 
  [06:53:34.944]                       envir = ns)) {
  [06:53:34.944]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:34.944]                         envir = ns)
  [06:53:34.944]                       envir <- sys.frame(frame)
  [06:53:34.944]                       master <- NULL
  [06:53:34.944]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:34.944]                         !identical(envir, emptyenv())) {
  [06:53:34.944]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:34.944]                           inherits = FALSE)) {
  [06:53:34.944]                           master <- get("master", mode = "list", 
  [06:53:34.944]                             envir = envir, inherits = FALSE)
  [06:53:34.944]                           if (inherits(master, "SOCKnode")) {
  [06:53:34.944]                             sendCondition <<- function(cond) {
  [06:53:34.944]                               data <- list(type = "VALUE", value = cond, 
  [06:53:34.944]                                 success = TRUE)
  [06:53:34.944]                               parallel_sendData(master, data)
  [06:53:34.944]                             }
  [06:53:34.944]                             return(sendCondition)
  [06:53:34.944]                           }
  [06:53:34.944]                         }
  [06:53:34.944]                         frame <- frame + 1L
  [06:53:34.944]                         envir <- sys.frame(frame)
  [06:53:34.944]                       }
  [06:53:34.944]                     }
  [06:53:34.944]                     sendCondition <<- function(cond) NULL
  [06:53:34.944]                   }
  [06:53:34.944]                 })
  [06:53:34.944]                 withCallingHandlers({
  [06:53:34.944]                   NA
  [06:53:34.944]                 }, immediateCondition = function(cond) {
  [06:53:34.944]                   sendCondition <- ...future.sendCondition()
  [06:53:34.944]                   sendCondition(cond)
  [06:53:34.944]                   muffleCondition <- function (cond) 
  [06:53:34.944]                   {
  [06:53:34.944]                     inherits <- base::inherits
  [06:53:34.944]                     invokeRestart <- base::invokeRestart
  [06:53:34.944]                     muffled <- FALSE
  [06:53:34.944]                     if (inherits(cond, "message")) {
  [06:53:34.944]                       invokeRestart("muffleMessage")
  [06:53:34.944]                       muffled <- TRUE
  [06:53:34.944]                     }
  [06:53:34.944]                     else if (inherits(cond, "warning")) {
  [06:53:34.944]                       invokeRestart("muffleWarning")
  [06:53:34.944]                       muffled <- TRUE
  [06:53:34.944]                     }
  [06:53:34.944]                     else if (inherits(cond, "condition")) {
  [06:53:34.944]                       computeRestarts <- base::computeRestarts
  [06:53:34.944]                       grepl <- base::grepl
  [06:53:34.944]                       is.null <- base::is.null
  [06:53:34.944]                       restarts <- computeRestarts(cond)
  [06:53:34.944]                       for (restart in restarts) {
  [06:53:34.944]                         name <- restart$name
  [06:53:34.944]                         if (is.null(name)) 
  [06:53:34.944]                           next
  [06:53:34.944]                         if (!grepl("^muffle", name)) 
  [06:53:34.944]                           next
  [06:53:34.944]                         invokeRestart(restart)
  [06:53:34.944]                         muffled <- TRUE
  [06:53:34.944]                         break
  [06:53:34.944]                       }
  [06:53:34.944]                     }
  [06:53:34.944]                     invisible(muffled)
  [06:53:34.944]                   }
  [06:53:34.944]                   muffleCondition(cond)
  [06:53:34.944]                 })
  [06:53:34.944]             }))
  [06:53:34.944]             future::FutureResult(value = ...future.value$value, 
  [06:53:34.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:34.944]                   ...future.rng), started = ...future.startTime, 
  [06:53:34.944]                 version = "1.8")
  [06:53:34.944]         }, condition = base::local({
  [06:53:34.944]             c <- base::c
  [06:53:34.944]             inherits <- base::inherits
  [06:53:34.944]             invokeRestart <- base::invokeRestart
  [06:53:34.944]             length <- base::length
  [06:53:34.944]             list <- base::list
  [06:53:34.944]             seq.int <- base::seq.int
  [06:53:34.944]             signalCondition <- base::signalCondition
  [06:53:34.944]             sys.calls <- base::sys.calls
  [06:53:34.944]             Sys.time <- base::Sys.time
  [06:53:34.944]             `[[` <- base::`[[`
  [06:53:34.944]             `+` <- base::`+`
  [06:53:34.944]             `<<-` <- base::`<<-`
  [06:53:34.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:34.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:34.944]                   3L)]
  [06:53:34.944]             }
  [06:53:34.944]             function(cond) {
  [06:53:34.944]                 if (inherits(cond, "error")) {
  [06:53:34.944]                   sessionInformation <- function() {
  [06:53:34.944]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:34.944]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:34.944]                       search = base::search(), system = base::Sys.info())
  [06:53:34.944]                   }
  [06:53:34.944]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:34.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:34.944]                     cond$call), session = sessionInformation(), 
  [06:53:34.944]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:34.944]                   signalCondition(cond)
  [06:53:34.944]                 }
  [06:53:34.944]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:34.944]                 ))) {
  [06:53:34.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:34.944]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:34.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:34.944]                   if (!signal) {
  [06:53:34.944]                     muffleCondition <- function (cond) 
  [06:53:34.944]                     {
  [06:53:34.944]                       inherits <- base::inherits
  [06:53:34.944]                       invokeRestart <- base::invokeRestart
  [06:53:34.944]                       muffled <- FALSE
  [06:53:34.944]                       if (inherits(cond, "message")) {
  [06:53:34.944]                         invokeRestart("muffleMessage")
  [06:53:34.944]                         muffled <- TRUE
  [06:53:34.944]                       }
  [06:53:34.944]                       else if (inherits(cond, "warning")) {
  [06:53:34.944]                         invokeRestart("muffleWarning")
  [06:53:34.944]                         muffled <- TRUE
  [06:53:34.944]                       }
  [06:53:34.944]                       else if (inherits(cond, "condition")) {
  [06:53:34.944]                         computeRestarts <- base::computeRestarts
  [06:53:34.944]                         grepl <- base::grepl
  [06:53:34.944]                         is.null <- base::is.null
  [06:53:34.944]                         restarts <- computeRestarts(cond)
  [06:53:34.944]                         for (restart in restarts) {
  [06:53:34.944]                           name <- restart$name
  [06:53:34.944]                           if (is.null(name)) 
  [06:53:34.944]                             next
  [06:53:34.944]                           if (!grepl("^muffle", name)) 
  [06:53:34.944]                             next
  [06:53:34.944]                           invokeRestart(restart)
  [06:53:34.944]                           muffled <- TRUE
  [06:53:34.944]                           break
  [06:53:34.944]                         }
  [06:53:34.944]                       }
  [06:53:34.944]                       invisible(muffled)
  [06:53:34.944]                     }
  [06:53:34.944]                     muffleCondition(cond)
  [06:53:34.944]                   }
  [06:53:34.944]                 }
  [06:53:34.944]             }
  [06:53:34.944]         }))
  [06:53:34.944]     }, error = function(ex) {
  [06:53:34.944]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:34.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:34.944]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:34.944]     }, finally = {
  [06:53:34.944]         {
  [06:53:34.944]             {
  [06:53:34.944]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:34.944]             }
  [06:53:34.944]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:34.944]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:34.944]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:34.944]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:34.944]                 ...) 
  [06:53:34.944]             {
  [06:53:34.944]                 if (substitute) 
  [06:53:34.944]                   expr <- substitute(expr)
  [06:53:34.944]                 if (is.function(workers)) 
  [06:53:34.944]                   workers <- workers()
  [06:53:34.944]                 workers <- as.integer(workers)
  [06:53:34.944]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:34.944]                   workers >= 1)
  [06:53:34.944]                 if (workers == 1L) {
  [06:53:34.944]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:34.944]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:34.944]                     local = TRUE, label = label, ...))
  [06:53:34.944]                 }
  [06:53:34.944]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:34.944]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:34.944]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:34.944]                   globals = globals, persistent = persistent, 
  [06:53:34.944]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:34.944]                   label = label, ...)
  [06:53:34.944]                 if (!future$lazy) 
  [06:53:34.944]                   future <- run(future)
  [06:53:34.944]                 invisible(future)
  [06:53:34.944]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:34.944]         }
  [06:53:34.944]         base::options(...future.oldOptions)
  [06:53:34.944]     })
  [06:53:34.944]     Sys.time
  [06:53:34.944]     if (base::is.na(TRUE)) {
  [06:53:34.944]     }
  [06:53:34.944]     else {
  [06:53:34.944]         base::sink(type = "output", split = FALSE)
  [06:53:34.944]         if (TRUE) {
  [06:53:34.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:34.944]         }
  [06:53:34.944]         else {
  [06:53:34.944]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:34.944]         }
  [06:53:34.944]         base::close(...future.stdout)
  [06:53:34.944]         ...future.stdout <- NULL
  [06:53:34.944]     }
  [06:53:34.944]     ...future.result$conditions <- ...future.conditions
  [06:53:34.944]     ...future.result
  [06:53:34.944] }
  [06:53:34.959] MultisessionFuture started
  [06:53:34.960] result() for ClusterFuture ...
  [06:53:34.961] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:34.961] - Validating connection of MultisessionFuture
  [06:53:35.093] - received message: FutureResult
  [06:53:35.094] - Received FutureResult
  [06:53:35.094] - Erased future from FutureRegistry
  [06:53:35.094] result() for ClusterFuture ...
  [06:53:35.095] - result already collected: FutureResult
  [06:53:35.095] result() for ClusterFuture ... done
  [06:53:35.096] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:35.096] result() for ClusterFuture ... done
  [06:53:35.096] result() for ClusterFuture ...
  [06:53:35.097] - result already collected: FutureResult
  [06:53:35.097] result() for ClusterFuture ... done
  [06:53:35.097] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [06:53:35.099] plan(): nbrOfWorkers() = 2
  [06:53:35.099] doFuture() ...
  [06:53:35.102] - dummy globals (as locals): [1] 'i'
  [06:53:35.103] - R expression:
  [06:53:35.103] {
  [06:53:35.103]     doFuture::registerDoFuture()
  [06:53:35.103]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:35.103]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:35.103]         i <- NULL
  [06:53:35.103]         ...future.env <- environment()
  [06:53:35.103]         local({
  [06:53:35.103]             for (name in names(...future.x_jj)) {
  [06:53:35.103]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:35.103]                   inherits = FALSE)
  [06:53:35.103]             }
  [06:53:35.103]         })
  [06:53:35.103]         tryCatch({
  [06:53:35.103]             if (i%%2 == 0) 
  [06:53:35.103]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:35.103]                   i))
  [06:53:35.103]             dnorm(i, mean = mu, sd = sigma)
  [06:53:35.103]         }, error = identity)
  [06:53:35.103]     })
  [06:53:35.103] }
  [06:53:35.104] - identifying globals and packages ...
  [06:53:35.105] getGlobalsAndPackages() ...
  [06:53:35.105] Searching for globals...
  [06:53:35.128] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:35.129] Searching for globals ... DONE
  [06:53:35.129] Resolving globals: FALSE
  [06:53:35.131] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:35.132] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.132] - packages: [1] 'stats'
  [06:53:35.133] getGlobalsAndPackages() ... DONE
  [06:53:35.133] List of 3
  [06:53:35.133]  $ ...future.x_ii: NULL
  [06:53:35.133]  $ mu            : num 1
  [06:53:35.133]  $ sigma         : num 2
  [06:53:35.133]  - attr(*, "where")=List of 3
  [06:53:35.133]   ..$ ...future.x_ii:<environment: 0x557600f853f8> 
  [06:53:35.133]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:35.133]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:35.133]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:35.133]  - attr(*, "resolved")= logi FALSE
  [06:53:35.133]  - attr(*, "total_size")= num 112
  [06:53:35.145]   - R expression:
  [06:53:35.145] {
  [06:53:35.145]     doFuture::registerDoFuture()
  [06:53:35.145]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:35.145]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:35.145]         i <- NULL
  [06:53:35.145]         ...future.env <- environment()
  [06:53:35.145]         local({
  [06:53:35.145]             for (name in names(...future.x_jj)) {
  [06:53:35.145]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:35.145]                   inherits = FALSE)
  [06:53:35.145]             }
  [06:53:35.145]         })
  [06:53:35.145]         tryCatch({
  [06:53:35.145]             if (i%%2 == 0) 
  [06:53:35.145]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:35.145]                   i))
  [06:53:35.145]             dnorm(i, mean = mu, sd = sigma)
  [06:53:35.145]         }, error = identity)
  [06:53:35.145]     })
  [06:53:35.145] }
  [06:53:35.146]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.146] List of 3
  [06:53:35.146]  $ ...future.x_ii: NULL
  [06:53:35.146]  $ mu            : num 1
  [06:53:35.146]  $ sigma         : num 2
  [06:53:35.146]  - attr(*, "where")=List of 3
  [06:53:35.146]   ..$ ...future.x_ii:<environment: 0x557600f853f8> 
  [06:53:35.146]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:35.146]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:35.146]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:35.146]  - attr(*, "resolved")= logi FALSE
  [06:53:35.146]  - attr(*, "total_size")= num 112
  [06:53:35.157]   - packages: [2] 'doFuture', 'stats'
  [06:53:35.166] - identifying globals and packages ... DONE
  [06:53:35.167] Number of chunks: 2
  [06:53:35.167] Number of futures (= number of chunks): 2
  [06:53:35.168] Launching 2 futures (chunks) ...
  [06:53:35.169] Chunk #1 of 2 ...
  [06:53:35.169]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:35.169] getGlobalsAndPackages() ...
  [06:53:35.170] Searching for globals...
  [06:53:35.171] 
  [06:53:35.171] Searching for globals ... DONE
  [06:53:35.172] - globals: [0] <none>
  [06:53:35.172] getGlobalsAndPackages() ... DONE
  [06:53:35.172] 
  [06:53:35.173] 
  [06:53:35.173]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:35.174] getGlobalsAndPackages() ...
  [06:53:35.175] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.175] Resolving globals: FALSE
  [06:53:35.177] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:35.177] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.180] 
  [06:53:35.181] getGlobalsAndPackages() ... DONE
  [06:53:35.185] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:35.185] Packages needed by future strategies (n = 0): <none>
  [06:53:35.191] {
  [06:53:35.191]     {
  [06:53:35.191]         ...future.startTime <- base::Sys.time()
  [06:53:35.191]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:35.191]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:35.191]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:35.191]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:35.191]             future.resolve.recursive = NULL, width = 80L)
  [06:53:35.191]         {
  [06:53:35.191]             {
  [06:53:35.191]                 {
  [06:53:35.191]                   {
  [06:53:35.191]                     base::local({
  [06:53:35.191]                       has_future <- base::requireNamespace("future", 
  [06:53:35.191]                         quietly = TRUE)
  [06:53:35.191]                       version <- if (has_future) 
  [06:53:35.191]                         utils::packageVersion("future")
  [06:53:35.191]                       else NULL
  [06:53:35.191]                       if (!has_future || version < "1.8.0") {
  [06:53:35.191]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:35.191]                           "", base::R.version$version.string), 
  [06:53:35.191]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:35.191]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:35.191]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:35.191]                             "release", "version")], collapse = " "), 
  [06:53:35.191]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:35.191]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:35.191]                           info)
  [06:53:35.191]                         info <- base::paste(info, collapse = "; ")
  [06:53:35.191]                         if (!has_future) {
  [06:53:35.191]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:35.191]                             info)
  [06:53:35.191]                         }
  [06:53:35.191]                         else {
  [06:53:35.191]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:35.191]                             info, version)
  [06:53:35.191]                         }
  [06:53:35.191]                         base::stop(msg)
  [06:53:35.191]                       }
  [06:53:35.191]                     })
  [06:53:35.191]                   }
  [06:53:35.191]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:35.191]                   base::options(mc.cores = 1L)
  [06:53:35.191]                 }
  [06:53:35.191]                 base::local({
  [06:53:35.191]                   for (pkg in c("doFuture", "stats")) {
  [06:53:35.191]                     base::loadNamespace(pkg)
  [06:53:35.191]                     base::library(pkg, character.only = TRUE)
  [06:53:35.191]                   }
  [06:53:35.191]                 })
  [06:53:35.191]             }
  [06:53:35.191]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:35.191]         }
  [06:53:35.191]     }
  [06:53:35.191]     if (base::is.na(TRUE)) {
  [06:53:35.191]     }
  [06:53:35.191]     else {
  [06:53:35.191]         if (TRUE) {
  [06:53:35.191]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:35.191]                 open = "w")
  [06:53:35.191]         }
  [06:53:35.191]         else {
  [06:53:35.191]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:35.191]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:35.191]         }
  [06:53:35.191]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:35.191]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:35.191]             base::sink(type = "output", split = FALSE)
  [06:53:35.191]             base::close(...future.stdout)
  [06:53:35.191]         }, add = TRUE)
  [06:53:35.191]     }
  [06:53:35.191]     ...future.frame <- base::sys.nframe()
  [06:53:35.191]     ...future.conditions <- base::list()
  [06:53:35.191]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:35.191]     ...future.result <- base::tryCatch({
  [06:53:35.191]         base::withCallingHandlers({
  [06:53:35.191]             ...future.value <- base::withVisible(base::local({
  [06:53:35.191]                 ...future.sendCondition <- local({
  [06:53:35.191]                   sendCondition <- NULL
  [06:53:35.191]                   function(frame = 1L) {
  [06:53:35.191]                     if (is.function(sendCondition)) 
  [06:53:35.191]                       return(sendCondition)
  [06:53:35.191]                     ns <- getNamespace("parallel")
  [06:53:35.191]                     if (exists("sendData", mode = "function", 
  [06:53:35.191]                       envir = ns)) {
  [06:53:35.191]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:35.191]                         envir = ns)
  [06:53:35.191]                       envir <- sys.frame(frame)
  [06:53:35.191]                       master <- NULL
  [06:53:35.191]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:35.191]                         !identical(envir, emptyenv())) {
  [06:53:35.191]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:35.191]                           inherits = FALSE)) {
  [06:53:35.191]                           master <- get("master", mode = "list", 
  [06:53:35.191]                             envir = envir, inherits = FALSE)
  [06:53:35.191]                           if (inherits(master, "SOCKnode")) {
  [06:53:35.191]                             sendCondition <<- function(cond) {
  [06:53:35.191]                               data <- list(type = "VALUE", value = cond, 
  [06:53:35.191]                                 success = TRUE)
  [06:53:35.191]                               parallel_sendData(master, data)
  [06:53:35.191]                             }
  [06:53:35.191]                             return(sendCondition)
  [06:53:35.191]                           }
  [06:53:35.191]                         }
  [06:53:35.191]                         frame <- frame + 1L
  [06:53:35.191]                         envir <- sys.frame(frame)
  [06:53:35.191]                       }
  [06:53:35.191]                     }
  [06:53:35.191]                     sendCondition <<- function(cond) NULL
  [06:53:35.191]                   }
  [06:53:35.191]                 })
  [06:53:35.191]                 withCallingHandlers({
  [06:53:35.191]                   {
  [06:53:35.191]                     doFuture::registerDoFuture()
  [06:53:35.191]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:35.191]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:35.191]                       i <- NULL
  [06:53:35.191]                       ...future.env <- environment()
  [06:53:35.191]                       local({
  [06:53:35.191]                         for (name in names(...future.x_jj)) {
  [06:53:35.191]                           assign(name, ...future.x_jj[[name]], 
  [06:53:35.191]                             envir = ...future.env, inherits = FALSE)
  [06:53:35.191]                         }
  [06:53:35.191]                       })
  [06:53:35.191]                       tryCatch({
  [06:53:35.191]                         if (i%%2 == 0) 
  [06:53:35.191]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:35.191]                             i))
  [06:53:35.191]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:35.191]                       }, error = identity)
  [06:53:35.191]                     })
  [06:53:35.191]                   }
  [06:53:35.191]                 }, immediateCondition = function(cond) {
  [06:53:35.191]                   sendCondition <- ...future.sendCondition()
  [06:53:35.191]                   sendCondition(cond)
  [06:53:35.191]                   muffleCondition <- function (cond) 
  [06:53:35.191]                   {
  [06:53:35.191]                     inherits <- base::inherits
  [06:53:35.191]                     invokeRestart <- base::invokeRestart
  [06:53:35.191]                     muffled <- FALSE
  [06:53:35.191]                     if (inherits(cond, "message")) {
  [06:53:35.191]                       invokeRestart("muffleMessage")
  [06:53:35.191]                       muffled <- TRUE
  [06:53:35.191]                     }
  [06:53:35.191]                     else if (inherits(cond, "warning")) {
  [06:53:35.191]                       invokeRestart("muffleWarning")
  [06:53:35.191]                       muffled <- TRUE
  [06:53:35.191]                     }
  [06:53:35.191]                     else if (inherits(cond, "condition")) {
  [06:53:35.191]                       computeRestarts <- base::computeRestarts
  [06:53:35.191]                       grepl <- base::grepl
  [06:53:35.191]                       is.null <- base::is.null
  [06:53:35.191]                       restarts <- computeRestarts(cond)
  [06:53:35.191]                       for (restart in restarts) {
  [06:53:35.191]                         name <- restart$name
  [06:53:35.191]                         if (is.null(name)) 
  [06:53:35.191]                           next
  [06:53:35.191]                         if (!grepl("^muffle", name)) 
  [06:53:35.191]                           next
  [06:53:35.191]                         invokeRestart(restart)
  [06:53:35.191]                         muffled <- TRUE
  [06:53:35.191]                         break
  [06:53:35.191]                       }
  [06:53:35.191]                     }
  [06:53:35.191]                     invisible(muffled)
  [06:53:35.191]                   }
  [06:53:35.191]                   muffleCondition(cond)
  [06:53:35.191]                 })
  [06:53:35.191]             }))
  [06:53:35.191]             future::FutureResult(value = ...future.value$value, 
  [06:53:35.191]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:35.191]                   ...future.rng), started = ...future.startTime, 
  [06:53:35.191]                 version = "1.8")
  [06:53:35.191]         }, condition = base::local({
  [06:53:35.191]             c <- base::c
  [06:53:35.191]             inherits <- base::inherits
  [06:53:35.191]             invokeRestart <- base::invokeRestart
  [06:53:35.191]             length <- base::length
  [06:53:35.191]             list <- base::list
  [06:53:35.191]             seq.int <- base::seq.int
  [06:53:35.191]             signalCondition <- base::signalCondition
  [06:53:35.191]             sys.calls <- base::sys.calls
  [06:53:35.191]             Sys.time <- base::Sys.time
  [06:53:35.191]             `[[` <- base::`[[`
  [06:53:35.191]             `+` <- base::`+`
  [06:53:35.191]             `<<-` <- base::`<<-`
  [06:53:35.191]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:35.191]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:35.191]                   3L)]
  [06:53:35.191]             }
  [06:53:35.191]             function(cond) {
  [06:53:35.191]                 if (inherits(cond, "error")) {
  [06:53:35.191]                   sessionInformation <- function() {
  [06:53:35.191]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:35.191]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:35.191]                       search = base::search(), system = base::Sys.info())
  [06:53:35.191]                   }
  [06:53:35.191]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:35.191]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:35.191]                     cond$call), session = sessionInformation(), 
  [06:53:35.191]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:35.191]                   signalCondition(cond)
  [06:53:35.191]                 }
  [06:53:35.191]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:35.191]                 ))) {
  [06:53:35.191]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:35.191]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:35.191]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:35.191]                   if (!signal) {
  [06:53:35.191]                     muffleCondition <- function (cond) 
  [06:53:35.191]                     {
  [06:53:35.191]                       inherits <- base::inherits
  [06:53:35.191]                       invokeRestart <- base::invokeRestart
  [06:53:35.191]                       muffled <- FALSE
  [06:53:35.191]                       if (inherits(cond, "message")) {
  [06:53:35.191]                         invokeRestart("muffleMessage")
  [06:53:35.191]                         muffled <- TRUE
  [06:53:35.191]                       }
  [06:53:35.191]                       else if (inherits(cond, "warning")) {
  [06:53:35.191]                         invokeRestart("muffleWarning")
  [06:53:35.191]                         muffled <- TRUE
  [06:53:35.191]                       }
  [06:53:35.191]                       else if (inherits(cond, "condition")) {
  [06:53:35.191]                         computeRestarts <- base::computeRestarts
  [06:53:35.191]                         grepl <- base::grepl
  [06:53:35.191]                         is.null <- base::is.null
  [06:53:35.191]                         restarts <- computeRestarts(cond)
  [06:53:35.191]                         for (restart in restarts) {
  [06:53:35.191]                           name <- restart$name
  [06:53:35.191]                           if (is.null(name)) 
  [06:53:35.191]                             next
  [06:53:35.191]                           if (!grepl("^muffle", name)) 
  [06:53:35.191]                             next
  [06:53:35.191]                           invokeRestart(restart)
  [06:53:35.191]                           muffled <- TRUE
  [06:53:35.191]                           break
  [06:53:35.191]                         }
  [06:53:35.191]                       }
  [06:53:35.191]                       invisible(muffled)
  [06:53:35.191]                     }
  [06:53:35.191]                     muffleCondition(cond)
  [06:53:35.191]                   }
  [06:53:35.191]                 }
  [06:53:35.191]             }
  [06:53:35.191]         }))
  [06:53:35.191]     }, error = function(ex) {
  [06:53:35.191]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:35.191]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:35.191]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:35.191]     }, finally = {
  [06:53:35.191]         {
  [06:53:35.191]             {
  [06:53:35.191]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:35.191]             }
  [06:53:35.191]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:35.191]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:35.191]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:35.191]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:35.191]                 ...) 
  [06:53:35.191]             {
  [06:53:35.191]                 if (substitute) 
  [06:53:35.191]                   expr <- substitute(expr)
  [06:53:35.191]                 if (is.function(workers)) 
  [06:53:35.191]                   workers <- workers()
  [06:53:35.191]                 workers <- as.integer(workers)
  [06:53:35.191]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:35.191]                   workers >= 1)
  [06:53:35.191]                 if (workers == 1L) {
  [06:53:35.191]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:35.191]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:35.191]                     local = TRUE, label = label, ...))
  [06:53:35.191]                 }
  [06:53:35.191]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:35.191]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:35.191]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:35.191]                   globals = globals, persistent = persistent, 
  [06:53:35.191]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:35.191]                   label = label, ...)
  [06:53:35.191]                 if (!future$lazy) 
  [06:53:35.191]                   future <- run(future)
  [06:53:35.191]                 invisible(future)
  [06:53:35.191]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:35.191]         }
  [06:53:35.191]         base::options(...future.oldOptions)
  [06:53:35.191]     })
  [06:53:35.191]     Sys.time
  [06:53:35.191]     if (base::is.na(TRUE)) {
  [06:53:35.191]     }
  [06:53:35.191]     else {
  [06:53:35.191]         base::sink(type = "output", split = FALSE)
  [06:53:35.191]         if (TRUE) {
  [06:53:35.191]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:35.191]         }
  [06:53:35.191]         else {
  [06:53:35.191]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:35.191]         }
  [06:53:35.191]         base::close(...future.stdout)
  [06:53:35.191]         ...future.stdout <- NULL
  [06:53:35.191]     }
  [06:53:35.191]     ...future.result$conditions <- ...future.conditions
  [06:53:35.191]     ...future.result
  [06:53:35.191] }
  [06:53:35.199] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [06:53:35.199] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [06:53:35.200] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [06:53:35.201] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [06:53:35.202] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [06:53:35.202] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [06:53:35.203] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [06:53:35.204] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [06:53:35.205] MultisessionFuture started
  [06:53:35.205] Chunk #1 of 2 ... DONE
  [06:53:35.206] Chunk #2 of 2 ...
  [06:53:35.206]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:35.206] getGlobalsAndPackages() ...
  [06:53:35.207] Searching for globals...
  [06:53:35.208] 
  [06:53:35.208] Searching for globals ... DONE
  [06:53:35.209] - globals: [0] <none>
  [06:53:35.209] getGlobalsAndPackages() ... DONE
  [06:53:35.209] 
  [06:53:35.209] 
  [06:53:35.210]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:35.211] getGlobalsAndPackages() ...
  [06:53:35.211] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.212] Resolving globals: FALSE
  [06:53:35.213] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:35.213] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:35.214] 
  [06:53:35.214] getGlobalsAndPackages() ... DONE
  [06:53:35.218] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:35.219] Packages needed by future strategies (n = 0): <none>
  [06:53:35.225] {
  [06:53:35.225]     {
  [06:53:35.225]         ...future.startTime <- base::Sys.time()
  [06:53:35.225]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:35.225]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:35.225]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:35.225]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:35.225]             future.resolve.recursive = NULL, width = 80L)
  [06:53:35.225]         {
  [06:53:35.225]             {
  [06:53:35.225]                 {
  [06:53:35.225]                   {
  [06:53:35.225]                     base::local({
  [06:53:35.225]                       has_future <- base::requireNamespace("future", 
  [06:53:35.225]                         quietly = TRUE)
  [06:53:35.225]                       version <- if (has_future) 
  [06:53:35.225]                         utils::packageVersion("future")
  [06:53:35.225]                       else NULL
  [06:53:35.225]                       if (!has_future || version < "1.8.0") {
  [06:53:35.225]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:35.225]                           "", base::R.version$version.string), 
  [06:53:35.225]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:35.225]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:35.225]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:35.225]                             "release", "version")], collapse = " "), 
  [06:53:35.225]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:35.225]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:35.225]                           info)
  [06:53:35.225]                         info <- base::paste(info, collapse = "; ")
  [06:53:35.225]                         if (!has_future) {
  [06:53:35.225]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:35.225]                             info)
  [06:53:35.225]                         }
  [06:53:35.225]                         else {
  [06:53:35.225]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:35.225]                             info, version)
  [06:53:35.225]                         }
  [06:53:35.225]                         base::stop(msg)
  [06:53:35.225]                       }
  [06:53:35.225]                     })
  [06:53:35.225]                   }
  [06:53:35.225]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:35.225]                   base::options(mc.cores = 1L)
  [06:53:35.225]                 }
  [06:53:35.225]                 base::local({
  [06:53:35.225]                   for (pkg in c("doFuture", "stats")) {
  [06:53:35.225]                     base::loadNamespace(pkg)
  [06:53:35.225]                     base::library(pkg, character.only = TRUE)
  [06:53:35.225]                   }
  [06:53:35.225]                 })
  [06:53:35.225]             }
  [06:53:35.225]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:35.225]         }
  [06:53:35.225]     }
  [06:53:35.225]     if (base::is.na(TRUE)) {
  [06:53:35.225]     }
  [06:53:35.225]     else {
  [06:53:35.225]         if (TRUE) {
  [06:53:35.225]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:35.225]                 open = "w")
  [06:53:35.225]         }
  [06:53:35.225]         else {
  [06:53:35.225]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:35.225]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:35.225]         }
  [06:53:35.225]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:35.225]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:35.225]             base::sink(type = "output", split = FALSE)
  [06:53:35.225]             base::close(...future.stdout)
  [06:53:35.225]         }, add = TRUE)
  [06:53:35.225]     }
  [06:53:35.225]     ...future.frame <- base::sys.nframe()
  [06:53:35.225]     ...future.conditions <- base::list()
  [06:53:35.225]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:35.225]     ...future.result <- base::tryCatch({
  [06:53:35.225]         base::withCallingHandlers({
  [06:53:35.225]             ...future.value <- base::withVisible(base::local({
  [06:53:35.225]                 ...future.sendCondition <- local({
  [06:53:35.225]                   sendCondition <- NULL
  [06:53:35.225]                   function(frame = 1L) {
  [06:53:35.225]                     if (is.function(sendCondition)) 
  [06:53:35.225]                       return(sendCondition)
  [06:53:35.225]                     ns <- getNamespace("parallel")
  [06:53:35.225]                     if (exists("sendData", mode = "function", 
  [06:53:35.225]                       envir = ns)) {
  [06:53:35.225]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:35.225]                         envir = ns)
  [06:53:35.225]                       envir <- sys.frame(frame)
  [06:53:35.225]                       master <- NULL
  [06:53:35.225]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:35.225]                         !identical(envir, emptyenv())) {
  [06:53:35.225]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:35.225]                           inherits = FALSE)) {
  [06:53:35.225]                           master <- get("master", mode = "list", 
  [06:53:35.225]                             envir = envir, inherits = FALSE)
  [06:53:35.225]                           if (inherits(master, "SOCKnode")) {
  [06:53:35.225]                             sendCondition <<- function(cond) {
  [06:53:35.225]                               data <- list(type = "VALUE", value = cond, 
  [06:53:35.225]                                 success = TRUE)
  [06:53:35.225]                               parallel_sendData(master, data)
  [06:53:35.225]                             }
  [06:53:35.225]                             return(sendCondition)
  [06:53:35.225]                           }
  [06:53:35.225]                         }
  [06:53:35.225]                         frame <- frame + 1L
  [06:53:35.225]                         envir <- sys.frame(frame)
  [06:53:35.225]                       }
  [06:53:35.225]                     }
  [06:53:35.225]                     sendCondition <<- function(cond) NULL
  [06:53:35.225]                   }
  [06:53:35.225]                 })
  [06:53:35.225]                 withCallingHandlers({
  [06:53:35.225]                   {
  [06:53:35.225]                     doFuture::registerDoFuture()
  [06:53:35.225]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:35.225]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:35.225]                       i <- NULL
  [06:53:35.225]                       ...future.env <- environment()
  [06:53:35.225]                       local({
  [06:53:35.225]                         for (name in names(...future.x_jj)) {
  [06:53:35.225]                           assign(name, ...future.x_jj[[name]], 
  [06:53:35.225]                             envir = ...future.env, inherits = FALSE)
  [06:53:35.225]                         }
  [06:53:35.225]                       })
  [06:53:35.225]                       tryCatch({
  [06:53:35.225]                         if (i%%2 == 0) 
  [06:53:35.225]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:35.225]                             i))
  [06:53:35.225]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:35.225]                       }, error = identity)
  [06:53:35.225]                     })
  [06:53:35.225]                   }
  [06:53:35.225]                 }, immediateCondition = function(cond) {
  [06:53:35.225]                   sendCondition <- ...future.sendCondition()
  [06:53:35.225]                   sendCondition(cond)
  [06:53:35.225]                   muffleCondition <- function (cond) 
  [06:53:35.225]                   {
  [06:53:35.225]                     inherits <- base::inherits
  [06:53:35.225]                     invokeRestart <- base::invokeRestart
  [06:53:35.225]                     muffled <- FALSE
  [06:53:35.225]                     if (inherits(cond, "message")) {
  [06:53:35.225]                       invokeRestart("muffleMessage")
  [06:53:35.225]                       muffled <- TRUE
  [06:53:35.225]                     }
  [06:53:35.225]                     else if (inherits(cond, "warning")) {
  [06:53:35.225]                       invokeRestart("muffleWarning")
  [06:53:35.225]                       muffled <- TRUE
  [06:53:35.225]                     }
  [06:53:35.225]                     else if (inherits(cond, "condition")) {
  [06:53:35.225]                       computeRestarts <- base::computeRestarts
  [06:53:35.225]                       grepl <- base::grepl
  [06:53:35.225]                       is.null <- base::is.null
  [06:53:35.225]                       restarts <- computeRestarts(cond)
  [06:53:35.225]                       for (restart in restarts) {
  [06:53:35.225]                         name <- restart$name
  [06:53:35.225]                         if (is.null(name)) 
  [06:53:35.225]                           next
  [06:53:35.225]                         if (!grepl("^muffle", name)) 
  [06:53:35.225]                           next
  [06:53:35.225]                         invokeRestart(restart)
  [06:53:35.225]                         muffled <- TRUE
  [06:53:35.225]                         break
  [06:53:35.225]                       }
  [06:53:35.225]                     }
  [06:53:35.225]                     invisible(muffled)
  [06:53:35.225]                   }
  [06:53:35.225]                   muffleCondition(cond)
  [06:53:35.225]                 })
  [06:53:35.225]             }))
  [06:53:35.225]             future::FutureResult(value = ...future.value$value, 
  [06:53:35.225]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:35.225]                   ...future.rng), started = ...future.startTime, 
  [06:53:35.225]                 version = "1.8")
  [06:53:35.225]         }, condition = base::local({
  [06:53:35.225]             c <- base::c
  [06:53:35.225]             inherits <- base::inherits
  [06:53:35.225]             invokeRestart <- base::invokeRestart
  [06:53:35.225]             length <- base::length
  [06:53:35.225]             list <- base::list
  [06:53:35.225]             seq.int <- base::seq.int
  [06:53:35.225]             signalCondition <- base::signalCondition
  [06:53:35.225]             sys.calls <- base::sys.calls
  [06:53:35.225]             Sys.time <- base::Sys.time
  [06:53:35.225]             `[[` <- base::`[[`
  [06:53:35.225]             `+` <- base::`+`
  [06:53:35.225]             `<<-` <- base::`<<-`
  [06:53:35.225]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:35.225]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:35.225]                   3L)]
  [06:53:35.225]             }
  [06:53:35.225]             function(cond) {
  [06:53:35.225]                 if (inherits(cond, "error")) {
  [06:53:35.225]                   sessionInformation <- function() {
  [06:53:35.225]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:35.225]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:35.225]                       search = base::search(), system = base::Sys.info())
  [06:53:35.225]                   }
  [06:53:35.225]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:35.225]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:35.225]                     cond$call), session = sessionInformation(), 
  [06:53:35.225]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:35.225]                   signalCondition(cond)
  [06:53:35.225]                 }
  [06:53:35.225]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:35.225]                 ))) {
  [06:53:35.225]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:35.225]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:35.225]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:35.225]                   if (!signal) {
  [06:53:35.225]                     muffleCondition <- function (cond) 
  [06:53:35.225]                     {
  [06:53:35.225]                       inherits <- base::inherits
  [06:53:35.225]                       invokeRestart <- base::invokeRestart
  [06:53:35.225]                       muffled <- FALSE
  [06:53:35.225]                       if (inherits(cond, "message")) {
  [06:53:35.225]                         invokeRestart("muffleMessage")
  [06:53:35.225]                         muffled <- TRUE
  [06:53:35.225]                       }
  [06:53:35.225]                       else if (inherits(cond, "warning")) {
  [06:53:35.225]                         invokeRestart("muffleWarning")
  [06:53:35.225]                         muffled <- TRUE
  [06:53:35.225]                       }
  [06:53:35.225]                       else if (inherits(cond, "condition")) {
  [06:53:35.225]                         computeRestarts <- base::computeRestarts
  [06:53:35.225]                         grepl <- base::grepl
  [06:53:35.225]                         is.null <- base::is.null
  [06:53:35.225]                         restarts <- computeRestarts(cond)
  [06:53:35.225]                         for (restart in restarts) {
  [06:53:35.225]                           name <- restart$name
  [06:53:35.225]                           if (is.null(name)) 
  [06:53:35.225]                             next
  [06:53:35.225]                           if (!grepl("^muffle", name)) 
  [06:53:35.225]                             next
  [06:53:35.225]                           invokeRestart(restart)
  [06:53:35.225]                           muffled <- TRUE
  [06:53:35.225]                           break
  [06:53:35.225]                         }
  [06:53:35.225]                       }
  [06:53:35.225]                       invisible(muffled)
  [06:53:35.225]                     }
  [06:53:35.225]                     muffleCondition(cond)
  [06:53:35.225]                   }
  [06:53:35.225]                 }
  [06:53:35.225]             }
  [06:53:35.225]         }))
  [06:53:35.225]     }, error = function(ex) {
  [06:53:35.225]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:35.225]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:35.225]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:35.225]     }, finally = {
  [06:53:35.225]         {
  [06:53:35.225]             {
  [06:53:35.225]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:35.225]             }
  [06:53:35.225]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:35.225]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:35.225]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:35.225]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:35.225]                 ...) 
  [06:53:35.225]             {
  [06:53:35.225]                 if (substitute) 
  [06:53:35.225]                   expr <- substitute(expr)
  [06:53:35.225]                 if (is.function(workers)) 
  [06:53:35.225]                   workers <- workers()
  [06:53:35.225]                 workers <- as.integer(workers)
  [06:53:35.225]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:35.225]                   workers >= 1)
  [06:53:35.225]                 if (workers == 1L) {
  [06:53:35.225]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:35.225]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:35.225]                     local = TRUE, label = label, ...))
  [06:53:35.225]                 }
  [06:53:35.225]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:35.225]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:35.225]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:35.225]                   globals = globals, persistent = persistent, 
  [06:53:35.225]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:35.225]                   label = label, ...)
  [06:53:35.225]                 if (!future$lazy) 
  [06:53:35.225]                   future <- run(future)
  [06:53:35.225]                 invisible(future)
  [06:53:35.225]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:35.225]         }
  [06:53:35.225]         base::options(...future.oldOptions)
  [06:53:35.225]     })
  [06:53:35.225]     Sys.time
  [06:53:35.225]     if (base::is.na(TRUE)) {
  [06:53:35.225]     }
  [06:53:35.225]     else {
  [06:53:35.225]         base::sink(type = "output", split = FALSE)
  [06:53:35.225]         if (TRUE) {
  [06:53:35.225]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:35.225]         }
  [06:53:35.225]         else {
  [06:53:35.225]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:35.225]         }
  [06:53:35.225]         base::close(...future.stdout)
  [06:53:35.225]         ...future.stdout <- NULL
  [06:53:35.225]     }
  [06:53:35.225]     ...future.result$conditions <- ...future.conditions
  [06:53:35.225]     ...future.result
  [06:53:35.225] }
  [06:53:35.231] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [06:53:35.232] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [06:53:35.233] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [06:53:35.233] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [06:53:35.234] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [06:53:35.235] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [06:53:35.236] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [06:53:35.236] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [06:53:35.237] MultisessionFuture started
  [06:53:35.238] Chunk #2 of 2 ... DONE
  [06:53:35.238] Launching 2 futures (chunks) ... DONE
  [06:53:35.238] - resolving futures
  [06:53:35.238]   - gathering results & relaying conditions (except errors)
  [06:53:35.239] resolve() on list ...
  [06:53:35.239]  recursive: 0
  [06:53:35.239]  length: 2
  [06:53:35.240] 
  [06:53:35.428] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:35.429] - Validating connection of MultisessionFuture
  [06:53:35.429] - received message: FutureResult
  [06:53:35.430] - Received FutureResult
  [06:53:35.430] - Erased future from FutureRegistry
  [06:53:35.430] result() for ClusterFuture ...
  [06:53:35.431] - result already collected: FutureResult
  [06:53:35.431] result() for ClusterFuture ... done
  [06:53:35.432] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:35.432] Future #1
  [06:53:35.432] result() for ClusterFuture ...
  [06:53:35.433] - result already collected: FutureResult
  [06:53:35.433] result() for ClusterFuture ... done
  [06:53:35.433] result() for ClusterFuture ...
  [06:53:35.434] - result already collected: FutureResult
  [06:53:35.434] result() for ClusterFuture ... done
  [06:53:35.435] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [06:53:35.435] - nx: 2
  [06:53:35.435] - relay: TRUE
  [06:53:35.436] - stdout: TRUE
  [06:53:35.436] - signal: TRUE
  [06:53:35.436] - resignal: FALSE
  [06:53:35.437] - force: FALSE
  [06:53:35.437] - relayed: [n=2] FALSE, FALSE
  [06:53:35.437] - queued futures: [n=2] FALSE, FALSE
  [06:53:35.438]  - until=1
  [06:53:35.438]  - relaying element #1
  [06:53:35.438] result() for ClusterFuture ...
  [06:53:35.439] - result already collected: FutureResult
  [06:53:35.439] result() for ClusterFuture ... done
  [06:53:35.440] result() for ClusterFuture ...
  [06:53:35.440] - result already collected: FutureResult
  [06:53:35.440] result() for ClusterFuture ... done
  [06:53:35.441] result() for ClusterFuture ...
  [06:53:35.441] - result already collected: FutureResult
  [06:53:35.442] result() for ClusterFuture ... done
  [06:53:35.442] result() for ClusterFuture ...
  [06:53:35.442] - result already collected: FutureResult
  [06:53:35.443] result() for ClusterFuture ... done
  [06:53:35.447] - relayed: [n=2] TRUE, FALSE
  [06:53:35.448] - queued futures: [n=2] TRUE, FALSE
  [06:53:35.448] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [06:53:35.448]  length: 1 (resolved future 1)
  [06:53:35.538] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:35.539] - Validating connection of MultisessionFuture
  [06:53:35.539] - received message: FutureResult
  [06:53:35.540] - Received FutureResult
  [06:53:35.540] - Erased future from FutureRegistry
  [06:53:35.541] result() for ClusterFuture ...
  [06:53:35.541] - result already collected: FutureResult
  [06:53:35.541] result() for ClusterFuture ... done
  [06:53:35.542] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:35.542] Future #2
  [06:53:35.543] result() for ClusterFuture ...
  [06:53:35.543] - result already collected: FutureResult
  [06:53:35.543] result() for ClusterFuture ... done
  [06:53:35.544] result() for ClusterFuture ...
  [06:53:35.545] - result already collected: FutureResult
  [06:53:35.545] result() for ClusterFuture ... done
  [06:53:35.545] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [06:53:35.546] - nx: 2
  [06:53:35.546] - relay: TRUE
  [06:53:35.547] - stdout: TRUE
  [06:53:35.547] - signal: TRUE
  [06:53:35.547] - resignal: FALSE
  [06:53:35.548] - force: FALSE
  [06:53:35.548] - relayed: [n=2] TRUE, FALSE
  [06:53:35.548] - queued futures: [n=2] TRUE, FALSE
  [06:53:35.549]  - until=2
  [06:53:35.549]  - relaying element #2
  [06:53:35.549] result() for ClusterFuture ...
  [06:53:35.550] - result already collected: FutureResult
  [06:53:35.550] result() for ClusterFuture ... done
  [06:53:35.550] result() for ClusterFuture ...
  [06:53:35.551] - result already collected: FutureResult
  [06:53:35.551] result() for ClusterFuture ... done
  [06:53:35.552] result() for ClusterFuture ...
  [06:53:35.552] - result already collected: FutureResult
  [06:53:35.552] result() for ClusterFuture ... done
  [06:53:35.553] result() for ClusterFuture ...
  [06:53:35.553] - result already collected: FutureResult
  [06:53:35.553] result() for ClusterFuture ... done
  [06:53:35.554] - relayed: [n=2] TRUE, TRUE
  [06:53:35.554] - queued futures: [n=2] TRUE, TRUE
  [06:53:35.554] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [06:53:35.555]  length: 0 (resolved future 2)
  [06:53:35.555] Relaying remaining futures
  [06:53:35.555] signalConditionsASAP(NULL, pos=0) ...
  [06:53:35.556] - nx: 2
  [06:53:35.556] - relay: TRUE
  [06:53:35.556] - stdout: TRUE
  [06:53:35.557] - signal: TRUE
  [06:53:35.557] - resignal: FALSE
  [06:53:35.558] - force: FALSE
  [06:53:35.558] - relayed: [n=2] TRUE, TRUE
  [06:53:35.558] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:35.560] - relayed: [n=2] TRUE, TRUE
  [06:53:35.560] - queued futures: [n=2] TRUE, TRUE
  [06:53:35.561] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:35.561] resolve() on list ... DONE
  [06:53:35.561] - collecting values of futures
  [06:53:35.562] result() for ClusterFuture ...
  [06:53:35.562] - result already collected: FutureResult
  [06:53:35.562] result() for ClusterFuture ... done
  [06:53:35.563] result() for ClusterFuture ...
  [06:53:35.563] - result already collected: FutureResult
  [06:53:35.564] result() for ClusterFuture ... done
  [06:53:35.564] result() for ClusterFuture ...
  [06:53:35.564] - result already collected: FutureResult
  [06:53:35.565] result() for ClusterFuture ... done
  [06:53:35.565] result() for ClusterFuture ...
  [06:53:35.566] - result already collected: FutureResult
  [06:53:35.566] result() for ClusterFuture ... done
  [06:53:35.566] - accumulating results
  [06:53:35.569] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('multisession') ... DONE
  - plan('cluster') ...
  [06:53:35.571] plan(): Setting new future strategy stack:
  [06:53:35.571] List of future strategies:
  [06:53:35.571] 1. cluster:
  [06:53:35.571]    - 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, ...)
  [06:53:35.571]    - tweaked: FALSE
  [06:53:35.571]    - call: plan(strategy)
  [06:53:35.573] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:35.574] cluster:
  [06:53:35.574] - 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, ...)
  [06:53:35.574] - tweaked: FALSE
  [06:53:35.574] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 28504
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758965cf2293.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.758965cf2293.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758965cf2293.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=28504 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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75892966c852.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.75892966c852.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75892966c852.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=28504 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [06:53:38.137] getGlobalsAndPackages() ...
  [06:53:38.138] Not searching for globals
  [06:53:38.138] - globals: [0] <none>
  [06:53:38.139] getGlobalsAndPackages() ... DONE
  [06:53:38.144] Packages needed by the future expression (n = 0): <none>
  [06:53:38.145] Packages needed by future strategies (n = 0): <none>
  [06:53:38.152] {
  [06:53:38.152]     {
  [06:53:38.152]         ...future.startTime <- base::Sys.time()
  [06:53:38.152]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:38.152]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:38.152]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:38.152]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:38.152]             future.resolve.recursive = NULL, width = 80L)
  [06:53:38.152]         {
  [06:53:38.152]             {
  [06:53:38.152]                 base::local({
  [06:53:38.152]                   has_future <- base::requireNamespace("future", 
  [06:53:38.152]                     quietly = TRUE)
  [06:53:38.152]                   version <- if (has_future) 
  [06:53:38.152]                     utils::packageVersion("future")
  [06:53:38.152]                   else NULL
  [06:53:38.152]                   if (!has_future || version < "1.8.0") {
  [06:53:38.152]                     info <- base::c(r_version = base::gsub("R version ", 
  [06:53:38.152]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [06:53:38.152]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:38.152]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:38.152]                         "release", "version")], collapse = " "), 
  [06:53:38.152]                       hostname = base::Sys.info()[["nodename"]])
  [06:53:38.152]                     info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:38.152]                       info)
  [06:53:38.152]                     info <- base::paste(info, collapse = "; ")
  [06:53:38.152]                     if (!has_future) {
  [06:53:38.152]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:38.152]                         info)
  [06:53:38.152]                     }
  [06:53:38.152]                     else {
  [06:53:38.152]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:38.152]                         info, version)
  [06:53:38.152]                     }
  [06:53:38.152]                     base::stop(msg)
  [06:53:38.152]                   }
  [06:53:38.152]                 })
  [06:53:38.152]             }
  [06:53:38.152]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:38.152]         }
  [06:53:38.152]     }
  [06:53:38.152]     if (base::is.na(TRUE)) {
  [06:53:38.152]     }
  [06:53:38.152]     else {
  [06:53:38.152]         if (TRUE) {
  [06:53:38.152]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:38.152]                 open = "w")
  [06:53:38.152]         }
  [06:53:38.152]         else {
  [06:53:38.152]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:38.152]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:38.152]         }
  [06:53:38.152]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:38.152]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:38.152]             base::sink(type = "output", split = FALSE)
  [06:53:38.152]             base::close(...future.stdout)
  [06:53:38.152]         }, add = TRUE)
  [06:53:38.152]     }
  [06:53:38.152]     ...future.frame <- base::sys.nframe()
  [06:53:38.152]     ...future.conditions <- base::list()
  [06:53:38.152]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:38.152]     ...future.result <- base::tryCatch({
  [06:53:38.152]         base::withCallingHandlers({
  [06:53:38.152]             ...future.value <- base::withVisible(base::local({
  [06:53:38.152]                 ...future.sendCondition <- local({
  [06:53:38.152]                   sendCondition <- NULL
  [06:53:38.152]                   function(frame = 1L) {
  [06:53:38.152]                     if (is.function(sendCondition)) 
  [06:53:38.152]                       return(sendCondition)
  [06:53:38.152]                     ns <- getNamespace("parallel")
  [06:53:38.152]                     if (exists("sendData", mode = "function", 
  [06:53:38.152]                       envir = ns)) {
  [06:53:38.152]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:38.152]                         envir = ns)
  [06:53:38.152]                       envir <- sys.frame(frame)
  [06:53:38.152]                       master <- NULL
  [06:53:38.152]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:38.152]                         !identical(envir, emptyenv())) {
  [06:53:38.152]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:38.152]                           inherits = FALSE)) {
  [06:53:38.152]                           master <- get("master", mode = "list", 
  [06:53:38.152]                             envir = envir, inherits = FALSE)
  [06:53:38.152]                           if (inherits(master, "SOCKnode")) {
  [06:53:38.152]                             sendCondition <<- function(cond) {
  [06:53:38.152]                               data <- list(type = "VALUE", value = cond, 
  [06:53:38.152]                                 success = TRUE)
  [06:53:38.152]                               parallel_sendData(master, data)
  [06:53:38.152]                             }
  [06:53:38.152]                             return(sendCondition)
  [06:53:38.152]                           }
  [06:53:38.152]                         }
  [06:53:38.152]                         frame <- frame + 1L
  [06:53:38.152]                         envir <- sys.frame(frame)
  [06:53:38.152]                       }
  [06:53:38.152]                     }
  [06:53:38.152]                     sendCondition <<- function(cond) NULL
  [06:53:38.152]                   }
  [06:53:38.152]                 })
  [06:53:38.152]                 withCallingHandlers({
  [06:53:38.152]                   NA
  [06:53:38.152]                 }, immediateCondition = function(cond) {
  [06:53:38.152]                   sendCondition <- ...future.sendCondition()
  [06:53:38.152]                   sendCondition(cond)
  [06:53:38.152]                   muffleCondition <- function (cond) 
  [06:53:38.152]                   {
  [06:53:38.152]                     inherits <- base::inherits
  [06:53:38.152]                     invokeRestart <- base::invokeRestart
  [06:53:38.152]                     muffled <- FALSE
  [06:53:38.152]                     if (inherits(cond, "message")) {
  [06:53:38.152]                       invokeRestart("muffleMessage")
  [06:53:38.152]                       muffled <- TRUE
  [06:53:38.152]                     }
  [06:53:38.152]                     else if (inherits(cond, "warning")) {
  [06:53:38.152]                       invokeRestart("muffleWarning")
  [06:53:38.152]                       muffled <- TRUE
  [06:53:38.152]                     }
  [06:53:38.152]                     else if (inherits(cond, "condition")) {
  [06:53:38.152]                       computeRestarts <- base::computeRestarts
  [06:53:38.152]                       grepl <- base::grepl
  [06:53:38.152]                       is.null <- base::is.null
  [06:53:38.152]                       restarts <- computeRestarts(cond)
  [06:53:38.152]                       for (restart in restarts) {
  [06:53:38.152]                         name <- restart$name
  [06:53:38.152]                         if (is.null(name)) 
  [06:53:38.152]                           next
  [06:53:38.152]                         if (!grepl("^muffle", name)) 
  [06:53:38.152]                           next
  [06:53:38.152]                         invokeRestart(restart)
  [06:53:38.152]                         muffled <- TRUE
  [06:53:38.152]                         break
  [06:53:38.152]                       }
  [06:53:38.152]                     }
  [06:53:38.152]                     invisible(muffled)
  [06:53:38.152]                   }
  [06:53:38.152]                   muffleCondition(cond)
  [06:53:38.152]                 })
  [06:53:38.152]             }))
  [06:53:38.152]             future::FutureResult(value = ...future.value$value, 
  [06:53:38.152]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.152]                   ...future.rng), started = ...future.startTime, 
  [06:53:38.152]                 version = "1.8")
  [06:53:38.152]         }, condition = base::local({
  [06:53:38.152]             c <- base::c
  [06:53:38.152]             inherits <- base::inherits
  [06:53:38.152]             invokeRestart <- base::invokeRestart
  [06:53:38.152]             length <- base::length
  [06:53:38.152]             list <- base::list
  [06:53:38.152]             seq.int <- base::seq.int
  [06:53:38.152]             signalCondition <- base::signalCondition
  [06:53:38.152]             sys.calls <- base::sys.calls
  [06:53:38.152]             Sys.time <- base::Sys.time
  [06:53:38.152]             `[[` <- base::`[[`
  [06:53:38.152]             `+` <- base::`+`
  [06:53:38.152]             `<<-` <- base::`<<-`
  [06:53:38.152]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:38.152]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:38.152]                   3L)]
  [06:53:38.152]             }
  [06:53:38.152]             function(cond) {
  [06:53:38.152]                 if (inherits(cond, "error")) {
  [06:53:38.152]                   sessionInformation <- function() {
  [06:53:38.152]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:38.152]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:38.152]                       search = base::search(), system = base::Sys.info())
  [06:53:38.152]                   }
  [06:53:38.152]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.152]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:38.152]                     cond$call), session = sessionInformation(), 
  [06:53:38.152]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:38.152]                   signalCondition(cond)
  [06:53:38.152]                 }
  [06:53:38.152]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:38.152]                 ))) {
  [06:53:38.152]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:38.152]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.152]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:38.152]                   if (!signal) {
  [06:53:38.152]                     muffleCondition <- function (cond) 
  [06:53:38.152]                     {
  [06:53:38.152]                       inherits <- base::inherits
  [06:53:38.152]                       invokeRestart <- base::invokeRestart
  [06:53:38.152]                       muffled <- FALSE
  [06:53:38.152]                       if (inherits(cond, "message")) {
  [06:53:38.152]                         invokeRestart("muffleMessage")
  [06:53:38.152]                         muffled <- TRUE
  [06:53:38.152]                       }
  [06:53:38.152]                       else if (inherits(cond, "warning")) {
  [06:53:38.152]                         invokeRestart("muffleWarning")
  [06:53:38.152]                         muffled <- TRUE
  [06:53:38.152]                       }
  [06:53:38.152]                       else if (inherits(cond, "condition")) {
  [06:53:38.152]                         computeRestarts <- base::computeRestarts
  [06:53:38.152]                         grepl <- base::grepl
  [06:53:38.152]                         is.null <- base::is.null
  [06:53:38.152]                         restarts <- computeRestarts(cond)
  [06:53:38.152]                         for (restart in restarts) {
  [06:53:38.152]                           name <- restart$name
  [06:53:38.152]                           if (is.null(name)) 
  [06:53:38.152]                             next
  [06:53:38.152]                           if (!grepl("^muffle", name)) 
  [06:53:38.152]                             next
  [06:53:38.152]                           invokeRestart(restart)
  [06:53:38.152]                           muffled <- TRUE
  [06:53:38.152]                           break
  [06:53:38.152]                         }
  [06:53:38.152]                       }
  [06:53:38.152]                       invisible(muffled)
  [06:53:38.152]                     }
  [06:53:38.152]                     muffleCondition(cond)
  [06:53:38.152]                   }
  [06:53:38.152]                 }
  [06:53:38.152]             }
  [06:53:38.152]         }))
  [06:53:38.152]     }, error = function(ex) {
  [06:53:38.152]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:38.152]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.152]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:38.152]     }, finally = {
  [06:53:38.152]         {
  [06:53:38.152]             NULL
  [06:53:38.152]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:38.152]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:38.152]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:38.152]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:38.152]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:38.152]                 ...) 
  [06:53:38.152]             {
  [06:53:38.152]                 if (substitute) 
  [06:53:38.152]                   expr <- substitute(expr)
  [06:53:38.152]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:38.152]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:38.152]                   globals = globals, persistent = persistent, 
  [06:53:38.152]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:38.152]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:38.152]                   label = label, ...)
  [06:53:38.152]                 if (!future$lazy) 
  [06:53:38.152]                   future <- run(future)
  [06:53:38.152]                 invisible(future)
  [06:53:38.152]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:38.152]         }
  [06:53:38.152]         base::options(...future.oldOptions)
  [06:53:38.152]     })
  [06:53:38.152]     Sys.time
  [06:53:38.152]     if (base::is.na(TRUE)) {
  [06:53:38.152]     }
  [06:53:38.152]     else {
  [06:53:38.152]         base::sink(type = "output", split = FALSE)
  [06:53:38.152]         if (TRUE) {
  [06:53:38.152]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:38.152]         }
  [06:53:38.152]         else {
  [06:53:38.152]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:38.152]         }
  [06:53:38.152]         base::close(...future.stdout)
  [06:53:38.152]         ...future.stdout <- NULL
  [06:53:38.152]     }
  [06:53:38.152]     ...future.result$conditions <- ...future.conditions
  [06:53:38.152]     ...future.result
  [06:53:38.152] }
  [06:53:38.160] ClusterFuture started
  [06:53:38.161] result() for ClusterFuture ...
  [06:53:38.161] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:38.162] - Validating connection of ClusterFuture
  [06:53:38.318] - received message: FutureResult
  [06:53:38.318] - Received FutureResult
  [06:53:38.319] - Erased future from FutureRegistry
  [06:53:38.319] result() for ClusterFuture ...
  [06:53:38.320] - result already collected: FutureResult
  [06:53:38.320] result() for ClusterFuture ... done
  [06:53:38.321] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:38.321] result() for ClusterFuture ... done
  [06:53:38.321] result() for ClusterFuture ...
  [06:53:38.322] - result already collected: FutureResult
  [06:53:38.322] result() for ClusterFuture ... done
  [06:53:38.323] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [06:53:38.325] plan(): nbrOfWorkers() = 2
  [06:53:38.325] doFuture() ...
  [06:53:38.339] - dummy globals (as locals): [1] 'i'
  [06:53:38.341] - R expression:
  [06:53:38.341] {
  [06:53:38.341]     doFuture::registerDoFuture()
  [06:53:38.341]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:38.341]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:38.341]         i <- NULL
  [06:53:38.341]         ...future.env <- environment()
  [06:53:38.341]         local({
  [06:53:38.341]             for (name in names(...future.x_jj)) {
  [06:53:38.341]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:38.341]                   inherits = FALSE)
  [06:53:38.341]             }
  [06:53:38.341]         })
  [06:53:38.341]         tryCatch({
  [06:53:38.341]             if (i%%2 == 0) 
  [06:53:38.341]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:38.341]                   i))
  [06:53:38.341]             dnorm(i, mean = mu, sd = sigma)
  [06:53:38.341]         }, error = identity)
  [06:53:38.341]     })
  [06:53:38.341] }
  [06:53:38.342] - identifying globals and packages ...
  [06:53:38.343] getGlobalsAndPackages() ...
  [06:53:38.343] Searching for globals...
  [06:53:38.366] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:38.367] Searching for globals ... DONE
  [06:53:38.367] Resolving globals: FALSE
  [06:53:38.370] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:38.370] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.371] - packages: [1] 'stats'
  [06:53:38.371] getGlobalsAndPackages() ... DONE
  [06:53:38.372] List of 3
  [06:53:38.372]  $ ...future.x_ii: NULL
  [06:53:38.372]  $ mu            : num 1
  [06:53:38.372]  $ sigma         : num 2
  [06:53:38.372]  - attr(*, "where")=List of 3
  [06:53:38.372]   ..$ ...future.x_ii:<environment: 0x5575ff6ccdb0> 
  [06:53:38.372]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:38.372]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:38.372]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:38.372]  - attr(*, "resolved")= logi FALSE
  [06:53:38.372]  - attr(*, "total_size")= num 112
  [06:53:38.388]   - R expression:
  [06:53:38.389] {
  [06:53:38.389]     doFuture::registerDoFuture()
  [06:53:38.389]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:38.389]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:38.389]         i <- NULL
  [06:53:38.389]         ...future.env <- environment()
  [06:53:38.389]         local({
  [06:53:38.389]             for (name in names(...future.x_jj)) {
  [06:53:38.389]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:38.389]                   inherits = FALSE)
  [06:53:38.389]             }
  [06:53:38.389]         })
  [06:53:38.389]         tryCatch({
  [06:53:38.389]             if (i%%2 == 0) 
  [06:53:38.389]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:38.389]                   i))
  [06:53:38.389]             dnorm(i, mean = mu, sd = sigma)
  [06:53:38.389]         }, error = identity)
  [06:53:38.389]     })
  [06:53:38.389] }
  [06:53:38.390]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.390] List of 3
  [06:53:38.390]  $ ...future.x_ii: NULL
  [06:53:38.390]  $ mu            : num 1
  [06:53:38.390]  $ sigma         : num 2
  [06:53:38.390]  - attr(*, "where")=List of 3
  [06:53:38.390]   ..$ ...future.x_ii:<environment: 0x5575ff6ccdb0> 
  [06:53:38.390]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:38.390]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:38.390]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:38.390]  - attr(*, "resolved")= logi FALSE
  [06:53:38.390]  - attr(*, "total_size")= num 112
  [06:53:38.415]   - packages: [2] 'doFuture', 'stats'
  [06:53:38.416] - identifying globals and packages ... DONE
  [06:53:38.418] Number of chunks: 2
  [06:53:38.419] Number of futures (= number of chunks): 2
  [06:53:38.424] Launching 2 futures (chunks) ...
  [06:53:38.425] Chunk #1 of 2 ...
  [06:53:38.425]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:38.425] getGlobalsAndPackages() ...
  [06:53:38.426] Searching for globals...
  [06:53:38.427] 
  [06:53:38.428] Searching for globals ... DONE
  [06:53:38.428] - globals: [0] <none>
  [06:53:38.429] getGlobalsAndPackages() ... DONE
  [06:53:38.429] 
  [06:53:38.429] 
  [06:53:38.430]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:38.432] getGlobalsAndPackages() ...
  [06:53:38.432] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.433] Resolving globals: FALSE
  [06:53:38.434] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:38.435] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.435] 
  [06:53:38.435] getGlobalsAndPackages() ... DONE
  [06:53:38.440] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:38.441] Packages needed by future strategies (n = 0): <none>
  [06:53:38.448] {
  [06:53:38.448]     {
  [06:53:38.448]         ...future.startTime <- base::Sys.time()
  [06:53:38.448]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:38.448]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:38.448]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:38.448]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:38.448]             future.resolve.recursive = NULL, width = 80L)
  [06:53:38.448]         {
  [06:53:38.448]             {
  [06:53:38.448]                 {
  [06:53:38.448]                   base::local({
  [06:53:38.448]                     has_future <- base::requireNamespace("future", 
  [06:53:38.448]                       quietly = TRUE)
  [06:53:38.448]                     version <- if (has_future) 
  [06:53:38.448]                       utils::packageVersion("future")
  [06:53:38.448]                     else NULL
  [06:53:38.448]                     if (!has_future || version < "1.8.0") {
  [06:53:38.448]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:38.448]                         "", base::R.version$version.string), 
  [06:53:38.448]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:38.448]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:38.448]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:38.448]                           "release", "version")], collapse = " "), 
  [06:53:38.448]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:38.448]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:38.448]                         info)
  [06:53:38.448]                       info <- base::paste(info, collapse = "; ")
  [06:53:38.448]                       if (!has_future) {
  [06:53:38.448]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:38.448]                           info)
  [06:53:38.448]                       }
  [06:53:38.448]                       else {
  [06:53:38.448]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:38.448]                           info, version)
  [06:53:38.448]                       }
  [06:53:38.448]                       base::stop(msg)
  [06:53:38.448]                     }
  [06:53:38.448]                   })
  [06:53:38.448]                 }
  [06:53:38.448]                 base::local({
  [06:53:38.448]                   for (pkg in c("doFuture", "stats")) {
  [06:53:38.448]                     base::loadNamespace(pkg)
  [06:53:38.448]                     base::library(pkg, character.only = TRUE)
  [06:53:38.448]                   }
  [06:53:38.448]                 })
  [06:53:38.448]             }
  [06:53:38.448]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:38.448]         }
  [06:53:38.448]     }
  [06:53:38.448]     if (base::is.na(TRUE)) {
  [06:53:38.448]     }
  [06:53:38.448]     else {
  [06:53:38.448]         if (TRUE) {
  [06:53:38.448]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:38.448]                 open = "w")
  [06:53:38.448]         }
  [06:53:38.448]         else {
  [06:53:38.448]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:38.448]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:38.448]         }
  [06:53:38.448]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:38.448]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:38.448]             base::sink(type = "output", split = FALSE)
  [06:53:38.448]             base::close(...future.stdout)
  [06:53:38.448]         }, add = TRUE)
  [06:53:38.448]     }
  [06:53:38.448]     ...future.frame <- base::sys.nframe()
  [06:53:38.448]     ...future.conditions <- base::list()
  [06:53:38.448]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:38.448]     ...future.result <- base::tryCatch({
  [06:53:38.448]         base::withCallingHandlers({
  [06:53:38.448]             ...future.value <- base::withVisible(base::local({
  [06:53:38.448]                 ...future.sendCondition <- local({
  [06:53:38.448]                   sendCondition <- NULL
  [06:53:38.448]                   function(frame = 1L) {
  [06:53:38.448]                     if (is.function(sendCondition)) 
  [06:53:38.448]                       return(sendCondition)
  [06:53:38.448]                     ns <- getNamespace("parallel")
  [06:53:38.448]                     if (exists("sendData", mode = "function", 
  [06:53:38.448]                       envir = ns)) {
  [06:53:38.448]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:38.448]                         envir = ns)
  [06:53:38.448]                       envir <- sys.frame(frame)
  [06:53:38.448]                       master <- NULL
  [06:53:38.448]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:38.448]                         !identical(envir, emptyenv())) {
  [06:53:38.448]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:38.448]                           inherits = FALSE)) {
  [06:53:38.448]                           master <- get("master", mode = "list", 
  [06:53:38.448]                             envir = envir, inherits = FALSE)
  [06:53:38.448]                           if (inherits(master, "SOCKnode")) {
  [06:53:38.448]                             sendCondition <<- function(cond) {
  [06:53:38.448]                               data <- list(type = "VALUE", value = cond, 
  [06:53:38.448]                                 success = TRUE)
  [06:53:38.448]                               parallel_sendData(master, data)
  [06:53:38.448]                             }
  [06:53:38.448]                             return(sendCondition)
  [06:53:38.448]                           }
  [06:53:38.448]                         }
  [06:53:38.448]                         frame <- frame + 1L
  [06:53:38.448]                         envir <- sys.frame(frame)
  [06:53:38.448]                       }
  [06:53:38.448]                     }
  [06:53:38.448]                     sendCondition <<- function(cond) NULL
  [06:53:38.448]                   }
  [06:53:38.448]                 })
  [06:53:38.448]                 withCallingHandlers({
  [06:53:38.448]                   {
  [06:53:38.448]                     doFuture::registerDoFuture()
  [06:53:38.448]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:38.448]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:38.448]                       i <- NULL
  [06:53:38.448]                       ...future.env <- environment()
  [06:53:38.448]                       local({
  [06:53:38.448]                         for (name in names(...future.x_jj)) {
  [06:53:38.448]                           assign(name, ...future.x_jj[[name]], 
  [06:53:38.448]                             envir = ...future.env, inherits = FALSE)
  [06:53:38.448]                         }
  [06:53:38.448]                       })
  [06:53:38.448]                       tryCatch({
  [06:53:38.448]                         if (i%%2 == 0) 
  [06:53:38.448]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:38.448]                             i))
  [06:53:38.448]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:38.448]                       }, error = identity)
  [06:53:38.448]                     })
  [06:53:38.448]                   }
  [06:53:38.448]                 }, immediateCondition = function(cond) {
  [06:53:38.448]                   sendCondition <- ...future.sendCondition()
  [06:53:38.448]                   sendCondition(cond)
  [06:53:38.448]                   muffleCondition <- function (cond) 
  [06:53:38.448]                   {
  [06:53:38.448]                     inherits <- base::inherits
  [06:53:38.448]                     invokeRestart <- base::invokeRestart
  [06:53:38.448]                     muffled <- FALSE
  [06:53:38.448]                     if (inherits(cond, "message")) {
  [06:53:38.448]                       invokeRestart("muffleMessage")
  [06:53:38.448]                       muffled <- TRUE
  [06:53:38.448]                     }
  [06:53:38.448]                     else if (inherits(cond, "warning")) {
  [06:53:38.448]                       invokeRestart("muffleWarning")
  [06:53:38.448]                       muffled <- TRUE
  [06:53:38.448]                     }
  [06:53:38.448]                     else if (inherits(cond, "condition")) {
  [06:53:38.448]                       computeRestarts <- base::computeRestarts
  [06:53:38.448]                       grepl <- base::grepl
  [06:53:38.448]                       is.null <- base::is.null
  [06:53:38.448]                       restarts <- computeRestarts(cond)
  [06:53:38.448]                       for (restart in restarts) {
  [06:53:38.448]                         name <- restart$name
  [06:53:38.448]                         if (is.null(name)) 
  [06:53:38.448]                           next
  [06:53:38.448]                         if (!grepl("^muffle", name)) 
  [06:53:38.448]                           next
  [06:53:38.448]                         invokeRestart(restart)
  [06:53:38.448]                         muffled <- TRUE
  [06:53:38.448]                         break
  [06:53:38.448]                       }
  [06:53:38.448]                     }
  [06:53:38.448]                     invisible(muffled)
  [06:53:38.448]                   }
  [06:53:38.448]                   muffleCondition(cond)
  [06:53:38.448]                 })
  [06:53:38.448]             }))
  [06:53:38.448]             future::FutureResult(value = ...future.value$value, 
  [06:53:38.448]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.448]                   ...future.rng), started = ...future.startTime, 
  [06:53:38.448]                 version = "1.8")
  [06:53:38.448]         }, condition = base::local({
  [06:53:38.448]             c <- base::c
  [06:53:38.448]             inherits <- base::inherits
  [06:53:38.448]             invokeRestart <- base::invokeRestart
  [06:53:38.448]             length <- base::length
  [06:53:38.448]             list <- base::list
  [06:53:38.448]             seq.int <- base::seq.int
  [06:53:38.448]             signalCondition <- base::signalCondition
  [06:53:38.448]             sys.calls <- base::sys.calls
  [06:53:38.448]             Sys.time <- base::Sys.time
  [06:53:38.448]             `[[` <- base::`[[`
  [06:53:38.448]             `+` <- base::`+`
  [06:53:38.448]             `<<-` <- base::`<<-`
  [06:53:38.448]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:38.448]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:38.448]                   3L)]
  [06:53:38.448]             }
  [06:53:38.448]             function(cond) {
  [06:53:38.448]                 if (inherits(cond, "error")) {
  [06:53:38.448]                   sessionInformation <- function() {
  [06:53:38.448]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:38.448]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:38.448]                       search = base::search(), system = base::Sys.info())
  [06:53:38.448]                   }
  [06:53:38.448]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.448]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:38.448]                     cond$call), session = sessionInformation(), 
  [06:53:38.448]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:38.448]                   signalCondition(cond)
  [06:53:38.448]                 }
  [06:53:38.448]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:38.448]                 ))) {
  [06:53:38.448]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:38.448]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.448]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:38.448]                   if (!signal) {
  [06:53:38.448]                     muffleCondition <- function (cond) 
  [06:53:38.448]                     {
  [06:53:38.448]                       inherits <- base::inherits
  [06:53:38.448]                       invokeRestart <- base::invokeRestart
  [06:53:38.448]                       muffled <- FALSE
  [06:53:38.448]                       if (inherits(cond, "message")) {
  [06:53:38.448]                         invokeRestart("muffleMessage")
  [06:53:38.448]                         muffled <- TRUE
  [06:53:38.448]                       }
  [06:53:38.448]                       else if (inherits(cond, "warning")) {
  [06:53:38.448]                         invokeRestart("muffleWarning")
  [06:53:38.448]                         muffled <- TRUE
  [06:53:38.448]                       }
  [06:53:38.448]                       else if (inherits(cond, "condition")) {
  [06:53:38.448]                         computeRestarts <- base::computeRestarts
  [06:53:38.448]                         grepl <- base::grepl
  [06:53:38.448]                         is.null <- base::is.null
  [06:53:38.448]                         restarts <- computeRestarts(cond)
  [06:53:38.448]                         for (restart in restarts) {
  [06:53:38.448]                           name <- restart$name
  [06:53:38.448]                           if (is.null(name)) 
  [06:53:38.448]                             next
  [06:53:38.448]                           if (!grepl("^muffle", name)) 
  [06:53:38.448]                             next
  [06:53:38.448]                           invokeRestart(restart)
  [06:53:38.448]                           muffled <- TRUE
  [06:53:38.448]                           break
  [06:53:38.448]                         }
  [06:53:38.448]                       }
  [06:53:38.448]                       invisible(muffled)
  [06:53:38.448]                     }
  [06:53:38.448]                     muffleCondition(cond)
  [06:53:38.448]                   }
  [06:53:38.448]                 }
  [06:53:38.448]             }
  [06:53:38.448]         }))
  [06:53:38.448]     }, error = function(ex) {
  [06:53:38.448]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:38.448]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.448]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:38.448]     }, finally = {
  [06:53:38.448]         {
  [06:53:38.448]             NULL
  [06:53:38.448]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:38.448]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:38.448]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:38.448]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:38.448]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:38.448]                 ...) 
  [06:53:38.448]             {
  [06:53:38.448]                 if (substitute) 
  [06:53:38.448]                   expr <- substitute(expr)
  [06:53:38.448]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:38.448]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:38.448]                   globals = globals, persistent = persistent, 
  [06:53:38.448]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:38.448]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:38.448]                   label = label, ...)
  [06:53:38.448]                 if (!future$lazy) 
  [06:53:38.448]                   future <- run(future)
  [06:53:38.448]                 invisible(future)
  [06:53:38.448]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:38.448]         }
  [06:53:38.448]         base::options(...future.oldOptions)
  [06:53:38.448]     })
  [06:53:38.448]     Sys.time
  [06:53:38.448]     if (base::is.na(TRUE)) {
  [06:53:38.448]     }
  [06:53:38.448]     else {
  [06:53:38.448]         base::sink(type = "output", split = FALSE)
  [06:53:38.448]         if (TRUE) {
  [06:53:38.448]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:38.448]         }
  [06:53:38.448]         else {
  [06:53:38.448]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:38.448]         }
  [06:53:38.448]         base::close(...future.stdout)
  [06:53:38.448]         ...future.stdout <- NULL
  [06:53:38.448]     }
  [06:53:38.448]     ...future.result$conditions <- ...future.conditions
  [06:53:38.448]     ...future.result
  [06:53:38.448] }
  [06:53:38.455] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [06:53:38.455] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [06:53:38.456] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [06:53:38.457] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [06:53:38.458] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [06:53:38.458] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [06:53:38.459] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [06:53:38.460] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [06:53:38.461] ClusterFuture started
  [06:53:38.462] Chunk #1 of 2 ... DONE
  [06:53:38.462] Chunk #2 of 2 ...
  [06:53:38.463]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:38.463] getGlobalsAndPackages() ...
  [06:53:38.463] Searching for globals...
  [06:53:38.465] 
  [06:53:38.465] Searching for globals ... DONE
  [06:53:38.466] - globals: [0] <none>
  [06:53:38.466] getGlobalsAndPackages() ... DONE
  [06:53:38.466] 
  [06:53:38.467] 
  [06:53:38.467]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:38.470] getGlobalsAndPackages() ...
  [06:53:38.470] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.471] Resolving globals: FALSE
  [06:53:38.472] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:38.473] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:38.473] 
  [06:53:38.474] getGlobalsAndPackages() ... DONE
  [06:53:38.494] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:38.495] Packages needed by future strategies (n = 0): <none>
  [06:53:38.502] {
  [06:53:38.502]     {
  [06:53:38.502]         ...future.startTime <- base::Sys.time()
  [06:53:38.502]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:38.502]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:38.502]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:38.502]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:38.502]             future.resolve.recursive = NULL, width = 80L)
  [06:53:38.502]         {
  [06:53:38.502]             {
  [06:53:38.502]                 {
  [06:53:38.502]                   base::local({
  [06:53:38.502]                     has_future <- base::requireNamespace("future", 
  [06:53:38.502]                       quietly = TRUE)
  [06:53:38.502]                     version <- if (has_future) 
  [06:53:38.502]                       utils::packageVersion("future")
  [06:53:38.502]                     else NULL
  [06:53:38.502]                     if (!has_future || version < "1.8.0") {
  [06:53:38.502]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:38.502]                         "", base::R.version$version.string), 
  [06:53:38.502]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:38.502]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:38.502]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:38.502]                           "release", "version")], collapse = " "), 
  [06:53:38.502]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:38.502]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:38.502]                         info)
  [06:53:38.502]                       info <- base::paste(info, collapse = "; ")
  [06:53:38.502]                       if (!has_future) {
  [06:53:38.502]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:38.502]                           info)
  [06:53:38.502]                       }
  [06:53:38.502]                       else {
  [06:53:38.502]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:38.502]                           info, version)
  [06:53:38.502]                       }
  [06:53:38.502]                       base::stop(msg)
  [06:53:38.502]                     }
  [06:53:38.502]                   })
  [06:53:38.502]                 }
  [06:53:38.502]                 base::local({
  [06:53:38.502]                   for (pkg in c("doFuture", "stats")) {
  [06:53:38.502]                     base::loadNamespace(pkg)
  [06:53:38.502]                     base::library(pkg, character.only = TRUE)
  [06:53:38.502]                   }
  [06:53:38.502]                 })
  [06:53:38.502]             }
  [06:53:38.502]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:38.502]         }
  [06:53:38.502]     }
  [06:53:38.502]     if (base::is.na(TRUE)) {
  [06:53:38.502]     }
  [06:53:38.502]     else {
  [06:53:38.502]         if (TRUE) {
  [06:53:38.502]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:38.502]                 open = "w")
  [06:53:38.502]         }
  [06:53:38.502]         else {
  [06:53:38.502]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:38.502]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:38.502]         }
  [06:53:38.502]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:38.502]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:38.502]             base::sink(type = "output", split = FALSE)
  [06:53:38.502]             base::close(...future.stdout)
  [06:53:38.502]         }, add = TRUE)
  [06:53:38.502]     }
  [06:53:38.502]     ...future.frame <- base::sys.nframe()
  [06:53:38.502]     ...future.conditions <- base::list()
  [06:53:38.502]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:38.502]     ...future.result <- base::tryCatch({
  [06:53:38.502]         base::withCallingHandlers({
  [06:53:38.502]             ...future.value <- base::withVisible(base::local({
  [06:53:38.502]                 ...future.sendCondition <- local({
  [06:53:38.502]                   sendCondition <- NULL
  [06:53:38.502]                   function(frame = 1L) {
  [06:53:38.502]                     if (is.function(sendCondition)) 
  [06:53:38.502]                       return(sendCondition)
  [06:53:38.502]                     ns <- getNamespace("parallel")
  [06:53:38.502]                     if (exists("sendData", mode = "function", 
  [06:53:38.502]                       envir = ns)) {
  [06:53:38.502]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:38.502]                         envir = ns)
  [06:53:38.502]                       envir <- sys.frame(frame)
  [06:53:38.502]                       master <- NULL
  [06:53:38.502]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:38.502]                         !identical(envir, emptyenv())) {
  [06:53:38.502]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:38.502]                           inherits = FALSE)) {
  [06:53:38.502]                           master <- get("master", mode = "list", 
  [06:53:38.502]                             envir = envir, inherits = FALSE)
  [06:53:38.502]                           if (inherits(master, "SOCKnode")) {
  [06:53:38.502]                             sendCondition <<- function(cond) {
  [06:53:38.502]                               data <- list(type = "VALUE", value = cond, 
  [06:53:38.502]                                 success = TRUE)
  [06:53:38.502]                               parallel_sendData(master, data)
  [06:53:38.502]                             }
  [06:53:38.502]                             return(sendCondition)
  [06:53:38.502]                           }
  [06:53:38.502]                         }
  [06:53:38.502]                         frame <- frame + 1L
  [06:53:38.502]                         envir <- sys.frame(frame)
  [06:53:38.502]                       }
  [06:53:38.502]                     }
  [06:53:38.502]                     sendCondition <<- function(cond) NULL
  [06:53:38.502]                   }
  [06:53:38.502]                 })
  [06:53:38.502]                 withCallingHandlers({
  [06:53:38.502]                   {
  [06:53:38.502]                     doFuture::registerDoFuture()
  [06:53:38.502]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:38.502]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:38.502]                       i <- NULL
  [06:53:38.502]                       ...future.env <- environment()
  [06:53:38.502]                       local({
  [06:53:38.502]                         for (name in names(...future.x_jj)) {
  [06:53:38.502]                           assign(name, ...future.x_jj[[name]], 
  [06:53:38.502]                             envir = ...future.env, inherits = FALSE)
  [06:53:38.502]                         }
  [06:53:38.502]                       })
  [06:53:38.502]                       tryCatch({
  [06:53:38.502]                         if (i%%2 == 0) 
  [06:53:38.502]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [06:53:38.502]                             i))
  [06:53:38.502]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:38.502]                       }, error = identity)
  [06:53:38.502]                     })
  [06:53:38.502]                   }
  [06:53:38.502]                 }, immediateCondition = function(cond) {
  [06:53:38.502]                   sendCondition <- ...future.sendCondition()
  [06:53:38.502]                   sendCondition(cond)
  [06:53:38.502]                   muffleCondition <- function (cond) 
  [06:53:38.502]                   {
  [06:53:38.502]                     inherits <- base::inherits
  [06:53:38.502]                     invokeRestart <- base::invokeRestart
  [06:53:38.502]                     muffled <- FALSE
  [06:53:38.502]                     if (inherits(cond, "message")) {
  [06:53:38.502]                       invokeRestart("muffleMessage")
  [06:53:38.502]                       muffled <- TRUE
  [06:53:38.502]                     }
  [06:53:38.502]                     else if (inherits(cond, "warning")) {
  [06:53:38.502]                       invokeRestart("muffleWarning")
  [06:53:38.502]                       muffled <- TRUE
  [06:53:38.502]                     }
  [06:53:38.502]                     else if (inherits(cond, "condition")) {
  [06:53:38.502]                       computeRestarts <- base::computeRestarts
  [06:53:38.502]                       grepl <- base::grepl
  [06:53:38.502]                       is.null <- base::is.null
  [06:53:38.502]                       restarts <- computeRestarts(cond)
  [06:53:38.502]                       for (restart in restarts) {
  [06:53:38.502]                         name <- restart$name
  [06:53:38.502]                         if (is.null(name)) 
  [06:53:38.502]                           next
  [06:53:38.502]                         if (!grepl("^muffle", name)) 
  [06:53:38.502]                           next
  [06:53:38.502]                         invokeRestart(restart)
  [06:53:38.502]                         muffled <- TRUE
  [06:53:38.502]                         break
  [06:53:38.502]                       }
  [06:53:38.502]                     }
  [06:53:38.502]                     invisible(muffled)
  [06:53:38.502]                   }
  [06:53:38.502]                   muffleCondition(cond)
  [06:53:38.502]                 })
  [06:53:38.502]             }))
  [06:53:38.502]             future::FutureResult(value = ...future.value$value, 
  [06:53:38.502]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.502]                   ...future.rng), started = ...future.startTime, 
  [06:53:38.502]                 version = "1.8")
  [06:53:38.502]         }, condition = base::local({
  [06:53:38.502]             c <- base::c
  [06:53:38.502]             inherits <- base::inherits
  [06:53:38.502]             invokeRestart <- base::invokeRestart
  [06:53:38.502]             length <- base::length
  [06:53:38.502]             list <- base::list
  [06:53:38.502]             seq.int <- base::seq.int
  [06:53:38.502]             signalCondition <- base::signalCondition
  [06:53:38.502]             sys.calls <- base::sys.calls
  [06:53:38.502]             Sys.time <- base::Sys.time
  [06:53:38.502]             `[[` <- base::`[[`
  [06:53:38.502]             `+` <- base::`+`
  [06:53:38.502]             `<<-` <- base::`<<-`
  [06:53:38.502]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:38.502]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:38.502]                   3L)]
  [06:53:38.502]             }
  [06:53:38.502]             function(cond) {
  [06:53:38.502]                 if (inherits(cond, "error")) {
  [06:53:38.502]                   sessionInformation <- function() {
  [06:53:38.502]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:38.502]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:38.502]                       search = base::search(), system = base::Sys.info())
  [06:53:38.502]                   }
  [06:53:38.502]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.502]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:38.502]                     cond$call), session = sessionInformation(), 
  [06:53:38.502]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:38.502]                   signalCondition(cond)
  [06:53:38.502]                 }
  [06:53:38.502]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:38.502]                 ))) {
  [06:53:38.502]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:38.502]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:38.502]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:38.502]                   if (!signal) {
  [06:53:38.502]                     muffleCondition <- function (cond) 
  [06:53:38.502]                     {
  [06:53:38.502]                       inherits <- base::inherits
  [06:53:38.502]                       invokeRestart <- base::invokeRestart
  [06:53:38.502]                       muffled <- FALSE
  [06:53:38.502]                       if (inherits(cond, "message")) {
  [06:53:38.502]                         invokeRestart("muffleMessage")
  [06:53:38.502]                         muffled <- TRUE
  [06:53:38.502]                       }
  [06:53:38.502]                       else if (inherits(cond, "warning")) {
  [06:53:38.502]                         invokeRestart("muffleWarning")
  [06:53:38.502]                         muffled <- TRUE
  [06:53:38.502]                       }
  [06:53:38.502]                       else if (inherits(cond, "condition")) {
  [06:53:38.502]                         computeRestarts <- base::computeRestarts
  [06:53:38.502]                         grepl <- base::grepl
  [06:53:38.502]                         is.null <- base::is.null
  [06:53:38.502]                         restarts <- computeRestarts(cond)
  [06:53:38.502]                         for (restart in restarts) {
  [06:53:38.502]                           name <- restart$name
  [06:53:38.502]                           if (is.null(name)) 
  [06:53:38.502]                             next
  [06:53:38.502]                           if (!grepl("^muffle", name)) 
  [06:53:38.502]                             next
  [06:53:38.502]                           invokeRestart(restart)
  [06:53:38.502]                           muffled <- TRUE
  [06:53:38.502]                           break
  [06:53:38.502]                         }
  [06:53:38.502]                       }
  [06:53:38.502]                       invisible(muffled)
  [06:53:38.502]                     }
  [06:53:38.502]                     muffleCondition(cond)
  [06:53:38.502]                   }
  [06:53:38.502]                 }
  [06:53:38.502]             }
  [06:53:38.502]         }))
  [06:53:38.502]     }, error = function(ex) {
  [06:53:38.502]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:38.502]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:38.502]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:38.502]     }, finally = {
  [06:53:38.502]         {
  [06:53:38.502]             NULL
  [06:53:38.502]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:38.502]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:38.502]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:38.502]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:38.502]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:38.502]                 ...) 
  [06:53:38.502]             {
  [06:53:38.502]                 if (substitute) 
  [06:53:38.502]                   expr <- substitute(expr)
  [06:53:38.502]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:38.502]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:38.502]                   globals = globals, persistent = persistent, 
  [06:53:38.502]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:38.502]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:38.502]                   label = label, ...)
  [06:53:38.502]                 if (!future$lazy) 
  [06:53:38.502]                   future <- run(future)
  [06:53:38.502]                 invisible(future)
  [06:53:38.502]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:38.502]         }
  [06:53:38.502]         base::options(...future.oldOptions)
  [06:53:38.502]     })
  [06:53:38.502]     Sys.time
  [06:53:38.502]     if (base::is.na(TRUE)) {
  [06:53:38.502]     }
  [06:53:38.502]     else {
  [06:53:38.502]         base::sink(type = "output", split = FALSE)
  [06:53:38.502]         if (TRUE) {
  [06:53:38.502]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:38.502]         }
  [06:53:38.502]         else {
  [06:53:38.502]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:38.502]         }
  [06:53:38.502]         base::close(...future.stdout)
  [06:53:38.502]         ...future.stdout <- NULL
  [06:53:38.502]     }
  [06:53:38.502]     ...future.result$conditions <- ...future.conditions
  [06:53:38.502]     ...future.result
  [06:53:38.502] }
  [06:53:38.525] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [06:53:38.526] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [06:53:38.527] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [06:53:38.527] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [06:53:38.543] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [06:53:38.543] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [06:53:38.544] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [06:53:38.545] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [06:53:38.546] ClusterFuture started
  [06:53:38.547] Chunk #2 of 2 ... DONE
  [06:53:38.547] Launching 2 futures (chunks) ... DONE
  [06:53:38.548] - resolving futures
  [06:53:38.548]   - gathering results & relaying conditions (except errors)
  [06:53:38.548] resolve() on list ...
  [06:53:38.549]  recursive: 0
  [06:53:38.549]  length: 2
  [06:53:38.549] 
  [06:53:38.699] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:38.700] - Validating connection of ClusterFuture
  [06:53:38.701] - received message: FutureResult
  [06:53:38.701] - Received FutureResult
  [06:53:38.702] - Erased future from FutureRegistry
  [06:53:38.702] result() for ClusterFuture ...
  [06:53:38.703] - result already collected: FutureResult
  [06:53:38.708] result() for ClusterFuture ... done
  [06:53:38.709] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:38.709] Future #1
  [06:53:38.709] result() for ClusterFuture ...
  [06:53:38.710] - result already collected: FutureResult
  [06:53:38.710] result() for ClusterFuture ... done
  [06:53:38.711] result() for ClusterFuture ...
  [06:53:38.711] - result already collected: FutureResult
  [06:53:38.712] result() for ClusterFuture ... done
  [06:53:38.712] signalConditionsASAP(ClusterFuture, pos=1) ...
  [06:53:38.712] - nx: 2
  [06:53:38.713] - relay: TRUE
  [06:53:38.713] - stdout: TRUE
  [06:53:38.713] - signal: TRUE
  [06:53:38.714] - resignal: FALSE
  [06:53:38.714] - force: FALSE
  [06:53:38.715] - relayed: [n=2] FALSE, FALSE
  [06:53:38.715] - queued futures: [n=2] FALSE, FALSE
  [06:53:38.716]  - until=1
  [06:53:38.716]  - relaying element #1
  [06:53:38.716] result() for ClusterFuture ...
  [06:53:38.717] - result already collected: FutureResult
  [06:53:38.717] result() for ClusterFuture ... done
  [06:53:38.718] result() for ClusterFuture ...
  [06:53:38.718] - result already collected: FutureResult
  [06:53:38.719] result() for ClusterFuture ... done
  [06:53:38.719] result() for ClusterFuture ...
  [06:53:38.720] - result already collected: FutureResult
  [06:53:38.720] result() for ClusterFuture ... done
  [06:53:38.720] result() for ClusterFuture ...
  [06:53:38.721] - result already collected: FutureResult
  [06:53:38.721] result() for ClusterFuture ... done
  [06:53:38.722] - relayed: [n=2] TRUE, FALSE
  [06:53:38.722] - queued futures: [n=2] TRUE, FALSE
  [06:53:38.722] signalConditionsASAP(ClusterFuture, pos=1) ... done
  [06:53:38.723]  length: 1 (resolved future 1)
  [06:53:38.901] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:38.901] - Validating connection of ClusterFuture
  [06:53:38.902] - received message: FutureResult
  [06:53:38.902] - Received FutureResult
  [06:53:38.903] - Erased future from FutureRegistry
  [06:53:38.903] result() for ClusterFuture ...
  [06:53:38.904] - result already collected: FutureResult
  [06:53:38.904] result() for ClusterFuture ... done
  [06:53:38.905] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:38.905] Future #2
  [06:53:38.906] result() for ClusterFuture ...
  [06:53:38.906] - result already collected: FutureResult
  [06:53:38.907] result() for ClusterFuture ... done
  [06:53:38.907] result() for ClusterFuture ...
  [06:53:38.907] - result already collected: FutureResult
  [06:53:38.908] result() for ClusterFuture ... done
  [06:53:38.908] signalConditionsASAP(ClusterFuture, pos=2) ...
  [06:53:38.909] - nx: 2
  [06:53:38.909] - relay: TRUE
  [06:53:38.909] - stdout: TRUE
  [06:53:38.910] - signal: TRUE
  [06:53:38.910] - resignal: FALSE
  [06:53:38.911] - force: FALSE
  [06:53:38.911] - relayed: [n=2] TRUE, FALSE
  [06:53:38.911] - queued futures: [n=2] TRUE, FALSE
  [06:53:38.912]  - until=2
  [06:53:38.912]  - relaying element #2
  [06:53:38.913] result() for ClusterFuture ...
  [06:53:38.913] - result already collected: FutureResult
  [06:53:38.914] result() for ClusterFuture ... done
  [06:53:38.917] result() for ClusterFuture ...
  [06:53:38.917] - result already collected: FutureResult
  [06:53:38.918] result() for ClusterFuture ... done
  [06:53:38.918] result() for ClusterFuture ...
  [06:53:38.919] - result already collected: FutureResult
  [06:53:38.919] result() for ClusterFuture ... done
  [06:53:38.920] result() for ClusterFuture ...
  [06:53:38.920] - result already collected: FutureResult
  [06:53:38.920] result() for ClusterFuture ... done
  [06:53:38.921] - relayed: [n=2] TRUE, TRUE
  [06:53:38.921] - queued futures: [n=2] TRUE, TRUE
  [06:53:38.922] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [06:53:38.922]  length: 0 (resolved future 2)
  [06:53:38.923] Relaying remaining futures
  [06:53:38.923] signalConditionsASAP(NULL, pos=0) ...
  [06:53:38.923] - nx: 2
  [06:53:38.924] - relay: TRUE
  [06:53:38.924] - stdout: TRUE
  [06:53:38.924] - signal: TRUE
  [06:53:38.925] - resignal: FALSE
  [06:53:38.925] - force: FALSE
  [06:53:38.926] - relayed: [n=2] TRUE, TRUE
  [06:53:38.926] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:38.927] - relayed: [n=2] TRUE, TRUE
  [06:53:38.927] - queued futures: [n=2] TRUE, TRUE
  [06:53:38.928] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:38.928] resolve() on list ... DONE
  [06:53:38.928] - collecting values of futures
  [06:53:38.929] result() for ClusterFuture ...
  [06:53:38.929] - result already collected: FutureResult
  [06:53:38.930] result() for ClusterFuture ... done
  [06:53:38.930] result() for ClusterFuture ...
  [06:53:38.931] - result already collected: FutureResult
  [06:53:38.931] result() for ClusterFuture ... done
  [06:53:38.932] result() for ClusterFuture ...
  [06:53:38.932] - result already collected: FutureResult
  [06:53:38.933] result() for ClusterFuture ... done
  [06:53:38.933] result() for ClusterFuture ...
  [06:53:38.933] - result already collected: FutureResult
  [06:53:38.934] result() for ClusterFuture ... done
  [06:53:38.935] - accumulating results
  [06:53:38.938] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('cluster') ... DONE
  > 
  > message("*** doFuture() - error handling w/ 'stop' ... DONE")
  *** doFuture() - error handling w/ 'stop' ... DONE
  > 
  > 
  > message("*** doFuture() - error handling w/ 'pass' ...")
  *** doFuture() - error handling w/ 'pass' ...
  > 
  > for (strategy in strategies) {
  +   message(sprintf("- plan('%s') ...", strategy))
  +   plan(strategy)
  + 
  +   mu <- 1.0
  +   sigma <- 2.0
  +   res <- foreach(i = 1:10, .errorhandling = "pass") %dopar% {
  +     if (i %% 2 == 0) stop(sprintf("Index error ('pass'), because i = %d", i))
  +     dnorm(i, mean = mu, sd = sigma)
  +   }
  +   str(res)
  + 
  +   message(sprintf("- plan('%s') ... DONE", strategy))
  + } ## for (strategy ...)
  - plan('sequential') ...
  [06:53:38.980] plan(): Setting new future strategy stack:
  [06:53:38.980] List of future strategies:
  [06:53:38.980] 1. sequential:
  [06:53:38.980]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:38.980]    - tweaked: FALSE
  [06:53:38.980]    - call: plan(strategy)
  [06:53:38.987] plan(): nbrOfWorkers() = 1
  [06:53:38.988] doFuture() ...
  [06:53:38.991] - dummy globals (as locals): [1] 'i'
  [06:53:38.993] - R expression:
  [06:53:38.993] {
  [06:53:38.993]     doFuture::registerDoFuture()
  [06:53:38.993]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:38.993]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:38.993]         i <- NULL
  [06:53:38.993]         ...future.env <- environment()
  [06:53:38.993]         local({
  [06:53:38.993]             for (name in names(...future.x_jj)) {
  [06:53:38.993]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:38.993]                   inherits = FALSE)
  [06:53:38.993]             }
  [06:53:38.993]         })
  [06:53:38.993]         tryCatch({
  [06:53:38.993]             if (i%%2 == 0) 
  [06:53:38.993]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:38.993]                   i))
  [06:53:38.993]             dnorm(i, mean = mu, sd = sigma)
  [06:53:38.993]         }, error = identity)
  [06:53:38.993]     })
  [06:53:38.993] }
  [06:53:38.994] - identifying globals and packages ...
  [06:53:38.995] getGlobalsAndPackages() ...
  [06:53:38.996] Searching for globals...
  [06:53:39.021] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:39.021] Searching for globals ... DONE
  [06:53:39.022] Resolving globals: FALSE
  [06:53:39.024] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:39.025] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.026] - packages: [1] 'stats'
  [06:53:39.026] getGlobalsAndPackages() ... DONE
  [06:53:39.027] List of 3
  [06:53:39.027]  $ ...future.x_ii: NULL
  [06:53:39.027]  $ mu            : num 1
  [06:53:39.027]  $ sigma         : num 2
  [06:53:39.027]  - attr(*, "where")=List of 3
  [06:53:39.027]   ..$ ...future.x_ii:<environment: 0x5575fefe9a28> 
  [06:53:39.027]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:39.027]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:39.027]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:39.027]  - attr(*, "resolved")= logi FALSE
  [06:53:39.027]  - attr(*, "total_size")= num 112
  [06:53:39.052]   - R expression:
  [06:53:39.052] {
  [06:53:39.052]     doFuture::registerDoFuture()
  [06:53:39.052]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.052]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.052]         i <- NULL
  [06:53:39.052]         ...future.env <- environment()
  [06:53:39.052]         local({
  [06:53:39.052]             for (name in names(...future.x_jj)) {
  [06:53:39.052]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.052]                   inherits = FALSE)
  [06:53:39.052]             }
  [06:53:39.052]         })
  [06:53:39.052]         tryCatch({
  [06:53:39.052]             if (i%%2 == 0) 
  [06:53:39.052]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.052]                   i))
  [06:53:39.052]             dnorm(i, mean = mu, sd = sigma)
  [06:53:39.052]         }, error = identity)
  [06:53:39.052]     })
  [06:53:39.052] }
  [06:53:39.053]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.054] List of 3
  [06:53:39.054]  $ ...future.x_ii: NULL
  [06:53:39.054]  $ mu            : num 1
  [06:53:39.054]  $ sigma         : num 2
  [06:53:39.054]  - attr(*, "where")=List of 3
  [06:53:39.054]   ..$ ...future.x_ii:<environment: 0x5575fefe9a28> 
  [06:53:39.054]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:39.054]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:39.054]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:39.054]  - attr(*, "resolved")= logi FALSE
  [06:53:39.054]  - attr(*, "total_size")= num 112
  [06:53:39.075]   - packages: [2] 'doFuture', 'stats'
  [06:53:39.075] - identifying globals and packages ... DONE
  [06:53:39.076] Number of chunks: 1
  [06:53:39.076] Number of futures (= number of chunks): 1
  [06:53:39.077] Launching 1 futures (chunks) ...
  [06:53:39.078] Chunk #1 of 1 ...
  [06:53:39.078]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:39.079] getGlobalsAndPackages() ...
  [06:53:39.079] Searching for globals...
  [06:53:39.081] 
  [06:53:39.081] Searching for globals ... DONE
  [06:53:39.082] - globals: [0] <none>
  [06:53:39.082] getGlobalsAndPackages() ... DONE
  [06:53:39.082] 
  [06:53:39.083] 
  [06:53:39.083]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:39.084] getGlobalsAndPackages() ...
  [06:53:39.084] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.085] Resolving globals: FALSE
  [06:53:39.086] The total size of the 3 globals is 672 bytes (672 bytes)
  [06:53:39.087] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.087] 
  [06:53:39.088] getGlobalsAndPackages() ... DONE
  [06:53:39.091] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:39.091] Packages needed by future strategies (n = 0): <none>
  [06:53:39.100] {
  [06:53:39.100]     {
  [06:53:39.100]         ...future.startTime <- base::Sys.time()
  [06:53:39.100]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:39.100]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:39.100]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:39.100]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:39.100]             future.resolve.recursive = NULL, width = 80L)
  [06:53:39.100]         {
  [06:53:39.100]             {
  [06:53:39.100]                 {
  [06:53:39.100]                   base::local({
  [06:53:39.100]                     has_future <- base::requireNamespace("future", 
  [06:53:39.100]                       quietly = TRUE)
  [06:53:39.100]                     version <- if (has_future) 
  [06:53:39.100]                       utils::packageVersion("future")
  [06:53:39.100]                     else NULL
  [06:53:39.100]                     if (!has_future || version < "1.8.0") {
  [06:53:39.100]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:39.100]                         "", base::R.version$version.string), 
  [06:53:39.100]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:39.100]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:39.100]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:39.100]                           "release", "version")], collapse = " "), 
  [06:53:39.100]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:39.100]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:39.100]                         info)
  [06:53:39.100]                       info <- base::paste(info, collapse = "; ")
  [06:53:39.100]                       if (!has_future) {
  [06:53:39.100]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:39.100]                           info)
  [06:53:39.100]                       }
  [06:53:39.100]                       else {
  [06:53:39.100]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:39.100]                           info, version)
  [06:53:39.100]                       }
  [06:53:39.100]                       base::stop(msg)
  [06:53:39.100]                     }
  [06:53:39.100]                   })
  [06:53:39.100]                 }
  [06:53:39.100]                 base::local({
  [06:53:39.100]                   for (pkg in c("doFuture", "stats")) {
  [06:53:39.100]                     base::loadNamespace(pkg)
  [06:53:39.100]                     base::library(pkg, character.only = TRUE)
  [06:53:39.100]                   }
  [06:53:39.100]                 })
  [06:53:39.100]             }
  [06:53:39.100]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:39.100]         }
  [06:53:39.100]     }
  [06:53:39.100]     if (base::is.na(TRUE)) {
  [06:53:39.100]     }
  [06:53:39.100]     else {
  [06:53:39.100]         if (TRUE) {
  [06:53:39.100]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:39.100]                 open = "w")
  [06:53:39.100]         }
  [06:53:39.100]         else {
  [06:53:39.100]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:39.100]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:39.100]         }
  [06:53:39.100]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:39.100]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:39.100]             base::sink(type = "output", split = FALSE)
  [06:53:39.100]             base::close(...future.stdout)
  [06:53:39.100]         }, add = TRUE)
  [06:53:39.100]     }
  [06:53:39.100]     ...future.frame <- base::sys.nframe()
  [06:53:39.100]     ...future.conditions <- base::list()
  [06:53:39.100]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:39.100]     ...future.result <- base::tryCatch({
  [06:53:39.100]         base::withCallingHandlers({
  [06:53:39.100]             ...future.value <- base::withVisible(base::local({
  [06:53:39.100]                 doFuture::registerDoFuture()
  [06:53:39.100]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.100]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.100]                   i <- NULL
  [06:53:39.100]                   ...future.env <- environment()
  [06:53:39.100]                   local({
  [06:53:39.100]                     for (name in names(...future.x_jj)) {
  [06:53:39.100]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.100]                         inherits = FALSE)
  [06:53:39.100]                     }
  [06:53:39.100]                   })
  [06:53:39.100]                   tryCatch({
  [06:53:39.100]                     if (i%%2 == 0) 
  [06:53:39.100]                       stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.100]                         i))
  [06:53:39.100]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:39.100]                   }, error = identity)
  [06:53:39.100]                 })
  [06:53:39.100]             }))
  [06:53:39.100]             future::FutureResult(value = ...future.value$value, 
  [06:53:39.100]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.100]                   ...future.rng), started = ...future.startTime, 
  [06:53:39.100]                 version = "1.8")
  [06:53:39.100]         }, condition = base::local({
  [06:53:39.100]             c <- base::c
  [06:53:39.100]             inherits <- base::inherits
  [06:53:39.100]             invokeRestart <- base::invokeRestart
  [06:53:39.100]             length <- base::length
  [06:53:39.100]             list <- base::list
  [06:53:39.100]             seq.int <- base::seq.int
  [06:53:39.100]             signalCondition <- base::signalCondition
  [06:53:39.100]             sys.calls <- base::sys.calls
  [06:53:39.100]             Sys.time <- base::Sys.time
  [06:53:39.100]             `[[` <- base::`[[`
  [06:53:39.100]             `+` <- base::`+`
  [06:53:39.100]             `<<-` <- base::`<<-`
  [06:53:39.100]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:39.100]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:39.100]                   3L)]
  [06:53:39.100]             }
  [06:53:39.100]             function(cond) {
  [06:53:39.100]                 if (inherits(cond, "error")) {
  [06:53:39.100]                   sessionInformation <- function() {
  [06:53:39.100]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:39.100]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:39.100]                       search = base::search(), system = base::Sys.info())
  [06:53:39.100]                   }
  [06:53:39.100]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.100]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:39.100]                     cond$call), session = sessionInformation(), 
  [06:53:39.100]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:39.100]                   signalCondition(cond)
  [06:53:39.100]                 }
  [06:53:39.100]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:39.100]                 ))) {
  [06:53:39.100]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:39.100]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.100]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:39.100]                   if (!signal) {
  [06:53:39.100]                     muffleCondition <- function (cond) 
  [06:53:39.100]                     {
  [06:53:39.100]                       inherits <- base::inherits
  [06:53:39.100]                       invokeRestart <- base::invokeRestart
  [06:53:39.100]                       muffled <- FALSE
  [06:53:39.100]                       if (inherits(cond, "message")) {
  [06:53:39.100]                         invokeRestart("muffleMessage")
  [06:53:39.100]                         muffled <- TRUE
  [06:53:39.100]                       }
  [06:53:39.100]                       else if (inherits(cond, "warning")) {
  [06:53:39.100]                         invokeRestart("muffleWarning")
  [06:53:39.100]                         muffled <- TRUE
  [06:53:39.100]                       }
  [06:53:39.100]                       else if (inherits(cond, "condition")) {
  [06:53:39.100]                         computeRestarts <- base::computeRestarts
  [06:53:39.100]                         grepl <- base::grepl
  [06:53:39.100]                         is.null <- base::is.null
  [06:53:39.100]                         restarts <- computeRestarts(cond)
  [06:53:39.100]                         for (restart in restarts) {
  [06:53:39.100]                           name <- restart$name
  [06:53:39.100]                           if (is.null(name)) 
  [06:53:39.100]                             next
  [06:53:39.100]                           if (!grepl("^muffle", name)) 
  [06:53:39.100]                             next
  [06:53:39.100]                           invokeRestart(restart)
  [06:53:39.100]                           muffled <- TRUE
  [06:53:39.100]                           break
  [06:53:39.100]                         }
  [06:53:39.100]                       }
  [06:53:39.100]                       invisible(muffled)
  [06:53:39.100]                     }
  [06:53:39.100]                     muffleCondition(cond)
  [06:53:39.100]                   }
  [06:53:39.100]                 }
  [06:53:39.100]             }
  [06:53:39.100]         }))
  [06:53:39.100]     }, error = function(ex) {
  [06:53:39.100]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:39.100]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.100]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:39.100]     }, finally = {
  [06:53:39.100]         {
  [06:53:39.100]             NULL
  [06:53:39.100]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:39.100]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:39.100]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [06:53:39.100]                 label = NULL, ...) 
  [06:53:39.100]             {
  [06:53:39.100]                 if (substitute) 
  [06:53:39.100]                   expr <- substitute(expr)
  [06:53:39.100]                 local <- as.logical(local)
  [06:53:39.100]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [06:53:39.100]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:39.100]                   globals = globals, local = local, earlySignal = earlySignal, 
  [06:53:39.100]                   label = label, ...)
  [06:53:39.100]                 if (!future$lazy) 
  [06:53:39.100]                   future <- run(future)
  [06:53:39.100]                 invisible(future)
  [06:53:39.100]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:39.100]         }
  [06:53:39.100]         base::options(...future.oldOptions)
  [06:53:39.100]     })
  [06:53:39.100]     Sys.time
  [06:53:39.100]     if (base::is.na(TRUE)) {
  [06:53:39.100]     }
  [06:53:39.100]     else {
  [06:53:39.100]         base::sink(type = "output", split = FALSE)
  [06:53:39.100]         if (TRUE) {
  [06:53:39.100]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:39.100]         }
  [06:53:39.100]         else {
  [06:53:39.100]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:39.100]         }
  [06:53:39.100]         base::close(...future.stdout)
  [06:53:39.100]         ...future.stdout <- NULL
  [06:53:39.100]     }
  [06:53:39.100]     ...future.result$conditions <- ...future.conditions
  [06:53:39.100]     ...future.result
  [06:53:39.100] }
  [06:53:39.108] plan(): Setting new future strategy stack:
  [06:53:39.108] List of future strategies:
  [06:53:39.108] 1. sequential:
  [06:53:39.108]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.108]    - tweaked: FALSE
  [06:53:39.108]    - call: NULL
  [06:53:39.110] plan(): nbrOfWorkers() = 1
  [06:53:39.140] plan(): Setting new future strategy stack:
  [06:53:39.141] List of future strategies:
  [06:53:39.141] 1. sequential:
  [06:53:39.141]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.141]    - tweaked: FALSE
  [06:53:39.141]    - call: plan(strategy)
  [06:53:39.142] plan(): nbrOfWorkers() = 1
  [06:53:39.143] SequentialFuture started (and completed)
  [06:53:39.144] Chunk #1 of 1 ... DONE
  [06:53:39.144] Launching 1 futures (chunks) ... DONE
  [06:53:39.145] - resolving futures
  [06:53:39.145]   - gathering results & relaying conditions (except errors)
  [06:53:39.145] resolve() on list ...
  [06:53:39.146]  recursive: 0
  [06:53:39.146]  length: 1
  [06:53:39.147] 
  [06:53:39.147] Future #1
  [06:53:39.148] signalConditionsASAP(SequentialFuture, pos=1) ...
  [06:53:39.148] - nx: 1
  [06:53:39.149] - relay: TRUE
  [06:53:39.149] - stdout: TRUE
  [06:53:39.155] - signal: TRUE
  [06:53:39.155] - resignal: FALSE
  [06:53:39.156] - force: FALSE
  [06:53:39.156] - relayed: [n=1] FALSE
  [06:53:39.156] - queued futures: [n=1] FALSE
  [06:53:39.157]  - until=1
  [06:53:39.157]  - relaying element #1
  [06:53:39.158] - relayed: [n=1] TRUE
  [06:53:39.158] - queued futures: [n=1] TRUE
  [06:53:39.159] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [06:53:39.159]  length: 0 (resolved future 1)
  [06:53:39.160] Relaying remaining futures
  [06:53:39.160] signalConditionsASAP(NULL, pos=0) ...
  [06:53:39.160] - nx: 1
  [06:53:39.161] - relay: TRUE
  [06:53:39.161] - stdout: TRUE
  [06:53:39.161] - signal: TRUE
  [06:53:39.162] - resignal: FALSE
  [06:53:39.162] - force: FALSE
  [06:53:39.163] - relayed: [n=1] TRUE
  [06:53:39.163] - queued futures: [n=1] TRUE
   - flush all
  [06:53:39.164] - relayed: [n=1] TRUE
  [06:53:39.164] - queued futures: [n=1] TRUE
  [06:53:39.164] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:39.165] resolve() on list ... DONE
  [06:53:39.165] - collecting values of futures
  [06:53:39.166] - accumulating results
  [06:53:39.169] - processing errors (handler = 'pass')
  [06:53:39.170] - extracting results
  [06:53:39.170] doFuture() ... DONE
  List of 10
   $ : num 0.199
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 2"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.121
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 4"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.027
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 6"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.00222
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 8"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 6.69e-05
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 10"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  - plan('sequential') ... DONE
  - plan('multicore') ...
  [06:53:39.206] plan(): Setting new future strategy stack:
  [06:53:39.207] List of future strategies:
  [06:53:39.207] 1. multicore:
  [06:53:39.207]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:39.207]    - tweaked: FALSE
  [06:53:39.207]    - call: plan(strategy)
  [06:53:39.209] plan(): nbrOfWorkers() = 2
  [06:53:39.210] doFuture() ...
  [06:53:39.212] - dummy globals (as locals): [1] 'i'
  [06:53:39.214] - R expression:
  [06:53:39.214] {
  [06:53:39.214]     doFuture::registerDoFuture()
  [06:53:39.214]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.214]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.214]         i <- NULL
  [06:53:39.214]         ...future.env <- environment()
  [06:53:39.214]         local({
  [06:53:39.214]             for (name in names(...future.x_jj)) {
  [06:53:39.214]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.214]                   inherits = FALSE)
  [06:53:39.214]             }
  [06:53:39.214]         })
  [06:53:39.214]         tryCatch({
  [06:53:39.214]             if (i%%2 == 0) 
  [06:53:39.214]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.214]                   i))
  [06:53:39.214]             dnorm(i, mean = mu, sd = sigma)
  [06:53:39.214]         }, error = identity)
  [06:53:39.214]     })
  [06:53:39.214] }
  [06:53:39.216] - identifying globals and packages ...
  [06:53:39.216] getGlobalsAndPackages() ...
  [06:53:39.217] Searching for globals...
  [06:53:39.260] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:39.261] Searching for globals ... DONE
  [06:53:39.261] Resolving globals: FALSE
  [06:53:39.264] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:39.265] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.265] - packages: [1] 'stats'
  [06:53:39.266] getGlobalsAndPackages() ... DONE
  [06:53:39.268] List of 3
  [06:53:39.268]  $ ...future.x_ii: NULL
  [06:53:39.268]  $ mu            : num 1
  [06:53:39.268]  $ sigma         : num 2
  [06:53:39.268]  - attr(*, "where")=List of 3
  [06:53:39.268]   ..$ ...future.x_ii:<environment: 0x557600da7838> 
  [06:53:39.268]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:39.268]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:39.268]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:39.268]  - attr(*, "resolved")= logi FALSE
  [06:53:39.268]  - attr(*, "total_size")= num 112
  [06:53:39.285]   - R expression:
  [06:53:39.285] {
  [06:53:39.285]     doFuture::registerDoFuture()
  [06:53:39.285]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.285]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.285]         i <- NULL
  [06:53:39.285]         ...future.env <- environment()
  [06:53:39.285]         local({
  [06:53:39.285]             for (name in names(...future.x_jj)) {
  [06:53:39.285]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.285]                   inherits = FALSE)
  [06:53:39.285]             }
  [06:53:39.285]         })
  [06:53:39.285]         tryCatch({
  [06:53:39.285]             if (i%%2 == 0) 
  [06:53:39.285]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.285]                   i))
  [06:53:39.285]             dnorm(i, mean = mu, sd = sigma)
  [06:53:39.285]         }, error = identity)
  [06:53:39.285]     })
  [06:53:39.285] }
  [06:53:39.286]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.287] List of 3
  [06:53:39.287]  $ ...future.x_ii: NULL
  [06:53:39.287]  $ mu            : num 1
  [06:53:39.287]  $ sigma         : num 2
  [06:53:39.287]  - attr(*, "where")=List of 3
  [06:53:39.287]   ..$ ...future.x_ii:<environment: 0x557600da7838> 
  [06:53:39.287]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:39.287]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:39.287]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:39.287]  - attr(*, "resolved")= logi FALSE
  [06:53:39.287]  - attr(*, "total_size")= num 112
  [06:53:39.304]   - packages: [2] 'doFuture', 'stats'
  [06:53:39.304] - identifying globals and packages ... DONE
  [06:53:39.306] Number of chunks: 2
  [06:53:39.307] Number of futures (= number of chunks): 2
  [06:53:39.308] Launching 2 futures (chunks) ...
  [06:53:39.308] Chunk #1 of 2 ...
  [06:53:39.309]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:39.309] getGlobalsAndPackages() ...
  [06:53:39.309] Searching for globals...
  [06:53:39.311] 
  [06:53:39.311] Searching for globals ... DONE
  [06:53:39.312] - globals: [0] <none>
  [06:53:39.312] getGlobalsAndPackages() ... DONE
  [06:53:39.312] 
  [06:53:39.313] 
  [06:53:39.313]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:39.316] getGlobalsAndPackages() ...
  [06:53:39.317] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.317] Resolving globals: FALSE
  [06:53:39.319] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:39.320] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.320] 
  [06:53:39.320] getGlobalsAndPackages() ... DONE
  [06:53:39.324] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:39.324] Packages needed by future strategies (n = 0): <none>
  [06:53:39.338] {
  [06:53:39.338]     {
  [06:53:39.338]         ...future.startTime <- base::Sys.time()
  [06:53:39.338]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:39.338]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:39.338]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:39.338]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:39.338]             future.resolve.recursive = NULL, width = 80L)
  [06:53:39.338]         {
  [06:53:39.338]             {
  [06:53:39.338]                 {
  [06:53:39.338]                   {
  [06:53:39.338]                     base::local({
  [06:53:39.338]                       has_future <- base::requireNamespace("future", 
  [06:53:39.338]                         quietly = TRUE)
  [06:53:39.338]                       version <- if (has_future) 
  [06:53:39.338]                         utils::packageVersion("future")
  [06:53:39.338]                       else NULL
  [06:53:39.338]                       if (!has_future || version < "1.8.0") {
  [06:53:39.338]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:39.338]                           "", base::R.version$version.string), 
  [06:53:39.338]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:39.338]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:39.338]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:39.338]                             "release", "version")], collapse = " "), 
  [06:53:39.338]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:39.338]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:39.338]                           info)
  [06:53:39.338]                         info <- base::paste(info, collapse = "; ")
  [06:53:39.338]                         if (!has_future) {
  [06:53:39.338]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:39.338]                             info)
  [06:53:39.338]                         }
  [06:53:39.338]                         else {
  [06:53:39.338]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:39.338]                             info, version)
  [06:53:39.338]                         }
  [06:53:39.338]                         base::stop(msg)
  [06:53:39.338]                       }
  [06:53:39.338]                     })
  [06:53:39.338]                   }
  [06:53:39.338]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:39.338]                   base::options(mc.cores = 1L)
  [06:53:39.338]                 }
  [06:53:39.338]                 base::local({
  [06:53:39.338]                   for (pkg in c("doFuture", "stats")) {
  [06:53:39.338]                     base::loadNamespace(pkg)
  [06:53:39.338]                     base::library(pkg, character.only = TRUE)
  [06:53:39.338]                   }
  [06:53:39.338]                 })
  [06:53:39.338]             }
  [06:53:39.338]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:39.338]         }
  [06:53:39.338]     }
  [06:53:39.338]     if (base::is.na(TRUE)) {
  [06:53:39.338]     }
  [06:53:39.338]     else {
  [06:53:39.338]         if (TRUE) {
  [06:53:39.338]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:39.338]                 open = "w")
  [06:53:39.338]         }
  [06:53:39.338]         else {
  [06:53:39.338]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:39.338]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:39.338]         }
  [06:53:39.338]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:39.338]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:39.338]             base::sink(type = "output", split = FALSE)
  [06:53:39.338]             base::close(...future.stdout)
  [06:53:39.338]         }, add = TRUE)
  [06:53:39.338]     }
  [06:53:39.338]     ...future.frame <- base::sys.nframe()
  [06:53:39.338]     ...future.conditions <- base::list()
  [06:53:39.338]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:39.338]     ...future.result <- base::tryCatch({
  [06:53:39.338]         base::withCallingHandlers({
  [06:53:39.338]             ...future.value <- base::withVisible(base::local({
  [06:53:39.338]                 doFuture::registerDoFuture()
  [06:53:39.338]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.338]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.338]                   i <- NULL
  [06:53:39.338]                   ...future.env <- environment()
  [06:53:39.338]                   local({
  [06:53:39.338]                     for (name in names(...future.x_jj)) {
  [06:53:39.338]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.338]                         inherits = FALSE)
  [06:53:39.338]                     }
  [06:53:39.338]                   })
  [06:53:39.338]                   tryCatch({
  [06:53:39.338]                     if (i%%2 == 0) 
  [06:53:39.338]                       stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.338]                         i))
  [06:53:39.338]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:39.338]                   }, error = identity)
  [06:53:39.338]                 })
  [06:53:39.338]             }))
  [06:53:39.338]             future::FutureResult(value = ...future.value$value, 
  [06:53:39.338]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.338]                   ...future.rng), started = ...future.startTime, 
  [06:53:39.338]                 version = "1.8")
  [06:53:39.338]         }, condition = base::local({
  [06:53:39.338]             c <- base::c
  [06:53:39.338]             inherits <- base::inherits
  [06:53:39.338]             invokeRestart <- base::invokeRestart
  [06:53:39.338]             length <- base::length
  [06:53:39.338]             list <- base::list
  [06:53:39.338]             seq.int <- base::seq.int
  [06:53:39.338]             signalCondition <- base::signalCondition
  [06:53:39.338]             sys.calls <- base::sys.calls
  [06:53:39.338]             Sys.time <- base::Sys.time
  [06:53:39.338]             `[[` <- base::`[[`
  [06:53:39.338]             `+` <- base::`+`
  [06:53:39.338]             `<<-` <- base::`<<-`
  [06:53:39.338]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:39.338]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:39.338]                   3L)]
  [06:53:39.338]             }
  [06:53:39.338]             function(cond) {
  [06:53:39.338]                 if (inherits(cond, "error")) {
  [06:53:39.338]                   sessionInformation <- function() {
  [06:53:39.338]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:39.338]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:39.338]                       search = base::search(), system = base::Sys.info())
  [06:53:39.338]                   }
  [06:53:39.338]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.338]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:39.338]                     cond$call), session = sessionInformation(), 
  [06:53:39.338]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:39.338]                   signalCondition(cond)
  [06:53:39.338]                 }
  [06:53:39.338]                 else if (inherits(cond, "condition")) {
  [06:53:39.338]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:39.338]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.338]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:39.338]                   if (!signal) {
  [06:53:39.338]                     muffleCondition <- function (cond) 
  [06:53:39.338]                     {
  [06:53:39.338]                       inherits <- base::inherits
  [06:53:39.338]                       invokeRestart <- base::invokeRestart
  [06:53:39.338]                       muffled <- FALSE
  [06:53:39.338]                       if (inherits(cond, "message")) {
  [06:53:39.338]                         invokeRestart("muffleMessage")
  [06:53:39.338]                         muffled <- TRUE
  [06:53:39.338]                       }
  [06:53:39.338]                       else if (inherits(cond, "warning")) {
  [06:53:39.338]                         invokeRestart("muffleWarning")
  [06:53:39.338]                         muffled <- TRUE
  [06:53:39.338]                       }
  [06:53:39.338]                       else if (inherits(cond, "condition")) {
  [06:53:39.338]                         computeRestarts <- base::computeRestarts
  [06:53:39.338]                         grepl <- base::grepl
  [06:53:39.338]                         is.null <- base::is.null
  [06:53:39.338]                         restarts <- computeRestarts(cond)
  [06:53:39.338]                         for (restart in restarts) {
  [06:53:39.338]                           name <- restart$name
  [06:53:39.338]                           if (is.null(name)) 
  [06:53:39.338]                             next
  [06:53:39.338]                           if (!grepl("^muffle", name)) 
  [06:53:39.338]                             next
  [06:53:39.338]                           invokeRestart(restart)
  [06:53:39.338]                           muffled <- TRUE
  [06:53:39.338]                           break
  [06:53:39.338]                         }
  [06:53:39.338]                       }
  [06:53:39.338]                       invisible(muffled)
  [06:53:39.338]                     }
  [06:53:39.338]                     muffleCondition(cond)
  [06:53:39.338]                   }
  [06:53:39.338]                 }
  [06:53:39.338]             }
  [06:53:39.338]         }))
  [06:53:39.338]     }, error = function(ex) {
  [06:53:39.338]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:39.338]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.338]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:39.338]     }, finally = {
  [06:53:39.338]         {
  [06:53:39.338]             {
  [06:53:39.338]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:39.338]             }
  [06:53:39.338]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:39.338]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:39.338]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:39.338]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:39.338]             {
  [06:53:39.338]                 if (substitute) 
  [06:53:39.338]                   expr <- substitute(expr)
  [06:53:39.338]                 if (is.function(workers)) 
  [06:53:39.338]                   workers <- workers()
  [06:53:39.338]                 workers <- as.integer(workers)
  [06:53:39.338]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:39.338]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:39.338]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:39.338]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:39.338]                     local = TRUE, label = label, ...))
  [06:53:39.338]                 }
  [06:53:39.338]                 oopts <- options(mc.cores = workers)
  [06:53:39.338]                 on.exit(options(oopts))
  [06:53:39.338]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:39.338]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:39.338]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:39.338]                   label = label, ...)
  [06:53:39.338]                 if (!future$lazy) 
  [06:53:39.338]                   future <- run(future)
  [06:53:39.338]                 invisible(future)
  [06:53:39.338]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:39.338]         }
  [06:53:39.338]         base::options(...future.oldOptions)
  [06:53:39.338]     })
  [06:53:39.338]     Sys.time
  [06:53:39.338]     if (base::is.na(TRUE)) {
  [06:53:39.338]     }
  [06:53:39.338]     else {
  [06:53:39.338]         base::sink(type = "output", split = FALSE)
  [06:53:39.338]         if (TRUE) {
  [06:53:39.338]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:39.338]         }
  [06:53:39.338]         else {
  [06:53:39.338]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:39.338]         }
  [06:53:39.338]         base::close(...future.stdout)
  [06:53:39.338]         ...future.stdout <- NULL
  [06:53:39.338]     }
  [06:53:39.338]     ...future.result$conditions <- ...future.conditions
  [06:53:39.338]     ...future.result
  [06:53:39.338] }
  [06:53:39.343] requestCore(): workers = 2
  [06:53:39.348] MulticoreFuture started
  [06:53:39.350] Chunk #1 of 2 ... DONE
  [06:53:39.350] Chunk #2 of 2 ...
  [06:53:39.351]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:39.351] getGlobalsAndPackages() ...
  [06:53:39.352] Searching for globals...
  [06:53:39.354] 
  [06:53:39.355] Searching for globals ... DONE
  [06:53:39.356] - globals: [0] <none>
  [06:53:39.356] getGlobalsAndPackages() ... DONE
  [06:53:39.357] 
  [06:53:39.357] 
  [06:53:39.358]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:39.360] getGlobalsAndPackages() ...
  [06:53:39.361] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.361] Resolving globals: FALSE
  [06:53:39.364] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:39.364] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:39.365] 
  [06:53:39.365] plan(): Setting new future strategy stack:
  [06:53:39.365] getGlobalsAndPackages() ... DONE
  [06:53:39.366] List of future strategies:
  [06:53:39.366] 1. sequential:
  [06:53:39.366]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.366]    - tweaked: FALSE
  [06:53:39.366]    - call: NULL
  [06:53:39.367] plan(): nbrOfWorkers() = 1
  [06:53:39.370] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:39.370] Packages needed by future strategies (n = 0): <none>
  [06:53:39.373] plan(): Setting new future strategy stack:
  [06:53:39.374] List of future strategies:
  [06:53:39.374] 1. multicore:
  [06:53:39.374]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:39.374]    - tweaked: FALSE
  [06:53:39.374]    - call: plan(strategy)
  [06:53:39.377] plan(): nbrOfWorkers() = 2
  [06:53:39.381] {
  [06:53:39.381]     {
  [06:53:39.381]         ...future.startTime <- base::Sys.time()
  [06:53:39.381]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:39.381]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:39.381]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:39.381]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:39.381]             future.resolve.recursive = NULL, width = 80L)
  [06:53:39.381]         {
  [06:53:39.381]             {
  [06:53:39.381]                 {
  [06:53:39.381]                   {
  [06:53:39.381]                     base::local({
  [06:53:39.381]                       has_future <- base::requireNamespace("future", 
  [06:53:39.381]                         quietly = TRUE)
  [06:53:39.381]                       version <- if (has_future) 
  [06:53:39.381]                         utils::packageVersion("future")
  [06:53:39.381]                       else NULL
  [06:53:39.381]                       if (!has_future || version < "1.8.0") {
  [06:53:39.381]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:39.381]                           "", base::R.version$version.string), 
  [06:53:39.381]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:39.381]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:39.381]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:39.381]                             "release", "version")], collapse = " "), 
  [06:53:39.381]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:39.381]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:39.381]                           info)
  [06:53:39.381]                         info <- base::paste(info, collapse = "; ")
  [06:53:39.381]                         if (!has_future) {
  [06:53:39.381]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:39.381]                             info)
  [06:53:39.381]                         }
  [06:53:39.381]                         else {
  [06:53:39.381]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:39.381]                             info, version)
  [06:53:39.381]                         }
  [06:53:39.381]                         base::stop(msg)
  [06:53:39.381]                       }
  [06:53:39.381]                     })
  [06:53:39.381]                   }
  [06:53:39.381]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:39.381]                   base::options(mc.cores = 1L)
  [06:53:39.381]                 }
  [06:53:39.381]                 base::local({
  [06:53:39.381]                   for (pkg in c("doFuture", "stats")) {
  [06:53:39.381]                     base::loadNamespace(pkg)
  [06:53:39.381]                     base::library(pkg, character.only = TRUE)
  [06:53:39.381]                   }
  [06:53:39.381]                 })
  [06:53:39.381]             }
  [06:53:39.381]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:39.381]         }
  [06:53:39.381]     }
  [06:53:39.381]     if (base::is.na(TRUE)) {
  [06:53:39.381]     }
  [06:53:39.381]     else {
  [06:53:39.381]         if (TRUE) {
  [06:53:39.381]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:39.381]                 open = "w")
  [06:53:39.381]         }
  [06:53:39.381]         else {
  [06:53:39.381]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:39.381]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:39.381]         }
  [06:53:39.381]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:39.381]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:39.381]             base::sink(type = "output", split = FALSE)
  [06:53:39.381]             base::close(...future.stdout)
  [06:53:39.381]         }, add = TRUE)
  [06:53:39.381]     }
  [06:53:39.381]     ...future.frame <- base::sys.nframe()
  [06:53:39.381]     ...future.conditions <- base::list()
  [06:53:39.381]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:39.381]     ...future.result <- base::tryCatch({
  [06:53:39.381]         base::withCallingHandlers({
  [06:53:39.381]             ...future.value <- base::withVisible(base::local({
  [06:53:39.381]                 doFuture::registerDoFuture()
  [06:53:39.381]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:39.381]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:39.381]                   i <- NULL
  [06:53:39.381]                   ...future.env <- environment()
  [06:53:39.381]                   local({
  [06:53:39.381]                     for (name in names(...future.x_jj)) {
  [06:53:39.381]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:39.381]                         inherits = FALSE)
  [06:53:39.381]                     }
  [06:53:39.381]                   })
  [06:53:39.381]                   tryCatch({
  [06:53:39.381]                     if (i%%2 == 0) 
  [06:53:39.381]                       stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:39.381]                         i))
  [06:53:39.381]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:39.381]                   }, error = identity)
  [06:53:39.381]                 })
  [06:53:39.381]             }))
  [06:53:39.381]             future::FutureResult(value = ...future.value$value, 
  [06:53:39.381]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.381]                   ...future.rng), started = ...future.startTime, 
  [06:53:39.381]                 version = "1.8")
  [06:53:39.381]         }, condition = base::local({
  [06:53:39.381]             c <- base::c
  [06:53:39.381]             inherits <- base::inherits
  [06:53:39.381]             invokeRestart <- base::invokeRestart
  [06:53:39.381]             length <- base::length
  [06:53:39.381]             list <- base::list
  [06:53:39.381]             seq.int <- base::seq.int
  [06:53:39.381]             signalCondition <- base::signalCondition
  [06:53:39.381]             sys.calls <- base::sys.calls
  [06:53:39.381]             Sys.time <- base::Sys.time
  [06:53:39.381]             `[[` <- base::`[[`
  [06:53:39.381]             `+` <- base::`+`
  [06:53:39.381]             `<<-` <- base::`<<-`
  [06:53:39.381]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:39.381]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:39.381]                   3L)]
  [06:53:39.381]             }
  [06:53:39.381]             function(cond) {
  [06:53:39.381]                 if (inherits(cond, "error")) {
  [06:53:39.381]                   sessionInformation <- function() {
  [06:53:39.381]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:39.381]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:39.381]                       search = base::search(), system = base::Sys.info())
  [06:53:39.381]                   }
  [06:53:39.381]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.381]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:39.381]                     cond$call), session = sessionInformation(), 
  [06:53:39.381]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:39.381]                   signalCondition(cond)
  [06:53:39.381]                 }
  [06:53:39.381]                 else if (inherits(cond, "condition")) {
  [06:53:39.381]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:39.381]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:39.381]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:39.381]                   if (!signal) {
  [06:53:39.381]                     muffleCondition <- function (cond) 
  [06:53:39.381]                     {
  [06:53:39.381]                       inherits <- base::inherits
  [06:53:39.381]                       invokeRestart <- base::invokeRestart
  [06:53:39.381]                       muffled <- FALSE
  [06:53:39.381]                       if (inherits(cond, "message")) {
  [06:53:39.381]                         invokeRestart("muffleMessage")
  [06:53:39.381]                         muffled <- TRUE
  [06:53:39.381]                       }
  [06:53:39.381]                       else if (inherits(cond, "warning")) {
  [06:53:39.381]                         invokeRestart("muffleWarning")
  [06:53:39.381]                         muffled <- TRUE
  [06:53:39.381]                       }
  [06:53:39.381]                       else if (inherits(cond, "condition")) {
  [06:53:39.381]                         computeRestarts <- base::computeRestarts
  [06:53:39.381]                         grepl <- base::grepl
  [06:53:39.381]                         is.null <- base::is.null
  [06:53:39.381]                         restarts <- computeRestarts(cond)
  [06:53:39.381]                         for (restart in restarts) {
  [06:53:39.381]                           name <- restart$name
  [06:53:39.381]                           if (is.null(name)) 
  [06:53:39.381]                             next
  [06:53:39.381]                           if (!grepl("^muffle", name)) 
  [06:53:39.381]                             next
  [06:53:39.381]                           invokeRestart(restart)
  [06:53:39.381]                           muffled <- TRUE
  [06:53:39.381]                           break
  [06:53:39.381]                         }
  [06:53:39.381]                       }
  [06:53:39.381]                       invisible(muffled)
  [06:53:39.381]                     }
  [06:53:39.381]                     muffleCondition(cond)
  [06:53:39.381]                   }
  [06:53:39.381]                 }
  [06:53:39.381]             }
  [06:53:39.381]         }))
  [06:53:39.381]     }, error = function(ex) {
  [06:53:39.381]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:39.381]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:39.381]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:39.381]     }, finally = {
  [06:53:39.381]         {
  [06:53:39.381]             {
  [06:53:39.381]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:39.381]             }
  [06:53:39.381]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:39.381]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:39.381]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:39.381]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:39.381]             {
  [06:53:39.381]                 if (substitute) 
  [06:53:39.381]                   expr <- substitute(expr)
  [06:53:39.381]                 if (is.function(workers)) 
  [06:53:39.381]                   workers <- workers()
  [06:53:39.381]                 workers <- as.integer(workers)
  [06:53:39.381]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:39.381]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:39.381]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:39.381]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:39.381]                     local = TRUE, label = label, ...))
  [06:53:39.381]                 }
  [06:53:39.381]                 oopts <- options(mc.cores = workers)
  [06:53:39.381]                 on.exit(options(oopts))
  [06:53:39.381]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:39.381]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:39.381]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:39.381]                   label = label, ...)
  [06:53:39.381]                 if (!future$lazy) 
  [06:53:39.381]                   future <- run(future)
  [06:53:39.381]                 invisible(future)
  [06:53:39.381]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:39.381]         }
  [06:53:39.381]         base::options(...future.oldOptions)
  [06:53:39.381]     })
  [06:53:39.381]     Sys.time
  [06:53:39.381]     if (base::is.na(TRUE)) {
  [06:53:39.381]     }
  [06:53:39.381]     else {
  [06:53:39.381]         base::sink(type = "output", split = FALSE)
  [06:53:39.381]         if (TRUE) {
  [06:53:39.381]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:39.381]         }
  [06:53:39.381]         else {
  [06:53:39.381]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:39.381]         }
  [06:53:39.381]         base::close(...future.stdout)
  [06:53:39.381]         ...future.stdout <- NULL
  [06:53:39.381]     }
  [06:53:39.381]     ...future.result$conditions <- ...future.conditions
  [06:53:39.381]     ...future.result
  [06:53:39.381] }
  [06:53:39.387] requestCore(): workers = 2
  [06:53:39.393] MulticoreFuture started
  [06:53:39.394] Chunk #2 of 2 ... DONE
  [06:53:39.395] Launching 2 futures (chunks) ... DONE
  [06:53:39.395] - resolving futures
  [06:53:39.396]   - gathering results & relaying conditions (except errors)
  [06:53:39.396] resolve() on list ...
  [06:53:39.397]  recursive: 0
  [06:53:39.397]  length: 2
  [06:53:39.398] 
  [06:53:39.401] Future #1
  [06:53:39.405] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [06:53:39.406] - nx: 2
  [06:53:39.406] - relay: TRUE
  [06:53:39.407] - stdout: TRUE
  [06:53:39.407] - signal: TRUE
  [06:53:39.407] - resignal: FALSE
  [06:53:39.408] - force: FALSE
  [06:53:39.408] - relayed: [n=2] FALSE, FALSE
  [06:53:39.409] - queued futures: [n=2] FALSE, FALSE
  [06:53:39.410]  - until=1
  [06:53:39.410]  - relaying element #1
  [06:53:39.411] - relayed: [n=2] TRUE, FALSE
  [06:53:39.411] - queued futures: [n=2] TRUE, FALSE
  [06:53:39.412] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [06:53:39.412]  length: 1 (resolved future 1)
  [06:53:39.412] plan(): Setting new future strategy stack:
  [06:53:39.413] List of future strategies:
  [06:53:39.413] 1. sequential:
  [06:53:39.413]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.413]    - tweaked: FALSE
  [06:53:39.413]    - call: NULL
  [06:53:39.415] plan(): nbrOfWorkers() = 1
  [06:53:39.419] plan(): Setting new future strategy stack:
  [06:53:39.420] List of future strategies:
  [06:53:39.420] 1. multicore:
  [06:53:39.420]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:39.420]    - tweaked: FALSE
  [06:53:39.420]    - call: plan(strategy)
  [06:53:39.433] plan(): nbrOfWorkers() = 2
  [06:53:39.434] Future #2
  [06:53:39.444] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [06:53:39.444] - nx: 2
  [06:53:39.445] - relay: TRUE
  [06:53:39.445] - stdout: TRUE
  [06:53:39.446] - signal: TRUE
  [06:53:39.446] - resignal: FALSE
  [06:53:39.446] - force: FALSE
  [06:53:39.447] - relayed: [n=2] TRUE, FALSE
  [06:53:39.447] - queued futures: [n=2] TRUE, FALSE
  [06:53:39.448]  - until=2
  [06:53:39.448]  - relaying element #2
  [06:53:39.449] - relayed: [n=2] TRUE, TRUE
  [06:53:39.449] - queued futures: [n=2] TRUE, TRUE
  [06:53:39.450] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [06:53:39.450]  length: 0 (resolved future 2)
  [06:53:39.450] Relaying remaining futures
  [06:53:39.451] signalConditionsASAP(NULL, pos=0) ...
  [06:53:39.451] - nx: 2
  [06:53:39.452] - relay: TRUE
  [06:53:39.452] - stdout: TRUE
  [06:53:39.452] - signal: TRUE
  [06:53:39.452] - resignal: FALSE
  [06:53:39.453] - force: FALSE
  [06:53:39.453] - relayed: [n=2] TRUE, TRUE
  [06:53:39.453] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:39.454] - relayed: [n=2] TRUE, TRUE
  [06:53:39.454] - queued futures: [n=2] TRUE, TRUE
  [06:53:39.455] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:39.455] resolve() on list ... DONE
  [06:53:39.456] - collecting values of futures
  [06:53:39.456] - accumulating results
  [06:53:39.459] - processing errors (handler = 'pass')
  [06:53:39.460] - extracting results
  [06:53:39.460] doFuture() ... DONE
  List of 10
   $ : num 0.199
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 2"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.121
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 4"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.027
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 6"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.00222
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 8"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 6.69e-05
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 10"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  - plan('multicore') ... DONE
  - plan('multisession') ...
  [06:53:39.503] plan(): Setting new future strategy stack:
  [06:53:39.504] List of future strategies:
  [06:53:39.504] 1. multisession:
  [06:53:39.504]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.504]    - tweaked: FALSE
  [06:53:39.504]    - call: plan(strategy)
  [06:53:39.505] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:39.505] multisession:
  [06:53:39.505] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:39.505] - tweaked: FALSE
  [06:53:39.505] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 24412
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758957e65c36.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.758957e65c36.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.758957e65c36.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=24412 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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75892602a5bd.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.75892602a5bd.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75892602a5bd.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=24412 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [06:53:42.359] getGlobalsAndPackages() ...
  [06:53:42.360] Not searching for globals
  [06:53:42.360] - globals: [0] <none>
  [06:53:42.360] getGlobalsAndPackages() ... DONE
  [06:53:42.366] Packages needed by the future expression (n = 0): <none>
  [06:53:42.367] Packages needed by future strategies (n = 0): <none>
  [06:53:42.373] {
  [06:53:42.373]     {
  [06:53:42.373]         ...future.startTime <- base::Sys.time()
  [06:53:42.373]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:42.373]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:42.373]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:42.373]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:42.373]             future.resolve.recursive = NULL, width = 80L)
  [06:53:42.373]         {
  [06:53:42.373]             {
  [06:53:42.373]                 {
  [06:53:42.373]                   base::local({
  [06:53:42.373]                     has_future <- base::requireNamespace("future", 
  [06:53:42.373]                       quietly = TRUE)
  [06:53:42.373]                     version <- if (has_future) 
  [06:53:42.373]                       utils::packageVersion("future")
  [06:53:42.373]                     else NULL
  [06:53:42.373]                     if (!has_future || version < "1.8.0") {
  [06:53:42.373]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:42.373]                         "", base::R.version$version.string), 
  [06:53:42.373]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:42.373]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:42.373]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:42.373]                           "release", "version")], collapse = " "), 
  [06:53:42.373]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:42.373]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:42.373]                         info)
  [06:53:42.373]                       info <- base::paste(info, collapse = "; ")
  [06:53:42.373]                       if (!has_future) {
  [06:53:42.373]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:42.373]                           info)
  [06:53:42.373]                       }
  [06:53:42.373]                       else {
  [06:53:42.373]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:42.373]                           info, version)
  [06:53:42.373]                       }
  [06:53:42.373]                       base::stop(msg)
  [06:53:42.373]                     }
  [06:53:42.373]                   })
  [06:53:42.373]                 }
  [06:53:42.373]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:42.373]                 base::options(mc.cores = 1L)
  [06:53:42.373]             }
  [06:53:42.373]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:42.373]         }
  [06:53:42.373]     }
  [06:53:42.373]     if (base::is.na(TRUE)) {
  [06:53:42.373]     }
  [06:53:42.373]     else {
  [06:53:42.373]         if (TRUE) {
  [06:53:42.373]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:42.373]                 open = "w")
  [06:53:42.373]         }
  [06:53:42.373]         else {
  [06:53:42.373]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:42.373]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:42.373]         }
  [06:53:42.373]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:42.373]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:42.373]             base::sink(type = "output", split = FALSE)
  [06:53:42.373]             base::close(...future.stdout)
  [06:53:42.373]         }, add = TRUE)
  [06:53:42.373]     }
  [06:53:42.373]     ...future.frame <- base::sys.nframe()
  [06:53:42.373]     ...future.conditions <- base::list()
  [06:53:42.373]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:42.373]     ...future.result <- base::tryCatch({
  [06:53:42.373]         base::withCallingHandlers({
  [06:53:42.373]             ...future.value <- base::withVisible(base::local({
  [06:53:42.373]                 ...future.sendCondition <- local({
  [06:53:42.373]                   sendCondition <- NULL
  [06:53:42.373]                   function(frame = 1L) {
  [06:53:42.373]                     if (is.function(sendCondition)) 
  [06:53:42.373]                       return(sendCondition)
  [06:53:42.373]                     ns <- getNamespace("parallel")
  [06:53:42.373]                     if (exists("sendData", mode = "function", 
  [06:53:42.373]                       envir = ns)) {
  [06:53:42.373]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:42.373]                         envir = ns)
  [06:53:42.373]                       envir <- sys.frame(frame)
  [06:53:42.373]                       master <- NULL
  [06:53:42.373]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:42.373]                         !identical(envir, emptyenv())) {
  [06:53:42.373]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:42.373]                           inherits = FALSE)) {
  [06:53:42.373]                           master <- get("master", mode = "list", 
  [06:53:42.373]                             envir = envir, inherits = FALSE)
  [06:53:42.373]                           if (inherits(master, "SOCKnode")) {
  [06:53:42.373]                             sendCondition <<- function(cond) {
  [06:53:42.373]                               data <- list(type = "VALUE", value = cond, 
  [06:53:42.373]                                 success = TRUE)
  [06:53:42.373]                               parallel_sendData(master, data)
  [06:53:42.373]                             }
  [06:53:42.373]                             return(sendCondition)
  [06:53:42.373]                           }
  [06:53:42.373]                         }
  [06:53:42.373]                         frame <- frame + 1L
  [06:53:42.373]                         envir <- sys.frame(frame)
  [06:53:42.373]                       }
  [06:53:42.373]                     }
  [06:53:42.373]                     sendCondition <<- function(cond) NULL
  [06:53:42.373]                   }
  [06:53:42.373]                 })
  [06:53:42.373]                 withCallingHandlers({
  [06:53:42.373]                   NA
  [06:53:42.373]                 }, immediateCondition = function(cond) {
  [06:53:42.373]                   sendCondition <- ...future.sendCondition()
  [06:53:42.373]                   sendCondition(cond)
  [06:53:42.373]                   muffleCondition <- function (cond) 
  [06:53:42.373]                   {
  [06:53:42.373]                     inherits <- base::inherits
  [06:53:42.373]                     invokeRestart <- base::invokeRestart
  [06:53:42.373]                     muffled <- FALSE
  [06:53:42.373]                     if (inherits(cond, "message")) {
  [06:53:42.373]                       invokeRestart("muffleMessage")
  [06:53:42.373]                       muffled <- TRUE
  [06:53:42.373]                     }
  [06:53:42.373]                     else if (inherits(cond, "warning")) {
  [06:53:42.373]                       invokeRestart("muffleWarning")
  [06:53:42.373]                       muffled <- TRUE
  [06:53:42.373]                     }
  [06:53:42.373]                     else if (inherits(cond, "condition")) {
  [06:53:42.373]                       computeRestarts <- base::computeRestarts
  [06:53:42.373]                       grepl <- base::grepl
  [06:53:42.373]                       is.null <- base::is.null
  [06:53:42.373]                       restarts <- computeRestarts(cond)
  [06:53:42.373]                       for (restart in restarts) {
  [06:53:42.373]                         name <- restart$name
  [06:53:42.373]                         if (is.null(name)) 
  [06:53:42.373]                           next
  [06:53:42.373]                         if (!grepl("^muffle", name)) 
  [06:53:42.373]                           next
  [06:53:42.373]                         invokeRestart(restart)
  [06:53:42.373]                         muffled <- TRUE
  [06:53:42.373]                         break
  [06:53:42.373]                       }
  [06:53:42.373]                     }
  [06:53:42.373]                     invisible(muffled)
  [06:53:42.373]                   }
  [06:53:42.373]                   muffleCondition(cond)
  [06:53:42.373]                 })
  [06:53:42.373]             }))
  [06:53:42.373]             future::FutureResult(value = ...future.value$value, 
  [06:53:42.373]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.373]                   ...future.rng), started = ...future.startTime, 
  [06:53:42.373]                 version = "1.8")
  [06:53:42.373]         }, condition = base::local({
  [06:53:42.373]             c <- base::c
  [06:53:42.373]             inherits <- base::inherits
  [06:53:42.373]             invokeRestart <- base::invokeRestart
  [06:53:42.373]             length <- base::length
  [06:53:42.373]             list <- base::list
  [06:53:42.373]             seq.int <- base::seq.int
  [06:53:42.373]             signalCondition <- base::signalCondition
  [06:53:42.373]             sys.calls <- base::sys.calls
  [06:53:42.373]             Sys.time <- base::Sys.time
  [06:53:42.373]             `[[` <- base::`[[`
  [06:53:42.373]             `+` <- base::`+`
  [06:53:42.373]             `<<-` <- base::`<<-`
  [06:53:42.373]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:42.373]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:42.373]                   3L)]
  [06:53:42.373]             }
  [06:53:42.373]             function(cond) {
  [06:53:42.373]                 if (inherits(cond, "error")) {
  [06:53:42.373]                   sessionInformation <- function() {
  [06:53:42.373]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:42.373]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:42.373]                       search = base::search(), system = base::Sys.info())
  [06:53:42.373]                   }
  [06:53:42.373]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.373]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:42.373]                     cond$call), session = sessionInformation(), 
  [06:53:42.373]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:42.373]                   signalCondition(cond)
  [06:53:42.373]                 }
  [06:53:42.373]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:42.373]                 ))) {
  [06:53:42.373]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:42.373]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.373]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:42.373]                   if (!signal) {
  [06:53:42.373]                     muffleCondition <- function (cond) 
  [06:53:42.373]                     {
  [06:53:42.373]                       inherits <- base::inherits
  [06:53:42.373]                       invokeRestart <- base::invokeRestart
  [06:53:42.373]                       muffled <- FALSE
  [06:53:42.373]                       if (inherits(cond, "message")) {
  [06:53:42.373]                         invokeRestart("muffleMessage")
  [06:53:42.373]                         muffled <- TRUE
  [06:53:42.373]                       }
  [06:53:42.373]                       else if (inherits(cond, "warning")) {
  [06:53:42.373]                         invokeRestart("muffleWarning")
  [06:53:42.373]                         muffled <- TRUE
  [06:53:42.373]                       }
  [06:53:42.373]                       else if (inherits(cond, "condition")) {
  [06:53:42.373]                         computeRestarts <- base::computeRestarts
  [06:53:42.373]                         grepl <- base::grepl
  [06:53:42.373]                         is.null <- base::is.null
  [06:53:42.373]                         restarts <- computeRestarts(cond)
  [06:53:42.373]                         for (restart in restarts) {
  [06:53:42.373]                           name <- restart$name
  [06:53:42.373]                           if (is.null(name)) 
  [06:53:42.373]                             next
  [06:53:42.373]                           if (!grepl("^muffle", name)) 
  [06:53:42.373]                             next
  [06:53:42.373]                           invokeRestart(restart)
  [06:53:42.373]                           muffled <- TRUE
  [06:53:42.373]                           break
  [06:53:42.373]                         }
  [06:53:42.373]                       }
  [06:53:42.373]                       invisible(muffled)
  [06:53:42.373]                     }
  [06:53:42.373]                     muffleCondition(cond)
  [06:53:42.373]                   }
  [06:53:42.373]                 }
  [06:53:42.373]             }
  [06:53:42.373]         }))
  [06:53:42.373]     }, error = function(ex) {
  [06:53:42.373]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:42.373]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.373]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:42.373]     }, finally = {
  [06:53:42.373]         {
  [06:53:42.373]             {
  [06:53:42.373]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:42.373]             }
  [06:53:42.373]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:42.373]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:42.373]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:42.373]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:42.373]                 ...) 
  [06:53:42.373]             {
  [06:53:42.373]                 if (substitute) 
  [06:53:42.373]                   expr <- substitute(expr)
  [06:53:42.373]                 if (is.function(workers)) 
  [06:53:42.373]                   workers <- workers()
  [06:53:42.373]                 workers <- as.integer(workers)
  [06:53:42.373]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:42.373]                   workers >= 1)
  [06:53:42.373]                 if (workers == 1L) {
  [06:53:42.373]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:42.373]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:42.373]                     local = TRUE, label = label, ...))
  [06:53:42.373]                 }
  [06:53:42.373]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:42.373]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:42.373]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:42.373]                   globals = globals, persistent = persistent, 
  [06:53:42.373]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:42.373]                   label = label, ...)
  [06:53:42.373]                 if (!future$lazy) 
  [06:53:42.373]                   future <- run(future)
  [06:53:42.373]                 invisible(future)
  [06:53:42.373]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:42.373]         }
  [06:53:42.373]         base::options(...future.oldOptions)
  [06:53:42.373]     })
  [06:53:42.373]     Sys.time
  [06:53:42.373]     if (base::is.na(TRUE)) {
  [06:53:42.373]     }
  [06:53:42.373]     else {
  [06:53:42.373]         base::sink(type = "output", split = FALSE)
  [06:53:42.373]         if (TRUE) {
  [06:53:42.373]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:42.373]         }
  [06:53:42.373]         else {
  [06:53:42.373]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:42.373]         }
  [06:53:42.373]         base::close(...future.stdout)
  [06:53:42.373]         ...future.stdout <- NULL
  [06:53:42.373]     }
  [06:53:42.373]     ...future.result$conditions <- ...future.conditions
  [06:53:42.373]     ...future.result
  [06:53:42.373] }
  [06:53:42.392] MultisessionFuture started
  [06:53:42.393] result() for ClusterFuture ...
  [06:53:42.393] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:42.394] - Validating connection of MultisessionFuture
  [06:53:42.573] - received message: FutureResult
  [06:53:42.574] - Received FutureResult
  [06:53:42.574] - Erased future from FutureRegistry
  [06:53:42.575] result() for ClusterFuture ...
  [06:53:42.575] - result already collected: FutureResult
  [06:53:42.576] result() for ClusterFuture ... done
  [06:53:42.576] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:42.577] result() for ClusterFuture ... done
  [06:53:42.577] result() for ClusterFuture ...
  [06:53:42.577] - result already collected: FutureResult
  [06:53:42.578] result() for ClusterFuture ... done
  [06:53:42.578] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [06:53:42.580] plan(): nbrOfWorkers() = 2
  [06:53:42.581] doFuture() ...
  [06:53:42.608] - dummy globals (as locals): [1] 'i'
  [06:53:42.609] - R expression:
  [06:53:42.610] {
  [06:53:42.610]     doFuture::registerDoFuture()
  [06:53:42.610]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:42.610]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:42.610]         i <- NULL
  [06:53:42.610]         ...future.env <- environment()
  [06:53:42.610]         local({
  [06:53:42.610]             for (name in names(...future.x_jj)) {
  [06:53:42.610]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:42.610]                   inherits = FALSE)
  [06:53:42.610]             }
  [06:53:42.610]         })
  [06:53:42.610]         tryCatch({
  [06:53:42.610]             if (i%%2 == 0) 
  [06:53:42.610]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:42.610]                   i))
  [06:53:42.610]             dnorm(i, mean = mu, sd = sigma)
  [06:53:42.610]         }, error = identity)
  [06:53:42.610]     })
  [06:53:42.610] }
  [06:53:42.618] - identifying globals and packages ...
  [06:53:42.619] getGlobalsAndPackages() ...
  [06:53:42.619] Searching for globals...
  [06:53:42.643] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:42.644] Searching for globals ... DONE
  [06:53:42.644] Resolving globals: FALSE
  [06:53:42.653] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:42.653] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.654] - packages: [1] 'stats'
  [06:53:42.654] getGlobalsAndPackages() ... DONE
  [06:53:42.655] List of 3
  [06:53:42.655]  $ ...future.x_ii: NULL
  [06:53:42.655]  $ mu            : num 1
  [06:53:42.655]  $ sigma         : num 2
  [06:53:42.655]  - attr(*, "where")=List of 3
  [06:53:42.655]   ..$ ...future.x_ii:<environment: 0x5575ff907e30> 
  [06:53:42.655]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:42.655]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:42.655]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:42.655]  - attr(*, "resolved")= logi FALSE
  [06:53:42.655]  - attr(*, "total_size")= num 112
  [06:53:42.669]   - R expression:
  [06:53:42.669] {
  [06:53:42.669]     doFuture::registerDoFuture()
  [06:53:42.669]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:42.669]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:42.669]         i <- NULL
  [06:53:42.669]         ...future.env <- environment()
  [06:53:42.669]         local({
  [06:53:42.669]             for (name in names(...future.x_jj)) {
  [06:53:42.669]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:42.669]                   inherits = FALSE)
  [06:53:42.669]             }
  [06:53:42.669]         })
  [06:53:42.669]         tryCatch({
  [06:53:42.669]             if (i%%2 == 0) 
  [06:53:42.669]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:42.669]                   i))
  [06:53:42.669]             dnorm(i, mean = mu, sd = sigma)
  [06:53:42.669]         }, error = identity)
  [06:53:42.669]     })
  [06:53:42.669] }
  [06:53:42.670]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.671] List of 3
  [06:53:42.671]  $ ...future.x_ii: NULL
  [06:53:42.671]  $ mu            : num 1
  [06:53:42.671]  $ sigma         : num 2
  [06:53:42.671]  - attr(*, "where")=List of 3
  [06:53:42.671]   ..$ ...future.x_ii:<environment: 0x5575ff907e30> 
  [06:53:42.671]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:42.671]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:42.671]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:42.671]  - attr(*, "resolved")= logi FALSE
  [06:53:42.671]  - attr(*, "total_size")= num 112
  [06:53:42.685]   - packages: [2] 'doFuture', 'stats'
  [06:53:42.685] - identifying globals and packages ... DONE
  [06:53:42.690] Number of chunks: 2
  [06:53:42.690] Number of futures (= number of chunks): 2
  [06:53:42.691] Launching 2 futures (chunks) ...
  [06:53:42.691] Chunk #1 of 2 ...
  [06:53:42.692]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:42.692] getGlobalsAndPackages() ...
  [06:53:42.692] Searching for globals...
  [06:53:42.694] 
  [06:53:42.694] Searching for globals ... DONE
  [06:53:42.694] - globals: [0] <none>
  [06:53:42.695] getGlobalsAndPackages() ... DONE
  [06:53:42.695] 
  [06:53:42.695] 
  [06:53:42.696]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:42.697] getGlobalsAndPackages() ...
  [06:53:42.697] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.698] Resolving globals: FALSE
  [06:53:42.699] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:42.700] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.700] 
  [06:53:42.700] getGlobalsAndPackages() ... DONE
  [06:53:42.705] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:42.706] Packages needed by future strategies (n = 0): <none>
  [06:53:42.712] {
  [06:53:42.712]     {
  [06:53:42.712]         ...future.startTime <- base::Sys.time()
  [06:53:42.712]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:42.712]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:42.712]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:42.712]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:42.712]             future.resolve.recursive = NULL, width = 80L)
  [06:53:42.712]         {
  [06:53:42.712]             {
  [06:53:42.712]                 {
  [06:53:42.712]                   {
  [06:53:42.712]                     base::local({
  [06:53:42.712]                       has_future <- base::requireNamespace("future", 
  [06:53:42.712]                         quietly = TRUE)
  [06:53:42.712]                       version <- if (has_future) 
  [06:53:42.712]                         utils::packageVersion("future")
  [06:53:42.712]                       else NULL
  [06:53:42.712]                       if (!has_future || version < "1.8.0") {
  [06:53:42.712]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:42.712]                           "", base::R.version$version.string), 
  [06:53:42.712]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:42.712]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:42.712]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:42.712]                             "release", "version")], collapse = " "), 
  [06:53:42.712]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:42.712]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:42.712]                           info)
  [06:53:42.712]                         info <- base::paste(info, collapse = "; ")
  [06:53:42.712]                         if (!has_future) {
  [06:53:42.712]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:42.712]                             info)
  [06:53:42.712]                         }
  [06:53:42.712]                         else {
  [06:53:42.712]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:42.712]                             info, version)
  [06:53:42.712]                         }
  [06:53:42.712]                         base::stop(msg)
  [06:53:42.712]                       }
  [06:53:42.712]                     })
  [06:53:42.712]                   }
  [06:53:42.712]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:42.712]                   base::options(mc.cores = 1L)
  [06:53:42.712]                 }
  [06:53:42.712]                 base::local({
  [06:53:42.712]                   for (pkg in c("doFuture", "stats")) {
  [06:53:42.712]                     base::loadNamespace(pkg)
  [06:53:42.712]                     base::library(pkg, character.only = TRUE)
  [06:53:42.712]                   }
  [06:53:42.712]                 })
  [06:53:42.712]             }
  [06:53:42.712]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:42.712]         }
  [06:53:42.712]     }
  [06:53:42.712]     if (base::is.na(TRUE)) {
  [06:53:42.712]     }
  [06:53:42.712]     else {
  [06:53:42.712]         if (TRUE) {
  [06:53:42.712]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:42.712]                 open = "w")
  [06:53:42.712]         }
  [06:53:42.712]         else {
  [06:53:42.712]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:42.712]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:42.712]         }
  [06:53:42.712]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:42.712]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:42.712]             base::sink(type = "output", split = FALSE)
  [06:53:42.712]             base::close(...future.stdout)
  [06:53:42.712]         }, add = TRUE)
  [06:53:42.712]     }
  [06:53:42.712]     ...future.frame <- base::sys.nframe()
  [06:53:42.712]     ...future.conditions <- base::list()
  [06:53:42.712]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:42.712]     ...future.result <- base::tryCatch({
  [06:53:42.712]         base::withCallingHandlers({
  [06:53:42.712]             ...future.value <- base::withVisible(base::local({
  [06:53:42.712]                 ...future.sendCondition <- local({
  [06:53:42.712]                   sendCondition <- NULL
  [06:53:42.712]                   function(frame = 1L) {
  [06:53:42.712]                     if (is.function(sendCondition)) 
  [06:53:42.712]                       return(sendCondition)
  [06:53:42.712]                     ns <- getNamespace("parallel")
  [06:53:42.712]                     if (exists("sendData", mode = "function", 
  [06:53:42.712]                       envir = ns)) {
  [06:53:42.712]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:42.712]                         envir = ns)
  [06:53:42.712]                       envir <- sys.frame(frame)
  [06:53:42.712]                       master <- NULL
  [06:53:42.712]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:42.712]                         !identical(envir, emptyenv())) {
  [06:53:42.712]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:42.712]                           inherits = FALSE)) {
  [06:53:42.712]                           master <- get("master", mode = "list", 
  [06:53:42.712]                             envir = envir, inherits = FALSE)
  [06:53:42.712]                           if (inherits(master, "SOCKnode")) {
  [06:53:42.712]                             sendCondition <<- function(cond) {
  [06:53:42.712]                               data <- list(type = "VALUE", value = cond, 
  [06:53:42.712]                                 success = TRUE)
  [06:53:42.712]                               parallel_sendData(master, data)
  [06:53:42.712]                             }
  [06:53:42.712]                             return(sendCondition)
  [06:53:42.712]                           }
  [06:53:42.712]                         }
  [06:53:42.712]                         frame <- frame + 1L
  [06:53:42.712]                         envir <- sys.frame(frame)
  [06:53:42.712]                       }
  [06:53:42.712]                     }
  [06:53:42.712]                     sendCondition <<- function(cond) NULL
  [06:53:42.712]                   }
  [06:53:42.712]                 })
  [06:53:42.712]                 withCallingHandlers({
  [06:53:42.712]                   {
  [06:53:42.712]                     doFuture::registerDoFuture()
  [06:53:42.712]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:42.712]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:42.712]                       i <- NULL
  [06:53:42.712]                       ...future.env <- environment()
  [06:53:42.712]                       local({
  [06:53:42.712]                         for (name in names(...future.x_jj)) {
  [06:53:42.712]                           assign(name, ...future.x_jj[[name]], 
  [06:53:42.712]                             envir = ...future.env, inherits = FALSE)
  [06:53:42.712]                         }
  [06:53:42.712]                       })
  [06:53:42.712]                       tryCatch({
  [06:53:42.712]                         if (i%%2 == 0) 
  [06:53:42.712]                           stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:42.712]                             i))
  [06:53:42.712]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:42.712]                       }, error = identity)
  [06:53:42.712]                     })
  [06:53:42.712]                   }
  [06:53:42.712]                 }, immediateCondition = function(cond) {
  [06:53:42.712]                   sendCondition <- ...future.sendCondition()
  [06:53:42.712]                   sendCondition(cond)
  [06:53:42.712]                   muffleCondition <- function (cond) 
  [06:53:42.712]                   {
  [06:53:42.712]                     inherits <- base::inherits
  [06:53:42.712]                     invokeRestart <- base::invokeRestart
  [06:53:42.712]                     muffled <- FALSE
  [06:53:42.712]                     if (inherits(cond, "message")) {
  [06:53:42.712]                       invokeRestart("muffleMessage")
  [06:53:42.712]                       muffled <- TRUE
  [06:53:42.712]                     }
  [06:53:42.712]                     else if (inherits(cond, "warning")) {
  [06:53:42.712]                       invokeRestart("muffleWarning")
  [06:53:42.712]                       muffled <- TRUE
  [06:53:42.712]                     }
  [06:53:42.712]                     else if (inherits(cond, "condition")) {
  [06:53:42.712]                       computeRestarts <- base::computeRestarts
  [06:53:42.712]                       grepl <- base::grepl
  [06:53:42.712]                       is.null <- base::is.null
  [06:53:42.712]                       restarts <- computeRestarts(cond)
  [06:53:42.712]                       for (restart in restarts) {
  [06:53:42.712]                         name <- restart$name
  [06:53:42.712]                         if (is.null(name)) 
  [06:53:42.712]                           next
  [06:53:42.712]                         if (!grepl("^muffle", name)) 
  [06:53:42.712]                           next
  [06:53:42.712]                         invokeRestart(restart)
  [06:53:42.712]                         muffled <- TRUE
  [06:53:42.712]                         break
  [06:53:42.712]                       }
  [06:53:42.712]                     }
  [06:53:42.712]                     invisible(muffled)
  [06:53:42.712]                   }
  [06:53:42.712]                   muffleCondition(cond)
  [06:53:42.712]                 })
  [06:53:42.712]             }))
  [06:53:42.712]             future::FutureResult(value = ...future.value$value, 
  [06:53:42.712]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.712]                   ...future.rng), started = ...future.startTime, 
  [06:53:42.712]                 version = "1.8")
  [06:53:42.712]         }, condition = base::local({
  [06:53:42.712]             c <- base::c
  [06:53:42.712]             inherits <- base::inherits
  [06:53:42.712]             invokeRestart <- base::invokeRestart
  [06:53:42.712]             length <- base::length
  [06:53:42.712]             list <- base::list
  [06:53:42.712]             seq.int <- base::seq.int
  [06:53:42.712]             signalCondition <- base::signalCondition
  [06:53:42.712]             sys.calls <- base::sys.calls
  [06:53:42.712]             Sys.time <- base::Sys.time
  [06:53:42.712]             `[[` <- base::`[[`
  [06:53:42.712]             `+` <- base::`+`
  [06:53:42.712]             `<<-` <- base::`<<-`
  [06:53:42.712]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:42.712]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:42.712]                   3L)]
  [06:53:42.712]             }
  [06:53:42.712]             function(cond) {
  [06:53:42.712]                 if (inherits(cond, "error")) {
  [06:53:42.712]                   sessionInformation <- function() {
  [06:53:42.712]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:42.712]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:42.712]                       search = base::search(), system = base::Sys.info())
  [06:53:42.712]                   }
  [06:53:42.712]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.712]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:42.712]                     cond$call), session = sessionInformation(), 
  [06:53:42.712]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:42.712]                   signalCondition(cond)
  [06:53:42.712]                 }
  [06:53:42.712]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:42.712]                 ))) {
  [06:53:42.712]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:42.712]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.712]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:42.712]                   if (!signal) {
  [06:53:42.712]                     muffleCondition <- function (cond) 
  [06:53:42.712]                     {
  [06:53:42.712]                       inherits <- base::inherits
  [06:53:42.712]                       invokeRestart <- base::invokeRestart
  [06:53:42.712]                       muffled <- FALSE
  [06:53:42.712]                       if (inherits(cond, "message")) {
  [06:53:42.712]                         invokeRestart("muffleMessage")
  [06:53:42.712]                         muffled <- TRUE
  [06:53:42.712]                       }
  [06:53:42.712]                       else if (inherits(cond, "warning")) {
  [06:53:42.712]                         invokeRestart("muffleWarning")
  [06:53:42.712]                         muffled <- TRUE
  [06:53:42.712]                       }
  [06:53:42.712]                       else if (inherits(cond, "condition")) {
  [06:53:42.712]                         computeRestarts <- base::computeRestarts
  [06:53:42.712]                         grepl <- base::grepl
  [06:53:42.712]                         is.null <- base::is.null
  [06:53:42.712]                         restarts <- computeRestarts(cond)
  [06:53:42.712]                         for (restart in restarts) {
  [06:53:42.712]                           name <- restart$name
  [06:53:42.712]                           if (is.null(name)) 
  [06:53:42.712]                             next
  [06:53:42.712]                           if (!grepl("^muffle", name)) 
  [06:53:42.712]                             next
  [06:53:42.712]                           invokeRestart(restart)
  [06:53:42.712]                           muffled <- TRUE
  [06:53:42.712]                           break
  [06:53:42.712]                         }
  [06:53:42.712]                       }
  [06:53:42.712]                       invisible(muffled)
  [06:53:42.712]                     }
  [06:53:42.712]                     muffleCondition(cond)
  [06:53:42.712]                   }
  [06:53:42.712]                 }
  [06:53:42.712]             }
  [06:53:42.712]         }))
  [06:53:42.712]     }, error = function(ex) {
  [06:53:42.712]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:42.712]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.712]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:42.712]     }, finally = {
  [06:53:42.712]         {
  [06:53:42.712]             {
  [06:53:42.712]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:42.712]             }
  [06:53:42.712]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:42.712]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:42.712]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:42.712]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:42.712]                 ...) 
  [06:53:42.712]             {
  [06:53:42.712]                 if (substitute) 
  [06:53:42.712]                   expr <- substitute(expr)
  [06:53:42.712]                 if (is.function(workers)) 
  [06:53:42.712]                   workers <- workers()
  [06:53:42.712]                 workers <- as.integer(workers)
  [06:53:42.712]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:42.712]                   workers >= 1)
  [06:53:42.712]                 if (workers == 1L) {
  [06:53:42.712]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:42.712]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:42.712]                     local = TRUE, label = label, ...))
  [06:53:42.712]                 }
  [06:53:42.712]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:42.712]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:42.712]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:42.712]                   globals = globals, persistent = persistent, 
  [06:53:42.712]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:42.712]                   label = label, ...)
  [06:53:42.712]                 if (!future$lazy) 
  [06:53:42.712]                   future <- run(future)
  [06:53:42.712]                 invisible(future)
  [06:53:42.712]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:42.712]         }
  [06:53:42.712]         base::options(...future.oldOptions)
  [06:53:42.712]     })
  [06:53:42.712]     Sys.time
  [06:53:42.712]     if (base::is.na(TRUE)) {
  [06:53:42.712]     }
  [06:53:42.712]     else {
  [06:53:42.712]         base::sink(type = "output", split = FALSE)
  [06:53:42.712]         if (TRUE) {
  [06:53:42.712]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:42.712]         }
  [06:53:42.712]         else {
  [06:53:42.712]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:42.712]         }
  [06:53:42.712]         base::close(...future.stdout)
  [06:53:42.712]         ...future.stdout <- NULL
  [06:53:42.712]     }
  [06:53:42.712]     ...future.result$conditions <- ...future.conditions
  [06:53:42.712]     ...future.result
  [06:53:42.712] }
  [06:53:42.720] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [06:53:42.720] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [06:53:42.721] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [06:53:42.722] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [06:53:42.723] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [06:53:42.723] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [06:53:42.724] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [06:53:42.724] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [06:53:42.726] MultisessionFuture started
  [06:53:42.726] Chunk #1 of 2 ... DONE
  [06:53:42.726] Chunk #2 of 2 ...
  [06:53:42.727]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:42.727] getGlobalsAndPackages() ...
  [06:53:42.727] Searching for globals...
  [06:53:42.729] 
  [06:53:42.729] Searching for globals ... DONE
  [06:53:42.730] - globals: [0] <none>
  [06:53:42.730] getGlobalsAndPackages() ... DONE
  [06:53:42.730] 
  [06:53:42.730] 
  [06:53:42.731]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:42.732] getGlobalsAndPackages() ...
  [06:53:42.733] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.733] Resolving globals: FALSE
  [06:53:42.734] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:42.735] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:42.735] 
  [06:53:42.735] getGlobalsAndPackages() ... DONE
  [06:53:42.740] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:42.741] Packages needed by future strategies (n = 0): <none>
  [06:53:42.750] {
  [06:53:42.750]     {
  [06:53:42.750]         ...future.startTime <- base::Sys.time()
  [06:53:42.750]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:42.750]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:42.750]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:42.750]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:42.750]             future.resolve.recursive = NULL, width = 80L)
  [06:53:42.750]         {
  [06:53:42.750]             {
  [06:53:42.750]                 {
  [06:53:42.750]                   {
  [06:53:42.750]                     base::local({
  [06:53:42.750]                       has_future <- base::requireNamespace("future", 
  [06:53:42.750]                         quietly = TRUE)
  [06:53:42.750]                       version <- if (has_future) 
  [06:53:42.750]                         utils::packageVersion("future")
  [06:53:42.750]                       else NULL
  [06:53:42.750]                       if (!has_future || version < "1.8.0") {
  [06:53:42.750]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:42.750]                           "", base::R.version$version.string), 
  [06:53:42.750]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:42.750]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:42.750]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:42.750]                             "release", "version")], collapse = " "), 
  [06:53:42.750]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:42.750]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:42.750]                           info)
  [06:53:42.750]                         info <- base::paste(info, collapse = "; ")
  [06:53:42.750]                         if (!has_future) {
  [06:53:42.750]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:42.750]                             info)
  [06:53:42.750]                         }
  [06:53:42.750]                         else {
  [06:53:42.750]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:42.750]                             info, version)
  [06:53:42.750]                         }
  [06:53:42.750]                         base::stop(msg)
  [06:53:42.750]                       }
  [06:53:42.750]                     })
  [06:53:42.750]                   }
  [06:53:42.750]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:42.750]                   base::options(mc.cores = 1L)
  [06:53:42.750]                 }
  [06:53:42.750]                 base::local({
  [06:53:42.750]                   for (pkg in c("doFuture", "stats")) {
  [06:53:42.750]                     base::loadNamespace(pkg)
  [06:53:42.750]                     base::library(pkg, character.only = TRUE)
  [06:53:42.750]                   }
  [06:53:42.750]                 })
  [06:53:42.750]             }
  [06:53:42.750]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:42.750]         }
  [06:53:42.750]     }
  [06:53:42.750]     if (base::is.na(TRUE)) {
  [06:53:42.750]     }
  [06:53:42.750]     else {
  [06:53:42.750]         if (TRUE) {
  [06:53:42.750]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:42.750]                 open = "w")
  [06:53:42.750]         }
  [06:53:42.750]         else {
  [06:53:42.750]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:42.750]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:42.750]         }
  [06:53:42.750]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:42.750]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:42.750]             base::sink(type = "output", split = FALSE)
  [06:53:42.750]             base::close(...future.stdout)
  [06:53:42.750]         }, add = TRUE)
  [06:53:42.750]     }
  [06:53:42.750]     ...future.frame <- base::sys.nframe()
  [06:53:42.750]     ...future.conditions <- base::list()
  [06:53:42.750]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:42.750]     ...future.result <- base::tryCatch({
  [06:53:42.750]         base::withCallingHandlers({
  [06:53:42.750]             ...future.value <- base::withVisible(base::local({
  [06:53:42.750]                 ...future.sendCondition <- local({
  [06:53:42.750]                   sendCondition <- NULL
  [06:53:42.750]                   function(frame = 1L) {
  [06:53:42.750]                     if (is.function(sendCondition)) 
  [06:53:42.750]                       return(sendCondition)
  [06:53:42.750]                     ns <- getNamespace("parallel")
  [06:53:42.750]                     if (exists("sendData", mode = "function", 
  [06:53:42.750]                       envir = ns)) {
  [06:53:42.750]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:42.750]                         envir = ns)
  [06:53:42.750]                       envir <- sys.frame(frame)
  [06:53:42.750]                       master <- NULL
  [06:53:42.750]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:42.750]                         !identical(envir, emptyenv())) {
  [06:53:42.750]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:42.750]                           inherits = FALSE)) {
  [06:53:42.750]                           master <- get("master", mode = "list", 
  [06:53:42.750]                             envir = envir, inherits = FALSE)
  [06:53:42.750]                           if (inherits(master, "SOCKnode")) {
  [06:53:42.750]                             sendCondition <<- function(cond) {
  [06:53:42.750]                               data <- list(type = "VALUE", value = cond, 
  [06:53:42.750]                                 success = TRUE)
  [06:53:42.750]                               parallel_sendData(master, data)
  [06:53:42.750]                             }
  [06:53:42.750]                             return(sendCondition)
  [06:53:42.750]                           }
  [06:53:42.750]                         }
  [06:53:42.750]                         frame <- frame + 1L
  [06:53:42.750]                         envir <- sys.frame(frame)
  [06:53:42.750]                       }
  [06:53:42.750]                     }
  [06:53:42.750]                     sendCondition <<- function(cond) NULL
  [06:53:42.750]                   }
  [06:53:42.750]                 })
  [06:53:42.750]                 withCallingHandlers({
  [06:53:42.750]                   {
  [06:53:42.750]                     doFuture::registerDoFuture()
  [06:53:42.750]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:42.750]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:42.750]                       i <- NULL
  [06:53:42.750]                       ...future.env <- environment()
  [06:53:42.750]                       local({
  [06:53:42.750]                         for (name in names(...future.x_jj)) {
  [06:53:42.750]                           assign(name, ...future.x_jj[[name]], 
  [06:53:42.750]                             envir = ...future.env, inherits = FALSE)
  [06:53:42.750]                         }
  [06:53:42.750]                       })
  [06:53:42.750]                       tryCatch({
  [06:53:42.750]                         if (i%%2 == 0) 
  [06:53:42.750]                           stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:42.750]                             i))
  [06:53:42.750]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:42.750]                       }, error = identity)
  [06:53:42.750]                     })
  [06:53:42.750]                   }
  [06:53:42.750]                 }, immediateCondition = function(cond) {
  [06:53:42.750]                   sendCondition <- ...future.sendCondition()
  [06:53:42.750]                   sendCondition(cond)
  [06:53:42.750]                   muffleCondition <- function (cond) 
  [06:53:42.750]                   {
  [06:53:42.750]                     inherits <- base::inherits
  [06:53:42.750]                     invokeRestart <- base::invokeRestart
  [06:53:42.750]                     muffled <- FALSE
  [06:53:42.750]                     if (inherits(cond, "message")) {
  [06:53:42.750]                       invokeRestart("muffleMessage")
  [06:53:42.750]                       muffled <- TRUE
  [06:53:42.750]                     }
  [06:53:42.750]                     else if (inherits(cond, "warning")) {
  [06:53:42.750]                       invokeRestart("muffleWarning")
  [06:53:42.750]                       muffled <- TRUE
  [06:53:42.750]                     }
  [06:53:42.750]                     else if (inherits(cond, "condition")) {
  [06:53:42.750]                       computeRestarts <- base::computeRestarts
  [06:53:42.750]                       grepl <- base::grepl
  [06:53:42.750]                       is.null <- base::is.null
  [06:53:42.750]                       restarts <- computeRestarts(cond)
  [06:53:42.750]                       for (restart in restarts) {
  [06:53:42.750]                         name <- restart$name
  [06:53:42.750]                         if (is.null(name)) 
  [06:53:42.750]                           next
  [06:53:42.750]                         if (!grepl("^muffle", name)) 
  [06:53:42.750]                           next
  [06:53:42.750]                         invokeRestart(restart)
  [06:53:42.750]                         muffled <- TRUE
  [06:53:42.750]                         break
  [06:53:42.750]                       }
  [06:53:42.750]                     }
  [06:53:42.750]                     invisible(muffled)
  [06:53:42.750]                   }
  [06:53:42.750]                   muffleCondition(cond)
  [06:53:42.750]                 })
  [06:53:42.750]             }))
  [06:53:42.750]             future::FutureResult(value = ...future.value$value, 
  [06:53:42.750]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.750]                   ...future.rng), started = ...future.startTime, 
  [06:53:42.750]                 version = "1.8")
  [06:53:42.750]         }, condition = base::local({
  [06:53:42.750]             c <- base::c
  [06:53:42.750]             inherits <- base::inherits
  [06:53:42.750]             invokeRestart <- base::invokeRestart
  [06:53:42.750]             length <- base::length
  [06:53:42.750]             list <- base::list
  [06:53:42.750]             seq.int <- base::seq.int
  [06:53:42.750]             signalCondition <- base::signalCondition
  [06:53:42.750]             sys.calls <- base::sys.calls
  [06:53:42.750]             Sys.time <- base::Sys.time
  [06:53:42.750]             `[[` <- base::`[[`
  [06:53:42.750]             `+` <- base::`+`
  [06:53:42.750]             `<<-` <- base::`<<-`
  [06:53:42.750]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:42.750]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:42.750]                   3L)]
  [06:53:42.750]             }
  [06:53:42.750]             function(cond) {
  [06:53:42.750]                 if (inherits(cond, "error")) {
  [06:53:42.750]                   sessionInformation <- function() {
  [06:53:42.750]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:42.750]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:42.750]                       search = base::search(), system = base::Sys.info())
  [06:53:42.750]                   }
  [06:53:42.750]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.750]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:42.750]                     cond$call), session = sessionInformation(), 
  [06:53:42.750]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:42.750]                   signalCondition(cond)
  [06:53:42.750]                 }
  [06:53:42.750]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:42.750]                 ))) {
  [06:53:42.750]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:42.750]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:42.750]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:42.750]                   if (!signal) {
  [06:53:42.750]                     muffleCondition <- function (cond) 
  [06:53:42.750]                     {
  [06:53:42.750]                       inherits <- base::inherits
  [06:53:42.750]                       invokeRestart <- base::invokeRestart
  [06:53:42.750]                       muffled <- FALSE
  [06:53:42.750]                       if (inherits(cond, "message")) {
  [06:53:42.750]                         invokeRestart("muffleMessage")
  [06:53:42.750]                         muffled <- TRUE
  [06:53:42.750]                       }
  [06:53:42.750]                       else if (inherits(cond, "warning")) {
  [06:53:42.750]                         invokeRestart("muffleWarning")
  [06:53:42.750]                         muffled <- TRUE
  [06:53:42.750]                       }
  [06:53:42.750]                       else if (inherits(cond, "condition")) {
  [06:53:42.750]                         computeRestarts <- base::computeRestarts
  [06:53:42.750]                         grepl <- base::grepl
  [06:53:42.750]                         is.null <- base::is.null
  [06:53:42.750]                         restarts <- computeRestarts(cond)
  [06:53:42.750]                         for (restart in restarts) {
  [06:53:42.750]                           name <- restart$name
  [06:53:42.750]                           if (is.null(name)) 
  [06:53:42.750]                             next
  [06:53:42.750]                           if (!grepl("^muffle", name)) 
  [06:53:42.750]                             next
  [06:53:42.750]                           invokeRestart(restart)
  [06:53:42.750]                           muffled <- TRUE
  [06:53:42.750]                           break
  [06:53:42.750]                         }
  [06:53:42.750]                       }
  [06:53:42.750]                       invisible(muffled)
  [06:53:42.750]                     }
  [06:53:42.750]                     muffleCondition(cond)
  [06:53:42.750]                   }
  [06:53:42.750]                 }
  [06:53:42.750]             }
  [06:53:42.750]         }))
  [06:53:42.750]     }, error = function(ex) {
  [06:53:42.750]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:42.750]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:42.750]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:42.750]     }, finally = {
  [06:53:42.750]         {
  [06:53:42.750]             {
  [06:53:42.750]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:42.750]             }
  [06:53:42.750]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:42.750]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:42.750]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:42.750]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:42.750]                 ...) 
  [06:53:42.750]             {
  [06:53:42.750]                 if (substitute) 
  [06:53:42.750]                   expr <- substitute(expr)
  [06:53:42.750]                 if (is.function(workers)) 
  [06:53:42.750]                   workers <- workers()
  [06:53:42.750]                 workers <- as.integer(workers)
  [06:53:42.750]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:42.750]                   workers >= 1)
  [06:53:42.750]                 if (workers == 1L) {
  [06:53:42.750]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:42.750]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:42.750]                     local = TRUE, label = label, ...))
  [06:53:42.750]                 }
  [06:53:42.750]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:42.750]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:42.750]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:42.750]                   globals = globals, persistent = persistent, 
  [06:53:42.750]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:42.750]                   label = label, ...)
  [06:53:42.750]                 if (!future$lazy) 
  [06:53:42.750]                   future <- run(future)
  [06:53:42.750]                 invisible(future)
  [06:53:42.750]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:42.750]         }
  [06:53:42.750]         base::options(...future.oldOptions)
  [06:53:42.750]     })
  [06:53:42.750]     Sys.time
  [06:53:42.750]     if (base::is.na(TRUE)) {
  [06:53:42.750]     }
  [06:53:42.750]     else {
  [06:53:42.750]         base::sink(type = "output", split = FALSE)
  [06:53:42.750]         if (TRUE) {
  [06:53:42.750]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:42.750]         }
  [06:53:42.750]         else {
  [06:53:42.750]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:42.750]         }
  [06:53:42.750]         base::close(...future.stdout)
  [06:53:42.750]         ...future.stdout <- NULL
  [06:53:42.750]     }
  [06:53:42.750]     ...future.result$conditions <- ...future.conditions
  [06:53:42.750]     ...future.result
  [06:53:42.750] }
  [06:53:42.757] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [06:53:42.758] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [06:53:42.759] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [06:53:42.759] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [06:53:42.760] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [06:53:42.760] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [06:53:42.761] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [06:53:42.762] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [06:53:42.763] MultisessionFuture started
  [06:53:42.764] Chunk #2 of 2 ... DONE
  [06:53:42.764] Launching 2 futures (chunks) ... DONE
  [06:53:42.764] - resolving futures
  [06:53:42.765]   - gathering results & relaying conditions (except errors)
  [06:53:42.765] resolve() on list ...
  [06:53:42.765]  recursive: 0
  [06:53:42.821]  length: 2
  [06:53:42.821] 
  [06:53:42.913] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:42.913] - Validating connection of MultisessionFuture
  [06:53:42.914] - received message: FutureResult
  [06:53:42.914] - Received FutureResult
  [06:53:42.915] - Erased future from FutureRegistry
  [06:53:42.915] result() for ClusterFuture ...
  [06:53:42.915] - result already collected: FutureResult
  [06:53:42.916] result() for ClusterFuture ... done
  [06:53:42.916] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:42.917] Future #1
  [06:53:42.917] result() for ClusterFuture ...
  [06:53:42.917] - result already collected: FutureResult
  [06:53:42.918] result() for ClusterFuture ... done
  [06:53:42.918] result() for ClusterFuture ...
  [06:53:42.919] - result already collected: FutureResult
  [06:53:42.919] result() for ClusterFuture ... done
  [06:53:42.919] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [06:53:42.920] - nx: 2
  [06:53:42.920] - relay: TRUE
  [06:53:42.920] - stdout: TRUE
  [06:53:42.921] - signal: TRUE
  [06:53:42.921] - resignal: FALSE
  [06:53:42.921] - force: FALSE
  [06:53:42.922] - relayed: [n=2] FALSE, FALSE
  [06:53:42.922] - queued futures: [n=2] FALSE, FALSE
  [06:53:42.922]  - until=1
  [06:53:42.923]  - relaying element #1
  [06:53:42.923] result() for ClusterFuture ...
  [06:53:42.923] - result already collected: FutureResult
  [06:53:42.924] result() for ClusterFuture ... done
  [06:53:42.924] result() for ClusterFuture ...
  [06:53:42.924] - result already collected: FutureResult
  [06:53:42.925] result() for ClusterFuture ... done
  [06:53:42.925] result() for ClusterFuture ...
  [06:53:42.926] - result already collected: FutureResult
  [06:53:42.926] result() for ClusterFuture ... done
  [06:53:42.942] result() for ClusterFuture ...
  [06:53:42.943] - result already collected: FutureResult
  [06:53:42.943] result() for ClusterFuture ... done
  [06:53:42.944] - relayed: [n=2] TRUE, FALSE
  [06:53:42.944] - queued futures: [n=2] TRUE, FALSE
  [06:53:42.944] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [06:53:42.945]  length: 1 (resolved future 1)
  [06:53:43.249] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:43.249] - Validating connection of MultisessionFuture
  [06:53:43.250] - received message: FutureResult
  [06:53:43.250] - Received FutureResult
  [06:53:43.250] - Erased future from FutureRegistry
  [06:53:43.251] result() for ClusterFuture ...
  [06:53:43.251] - result already collected: FutureResult
  [06:53:43.252] result() for ClusterFuture ... done
  [06:53:43.252] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:43.252] Future #2
  [06:53:43.252] result() for ClusterFuture ...
  [06:53:43.253] - result already collected: FutureResult
  [06:53:43.253] result() for ClusterFuture ... done
  [06:53:43.254] result() for ClusterFuture ...
  [06:53:43.254] - result already collected: FutureResult
  [06:53:43.254] result() for ClusterFuture ... done
  [06:53:43.255] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [06:53:43.255] - nx: 2
  [06:53:43.255] - relay: TRUE
  [06:53:43.256] - stdout: TRUE
  [06:53:43.256] - signal: TRUE
  [06:53:43.256] - resignal: FALSE
  [06:53:43.256] - force: FALSE
  [06:53:43.257] - relayed: [n=2] TRUE, FALSE
  [06:53:43.257] - queued futures: [n=2] TRUE, FALSE
  [06:53:43.257]  - until=2
  [06:53:43.258]  - relaying element #2
  [06:53:43.258] result() for ClusterFuture ...
  [06:53:43.258] - result already collected: FutureResult
  [06:53:43.259] result() for ClusterFuture ... done
  [06:53:43.259] result() for ClusterFuture ...
  [06:53:43.260] - result already collected: FutureResult
  [06:53:43.260] result() for ClusterFuture ... done
  [06:53:43.260] result() for ClusterFuture ...
  [06:53:43.261] - result already collected: FutureResult
  [06:53:43.261] result() for ClusterFuture ... done
  [06:53:43.261] result() for ClusterFuture ...
  [06:53:43.262] - result already collected: FutureResult
  [06:53:43.262] result() for ClusterFuture ... done
  [06:53:43.262] - relayed: [n=2] TRUE, TRUE
  [06:53:43.279] - queued futures: [n=2] TRUE, TRUE
  [06:53:43.279] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [06:53:43.280]  length: 0 (resolved future 2)
  [06:53:43.280] Relaying remaining futures
  [06:53:43.280] signalConditionsASAP(NULL, pos=0) ...
  [06:53:43.281] - nx: 2
  [06:53:43.281] - relay: TRUE
  [06:53:43.281] - stdout: TRUE
  [06:53:43.282] - signal: TRUE
  [06:53:43.282] - resignal: FALSE
  [06:53:43.282] - force: FALSE
  [06:53:43.283] - relayed: [n=2] TRUE, TRUE
  [06:53:43.283] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:43.284] - relayed: [n=2] TRUE, TRUE
  [06:53:43.284] - queued futures: [n=2] TRUE, TRUE
  [06:53:43.284] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:43.285] resolve() on list ... DONE
  [06:53:43.285] - collecting values of futures
  [06:53:43.285] result() for ClusterFuture ...
  [06:53:43.286] - result already collected: FutureResult
  [06:53:43.286] result() for ClusterFuture ... done
  [06:53:43.287] result() for ClusterFuture ...
  [06:53:43.287] - result already collected: FutureResult
  [06:53:43.287] result() for ClusterFuture ... done
  [06:53:43.288] result() for ClusterFuture ...
  [06:53:43.288] - result already collected: FutureResult
  [06:53:43.288] result() for ClusterFuture ... done
  [06:53:43.289] result() for ClusterFuture ...
  [06:53:43.289] - result already collected: FutureResult
  [06:53:43.289] result() for ClusterFuture ... done
  [06:53:43.290] - accumulating results
  [06:53:43.292] - processing errors (handler = 'pass')
  [06:53:43.293] - extracting results
  [06:53:43.293] doFuture() ... DONE
  List of 10
   $ : num 0.199
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 2"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.121
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 4"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.027
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 6"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.00222
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 8"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 6.69e-05
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 10"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  - plan('multisession') ... DONE
  - plan('cluster') ...
  [06:53:43.380] plan(): Setting new future strategy stack:
  [06:53:43.380] List of future strategies:
  [06:53:43.380] 1. cluster:
  [06:53:43.380]    - 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, ...)
  [06:53:43.380]    - tweaked: FALSE
  [06:53:43.380]    - call: plan(strategy)
  [06:53:43.382] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:43.382] cluster:
  [06:53:43.382] - 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, ...)
  [06:53:43.382] - tweaked: FALSE
  [06:53:43.382] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 26332
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589763777fe.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.7589763777fe.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589763777fe.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=26332 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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75893e22b0d2.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.75893e22b0d2.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75893e22b0d2.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=26332 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [06:53:45.864] getGlobalsAndPackages() ...
  [06:53:45.864] Not searching for globals
  [06:53:45.865] - globals: [0] <none>
  [06:53:45.865] getGlobalsAndPackages() ... DONE
  [06:53:45.870] Packages needed by the future expression (n = 0): <none>
  [06:53:45.870] Packages needed by future strategies (n = 0): <none>
  [06:53:45.876] {
  [06:53:45.876]     {
  [06:53:45.876]         ...future.startTime <- base::Sys.time()
  [06:53:45.876]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:45.876]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:45.876]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:45.876]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:45.876]             future.resolve.recursive = NULL, width = 80L)
  [06:53:45.876]         {
  [06:53:45.876]             {
  [06:53:45.876]                 base::local({
  [06:53:45.876]                   has_future <- base::requireNamespace("future", 
  [06:53:45.876]                     quietly = TRUE)
  [06:53:45.876]                   version <- if (has_future) 
  [06:53:45.876]                     utils::packageVersion("future")
  [06:53:45.876]                   else NULL
  [06:53:45.876]                   if (!has_future || version < "1.8.0") {
  [06:53:45.876]                     info <- base::c(r_version = base::gsub("R version ", 
  [06:53:45.876]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [06:53:45.876]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:45.876]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:45.876]                         "release", "version")], collapse = " "), 
  [06:53:45.876]                       hostname = base::Sys.info()[["nodename"]])
  [06:53:45.876]                     info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:45.876]                       info)
  [06:53:45.876]                     info <- base::paste(info, collapse = "; ")
  [06:53:45.876]                     if (!has_future) {
  [06:53:45.876]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:45.876]                         info)
  [06:53:45.876]                     }
  [06:53:45.876]                     else {
  [06:53:45.876]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:45.876]                         info, version)
  [06:53:45.876]                     }
  [06:53:45.876]                     base::stop(msg)
  [06:53:45.876]                   }
  [06:53:45.876]                 })
  [06:53:45.876]             }
  [06:53:45.876]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:45.876]         }
  [06:53:45.876]     }
  [06:53:45.876]     if (base::is.na(TRUE)) {
  [06:53:45.876]     }
  [06:53:45.876]     else {
  [06:53:45.876]         if (TRUE) {
  [06:53:45.876]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:45.876]                 open = "w")
  [06:53:45.876]         }
  [06:53:45.876]         else {
  [06:53:45.876]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:45.876]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:45.876]         }
  [06:53:45.876]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:45.876]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:45.876]             base::sink(type = "output", split = FALSE)
  [06:53:45.876]             base::close(...future.stdout)
  [06:53:45.876]         }, add = TRUE)
  [06:53:45.876]     }
  [06:53:45.876]     ...future.frame <- base::sys.nframe()
  [06:53:45.876]     ...future.conditions <- base::list()
  [06:53:45.876]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:45.876]     ...future.result <- base::tryCatch({
  [06:53:45.876]         base::withCallingHandlers({
  [06:53:45.876]             ...future.value <- base::withVisible(base::local({
  [06:53:45.876]                 ...future.sendCondition <- local({
  [06:53:45.876]                   sendCondition <- NULL
  [06:53:45.876]                   function(frame = 1L) {
  [06:53:45.876]                     if (is.function(sendCondition)) 
  [06:53:45.876]                       return(sendCondition)
  [06:53:45.876]                     ns <- getNamespace("parallel")
  [06:53:45.876]                     if (exists("sendData", mode = "function", 
  [06:53:45.876]                       envir = ns)) {
  [06:53:45.876]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:45.876]                         envir = ns)
  [06:53:45.876]                       envir <- sys.frame(frame)
  [06:53:45.876]                       master <- NULL
  [06:53:45.876]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:45.876]                         !identical(envir, emptyenv())) {
  [06:53:45.876]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:45.876]                           inherits = FALSE)) {
  [06:53:45.876]                           master <- get("master", mode = "list", 
  [06:53:45.876]                             envir = envir, inherits = FALSE)
  [06:53:45.876]                           if (inherits(master, "SOCKnode")) {
  [06:53:45.876]                             sendCondition <<- function(cond) {
  [06:53:45.876]                               data <- list(type = "VALUE", value = cond, 
  [06:53:45.876]                                 success = TRUE)
  [06:53:45.876]                               parallel_sendData(master, data)
  [06:53:45.876]                             }
  [06:53:45.876]                             return(sendCondition)
  [06:53:45.876]                           }
  [06:53:45.876]                         }
  [06:53:45.876]                         frame <- frame + 1L
  [06:53:45.876]                         envir <- sys.frame(frame)
  [06:53:45.876]                       }
  [06:53:45.876]                     }
  [06:53:45.876]                     sendCondition <<- function(cond) NULL
  [06:53:45.876]                   }
  [06:53:45.876]                 })
  [06:53:45.876]                 withCallingHandlers({
  [06:53:45.876]                   NA
  [06:53:45.876]                 }, immediateCondition = function(cond) {
  [06:53:45.876]                   sendCondition <- ...future.sendCondition()
  [06:53:45.876]                   sendCondition(cond)
  [06:53:45.876]                   muffleCondition <- function (cond) 
  [06:53:45.876]                   {
  [06:53:45.876]                     inherits <- base::inherits
  [06:53:45.876]                     invokeRestart <- base::invokeRestart
  [06:53:45.876]                     muffled <- FALSE
  [06:53:45.876]                     if (inherits(cond, "message")) {
  [06:53:45.876]                       invokeRestart("muffleMessage")
  [06:53:45.876]                       muffled <- TRUE
  [06:53:45.876]                     }
  [06:53:45.876]                     else if (inherits(cond, "warning")) {
  [06:53:45.876]                       invokeRestart("muffleWarning")
  [06:53:45.876]                       muffled <- TRUE
  [06:53:45.876]                     }
  [06:53:45.876]                     else if (inherits(cond, "condition")) {
  [06:53:45.876]                       computeRestarts <- base::computeRestarts
  [06:53:45.876]                       grepl <- base::grepl
  [06:53:45.876]                       is.null <- base::is.null
  [06:53:45.876]                       restarts <- computeRestarts(cond)
  [06:53:45.876]                       for (restart in restarts) {
  [06:53:45.876]                         name <- restart$name
  [06:53:45.876]                         if (is.null(name)) 
  [06:53:45.876]                           next
  [06:53:45.876]                         if (!grepl("^muffle", name)) 
  [06:53:45.876]                           next
  [06:53:45.876]                         invokeRestart(restart)
  [06:53:45.876]                         muffled <- TRUE
  [06:53:45.876]                         break
  [06:53:45.876]                       }
  [06:53:45.876]                     }
  [06:53:45.876]                     invisible(muffled)
  [06:53:45.876]                   }
  [06:53:45.876]                   muffleCondition(cond)
  [06:53:45.876]                 })
  [06:53:45.876]             }))
  [06:53:45.876]             future::FutureResult(value = ...future.value$value, 
  [06:53:45.876]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:45.876]                   ...future.rng), started = ...future.startTime, 
  [06:53:45.876]                 version = "1.8")
  [06:53:45.876]         }, condition = base::local({
  [06:53:45.876]             c <- base::c
  [06:53:45.876]             inherits <- base::inherits
  [06:53:45.876]             invokeRestart <- base::invokeRestart
  [06:53:45.876]             length <- base::length
  [06:53:45.876]             list <- base::list
  [06:53:45.876]             seq.int <- base::seq.int
  [06:53:45.876]             signalCondition <- base::signalCondition
  [06:53:45.876]             sys.calls <- base::sys.calls
  [06:53:45.876]             Sys.time <- base::Sys.time
  [06:53:45.876]             `[[` <- base::`[[`
  [06:53:45.876]             `+` <- base::`+`
  [06:53:45.876]             `<<-` <- base::`<<-`
  [06:53:45.876]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:45.876]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:45.876]                   3L)]
  [06:53:45.876]             }
  [06:53:45.876]             function(cond) {
  [06:53:45.876]                 if (inherits(cond, "error")) {
  [06:53:45.876]                   sessionInformation <- function() {
  [06:53:45.876]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:45.876]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:45.876]                       search = base::search(), system = base::Sys.info())
  [06:53:45.876]                   }
  [06:53:45.876]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:45.876]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:45.876]                     cond$call), session = sessionInformation(), 
  [06:53:45.876]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:45.876]                   signalCondition(cond)
  [06:53:45.876]                 }
  [06:53:45.876]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:45.876]                 ))) {
  [06:53:45.876]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:45.876]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:45.876]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:45.876]                   if (!signal) {
  [06:53:45.876]                     muffleCondition <- function (cond) 
  [06:53:45.876]                     {
  [06:53:45.876]                       inherits <- base::inherits
  [06:53:45.876]                       invokeRestart <- base::invokeRestart
  [06:53:45.876]                       muffled <- FALSE
  [06:53:45.876]                       if (inherits(cond, "message")) {
  [06:53:45.876]                         invokeRestart("muffleMessage")
  [06:53:45.876]                         muffled <- TRUE
  [06:53:45.876]                       }
  [06:53:45.876]                       else if (inherits(cond, "warning")) {
  [06:53:45.876]                         invokeRestart("muffleWarning")
  [06:53:45.876]                         muffled <- TRUE
  [06:53:45.876]                       }
  [06:53:45.876]                       else if (inherits(cond, "condition")) {
  [06:53:45.876]                         computeRestarts <- base::computeRestarts
  [06:53:45.876]                         grepl <- base::grepl
  [06:53:45.876]                         is.null <- base::is.null
  [06:53:45.876]                         restarts <- computeRestarts(cond)
  [06:53:45.876]                         for (restart in restarts) {
  [06:53:45.876]                           name <- restart$name
  [06:53:45.876]                           if (is.null(name)) 
  [06:53:45.876]                             next
  [06:53:45.876]                           if (!grepl("^muffle", name)) 
  [06:53:45.876]                             next
  [06:53:45.876]                           invokeRestart(restart)
  [06:53:45.876]                           muffled <- TRUE
  [06:53:45.876]                           break
  [06:53:45.876]                         }
  [06:53:45.876]                       }
  [06:53:45.876]                       invisible(muffled)
  [06:53:45.876]                     }
  [06:53:45.876]                     muffleCondition(cond)
  [06:53:45.876]                   }
  [06:53:45.876]                 }
  [06:53:45.876]             }
  [06:53:45.876]         }))
  [06:53:45.876]     }, error = function(ex) {
  [06:53:45.876]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:45.876]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:45.876]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:45.876]     }, finally = {
  [06:53:45.876]         {
  [06:53:45.876]             NULL
  [06:53:45.876]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:45.876]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:45.876]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:45.876]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:45.876]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:45.876]                 ...) 
  [06:53:45.876]             {
  [06:53:45.876]                 if (substitute) 
  [06:53:45.876]                   expr <- substitute(expr)
  [06:53:45.876]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:45.876]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:45.876]                   globals = globals, persistent = persistent, 
  [06:53:45.876]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:45.876]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:45.876]                   label = label, ...)
  [06:53:45.876]                 if (!future$lazy) 
  [06:53:45.876]                   future <- run(future)
  [06:53:45.876]                 invisible(future)
  [06:53:45.876]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:45.876]         }
  [06:53:45.876]         base::options(...future.oldOptions)
  [06:53:45.876]     })
  [06:53:45.876]     Sys.time
  [06:53:45.876]     if (base::is.na(TRUE)) {
  [06:53:45.876]     }
  [06:53:45.876]     else {
  [06:53:45.876]         base::sink(type = "output", split = FALSE)
  [06:53:45.876]         if (TRUE) {
  [06:53:45.876]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:45.876]         }
  [06:53:45.876]         else {
  [06:53:45.876]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:45.876]         }
  [06:53:45.876]         base::close(...future.stdout)
  [06:53:45.876]         ...future.stdout <- NULL
  [06:53:45.876]     }
  [06:53:45.876]     ...future.result$conditions <- ...future.conditions
  [06:53:45.876]     ...future.result
  [06:53:45.876] }
  [06:53:45.884] ClusterFuture started
  [06:53:45.885] result() for ClusterFuture ...
  [06:53:45.885] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:45.886] - Validating connection of ClusterFuture
  [06:53:46.101] - received message: FutureResult
  [06:53:46.102] - Received FutureResult
  [06:53:46.102] - Erased future from FutureRegistry
  [06:53:46.103] result() for ClusterFuture ...
  [06:53:46.103] - result already collected: FutureResult
  [06:53:46.103] result() for ClusterFuture ... done
  [06:53:46.104] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:46.104] result() for ClusterFuture ... done
  [06:53:46.105] result() for ClusterFuture ...
  [06:53:46.105] - result already collected: FutureResult
  [06:53:46.105] result() for ClusterFuture ... done
  [06:53:46.106] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [06:53:46.107] plan(): nbrOfWorkers() = 2
  [06:53:46.108] doFuture() ...
  [06:53:46.110] - dummy globals (as locals): [1] 'i'
  [06:53:46.112] - R expression:
  [06:53:46.112] {
  [06:53:46.112]     doFuture::registerDoFuture()
  [06:53:46.112]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.112]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.112]         i <- NULL
  [06:53:46.112]         ...future.env <- environment()
  [06:53:46.112]         local({
  [06:53:46.112]             for (name in names(...future.x_jj)) {
  [06:53:46.112]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:46.112]                   inherits = FALSE)
  [06:53:46.112]             }
  [06:53:46.112]         })
  [06:53:46.112]         tryCatch({
  [06:53:46.112]             if (i%%2 == 0) 
  [06:53:46.112]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:46.112]                   i))
  [06:53:46.112]             dnorm(i, mean = mu, sd = sigma)
  [06:53:46.112]         }, error = identity)
  [06:53:46.112]     })
  [06:53:46.112] }
  [06:53:46.113] - identifying globals and packages ...
  [06:53:46.114] getGlobalsAndPackages() ...
  [06:53:46.114] Searching for globals...
  [06:53:46.152] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:46.152] Searching for globals ... DONE
  [06:53:46.153] Resolving globals: FALSE
  [06:53:46.171] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:46.172] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.172] - packages: [1] 'stats'
  [06:53:46.172] getGlobalsAndPackages() ... DONE
  [06:53:46.173] List of 3
  [06:53:46.173]  $ ...future.x_ii: NULL
  [06:53:46.173]  $ mu            : num 1
  [06:53:46.173]  $ sigma         : num 2
  [06:53:46.173]  - attr(*, "where")=List of 3
  [06:53:46.173]   ..$ ...future.x_ii:<environment: 0x557600a5d230> 
  [06:53:46.173]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:46.173]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:46.173]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:46.173]  - attr(*, "resolved")= logi FALSE
  [06:53:46.173]  - attr(*, "total_size")= num 112
  [06:53:46.185]   - R expression:
  [06:53:46.185] {
  [06:53:46.185]     doFuture::registerDoFuture()
  [06:53:46.185]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.185]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.185]         i <- NULL
  [06:53:46.185]         ...future.env <- environment()
  [06:53:46.185]         local({
  [06:53:46.185]             for (name in names(...future.x_jj)) {
  [06:53:46.185]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:46.185]                   inherits = FALSE)
  [06:53:46.185]             }
  [06:53:46.185]         })
  [06:53:46.185]         tryCatch({
  [06:53:46.185]             if (i%%2 == 0) 
  [06:53:46.185]                 stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:46.185]                   i))
  [06:53:46.185]             dnorm(i, mean = mu, sd = sigma)
  [06:53:46.185]         }, error = identity)
  [06:53:46.185]     })
  [06:53:46.185] }
  [06:53:46.186]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.203] List of 3
  [06:53:46.203]  $ ...future.x_ii: NULL
  [06:53:46.203]  $ mu            : num 1
  [06:53:46.203]  $ sigma         : num 2
  [06:53:46.203]  - attr(*, "where")=List of 3
  [06:53:46.203]   ..$ ...future.x_ii:<environment: 0x557600a5d230> 
  [06:53:46.203]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:46.203]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:46.203]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:46.203]  - attr(*, "resolved")= logi FALSE
  [06:53:46.203]  - attr(*, "total_size")= num 112
  [06:53:46.214]   - packages: [2] 'doFuture', 'stats'
  [06:53:46.214] - identifying globals and packages ... DONE
  [06:53:46.216] Number of chunks: 2
  [06:53:46.217] Number of futures (= number of chunks): 2
  [06:53:46.218] Launching 2 futures (chunks) ...
  [06:53:46.218] Chunk #1 of 2 ...
  [06:53:46.234]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:46.235] getGlobalsAndPackages() ...
  [06:53:46.235] Searching for globals...
  [06:53:46.236] 
  [06:53:46.237] Searching for globals ... DONE
  [06:53:46.237] - globals: [0] <none>
  [06:53:46.237] getGlobalsAndPackages() ... DONE
  [06:53:46.238] 
  [06:53:46.238] 
  [06:53:46.238]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:46.240] getGlobalsAndPackages() ...
  [06:53:46.241] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.241] Resolving globals: FALSE
  [06:53:46.242] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:46.243] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.243] 
  [06:53:46.244] getGlobalsAndPackages() ... DONE
  [06:53:46.248] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:46.248] Packages needed by future strategies (n = 0): <none>
  [06:53:46.271] {
  [06:53:46.271]     {
  [06:53:46.271]         ...future.startTime <- base::Sys.time()
  [06:53:46.271]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:46.271]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:46.271]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:46.271]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:46.271]             future.resolve.recursive = NULL, width = 80L)
  [06:53:46.271]         {
  [06:53:46.271]             {
  [06:53:46.271]                 {
  [06:53:46.271]                   base::local({
  [06:53:46.271]                     has_future <- base::requireNamespace("future", 
  [06:53:46.271]                       quietly = TRUE)
  [06:53:46.271]                     version <- if (has_future) 
  [06:53:46.271]                       utils::packageVersion("future")
  [06:53:46.271]                     else NULL
  [06:53:46.271]                     if (!has_future || version < "1.8.0") {
  [06:53:46.271]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:46.271]                         "", base::R.version$version.string), 
  [06:53:46.271]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:46.271]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:46.271]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:46.271]                           "release", "version")], collapse = " "), 
  [06:53:46.271]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:46.271]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:46.271]                         info)
  [06:53:46.271]                       info <- base::paste(info, collapse = "; ")
  [06:53:46.271]                       if (!has_future) {
  [06:53:46.271]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:46.271]                           info)
  [06:53:46.271]                       }
  [06:53:46.271]                       else {
  [06:53:46.271]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:46.271]                           info, version)
  [06:53:46.271]                       }
  [06:53:46.271]                       base::stop(msg)
  [06:53:46.271]                     }
  [06:53:46.271]                   })
  [06:53:46.271]                 }
  [06:53:46.271]                 base::local({
  [06:53:46.271]                   for (pkg in c("doFuture", "stats")) {
  [06:53:46.271]                     base::loadNamespace(pkg)
  [06:53:46.271]                     base::library(pkg, character.only = TRUE)
  [06:53:46.271]                   }
  [06:53:46.271]                 })
  [06:53:46.271]             }
  [06:53:46.271]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:46.271]         }
  [06:53:46.271]     }
  [06:53:46.271]     if (base::is.na(TRUE)) {
  [06:53:46.271]     }
  [06:53:46.271]     else {
  [06:53:46.271]         if (TRUE) {
  [06:53:46.271]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:46.271]                 open = "w")
  [06:53:46.271]         }
  [06:53:46.271]         else {
  [06:53:46.271]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:46.271]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:46.271]         }
  [06:53:46.271]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:46.271]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:46.271]             base::sink(type = "output", split = FALSE)
  [06:53:46.271]             base::close(...future.stdout)
  [06:53:46.271]         }, add = TRUE)
  [06:53:46.271]     }
  [06:53:46.271]     ...future.frame <- base::sys.nframe()
  [06:53:46.271]     ...future.conditions <- base::list()
  [06:53:46.271]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:46.271]     ...future.result <- base::tryCatch({
  [06:53:46.271]         base::withCallingHandlers({
  [06:53:46.271]             ...future.value <- base::withVisible(base::local({
  [06:53:46.271]                 ...future.sendCondition <- local({
  [06:53:46.271]                   sendCondition <- NULL
  [06:53:46.271]                   function(frame = 1L) {
  [06:53:46.271]                     if (is.function(sendCondition)) 
  [06:53:46.271]                       return(sendCondition)
  [06:53:46.271]                     ns <- getNamespace("parallel")
  [06:53:46.271]                     if (exists("sendData", mode = "function", 
  [06:53:46.271]                       envir = ns)) {
  [06:53:46.271]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:46.271]                         envir = ns)
  [06:53:46.271]                       envir <- sys.frame(frame)
  [06:53:46.271]                       master <- NULL
  [06:53:46.271]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:46.271]                         !identical(envir, emptyenv())) {
  [06:53:46.271]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:46.271]                           inherits = FALSE)) {
  [06:53:46.271]                           master <- get("master", mode = "list", 
  [06:53:46.271]                             envir = envir, inherits = FALSE)
  [06:53:46.271]                           if (inherits(master, "SOCKnode")) {
  [06:53:46.271]                             sendCondition <<- function(cond) {
  [06:53:46.271]                               data <- list(type = "VALUE", value = cond, 
  [06:53:46.271]                                 success = TRUE)
  [06:53:46.271]                               parallel_sendData(master, data)
  [06:53:46.271]                             }
  [06:53:46.271]                             return(sendCondition)
  [06:53:46.271]                           }
  [06:53:46.271]                         }
  [06:53:46.271]                         frame <- frame + 1L
  [06:53:46.271]                         envir <- sys.frame(frame)
  [06:53:46.271]                       }
  [06:53:46.271]                     }
  [06:53:46.271]                     sendCondition <<- function(cond) NULL
  [06:53:46.271]                   }
  [06:53:46.271]                 })
  [06:53:46.271]                 withCallingHandlers({
  [06:53:46.271]                   {
  [06:53:46.271]                     doFuture::registerDoFuture()
  [06:53:46.271]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.271]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.271]                       i <- NULL
  [06:53:46.271]                       ...future.env <- environment()
  [06:53:46.271]                       local({
  [06:53:46.271]                         for (name in names(...future.x_jj)) {
  [06:53:46.271]                           assign(name, ...future.x_jj[[name]], 
  [06:53:46.271]                             envir = ...future.env, inherits = FALSE)
  [06:53:46.271]                         }
  [06:53:46.271]                       })
  [06:53:46.271]                       tryCatch({
  [06:53:46.271]                         if (i%%2 == 0) 
  [06:53:46.271]                           stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:46.271]                             i))
  [06:53:46.271]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:46.271]                       }, error = identity)
  [06:53:46.271]                     })
  [06:53:46.271]                   }
  [06:53:46.271]                 }, immediateCondition = function(cond) {
  [06:53:46.271]                   sendCondition <- ...future.sendCondition()
  [06:53:46.271]                   sendCondition(cond)
  [06:53:46.271]                   muffleCondition <- function (cond) 
  [06:53:46.271]                   {
  [06:53:46.271]                     inherits <- base::inherits
  [06:53:46.271]                     invokeRestart <- base::invokeRestart
  [06:53:46.271]                     muffled <- FALSE
  [06:53:46.271]                     if (inherits(cond, "message")) {
  [06:53:46.271]                       invokeRestart("muffleMessage")
  [06:53:46.271]                       muffled <- TRUE
  [06:53:46.271]                     }
  [06:53:46.271]                     else if (inherits(cond, "warning")) {
  [06:53:46.271]                       invokeRestart("muffleWarning")
  [06:53:46.271]                       muffled <- TRUE
  [06:53:46.271]                     }
  [06:53:46.271]                     else if (inherits(cond, "condition")) {
  [06:53:46.271]                       computeRestarts <- base::computeRestarts
  [06:53:46.271]                       grepl <- base::grepl
  [06:53:46.271]                       is.null <- base::is.null
  [06:53:46.271]                       restarts <- computeRestarts(cond)
  [06:53:46.271]                       for (restart in restarts) {
  [06:53:46.271]                         name <- restart$name
  [06:53:46.271]                         if (is.null(name)) 
  [06:53:46.271]                           next
  [06:53:46.271]                         if (!grepl("^muffle", name)) 
  [06:53:46.271]                           next
  [06:53:46.271]                         invokeRestart(restart)
  [06:53:46.271]                         muffled <- TRUE
  [06:53:46.271]                         break
  [06:53:46.271]                       }
  [06:53:46.271]                     }
  [06:53:46.271]                     invisible(muffled)
  [06:53:46.271]                   }
  [06:53:46.271]                   muffleCondition(cond)
  [06:53:46.271]                 })
  [06:53:46.271]             }))
  [06:53:46.271]             future::FutureResult(value = ...future.value$value, 
  [06:53:46.271]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.271]                   ...future.rng), started = ...future.startTime, 
  [06:53:46.271]                 version = "1.8")
  [06:53:46.271]         }, condition = base::local({
  [06:53:46.271]             c <- base::c
  [06:53:46.271]             inherits <- base::inherits
  [06:53:46.271]             invokeRestart <- base::invokeRestart
  [06:53:46.271]             length <- base::length
  [06:53:46.271]             list <- base::list
  [06:53:46.271]             seq.int <- base::seq.int
  [06:53:46.271]             signalCondition <- base::signalCondition
  [06:53:46.271]             sys.calls <- base::sys.calls
  [06:53:46.271]             Sys.time <- base::Sys.time
  [06:53:46.271]             `[[` <- base::`[[`
  [06:53:46.271]             `+` <- base::`+`
  [06:53:46.271]             `<<-` <- base::`<<-`
  [06:53:46.271]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:46.271]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:46.271]                   3L)]
  [06:53:46.271]             }
  [06:53:46.271]             function(cond) {
  [06:53:46.271]                 if (inherits(cond, "error")) {
  [06:53:46.271]                   sessionInformation <- function() {
  [06:53:46.271]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:46.271]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:46.271]                       search = base::search(), system = base::Sys.info())
  [06:53:46.271]                   }
  [06:53:46.271]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.271]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:46.271]                     cond$call), session = sessionInformation(), 
  [06:53:46.271]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:46.271]                   signalCondition(cond)
  [06:53:46.271]                 }
  [06:53:46.271]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:46.271]                 ))) {
  [06:53:46.271]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:46.271]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.271]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:46.271]                   if (!signal) {
  [06:53:46.271]                     muffleCondition <- function (cond) 
  [06:53:46.271]                     {
  [06:53:46.271]                       inherits <- base::inherits
  [06:53:46.271]                       invokeRestart <- base::invokeRestart
  [06:53:46.271]                       muffled <- FALSE
  [06:53:46.271]                       if (inherits(cond, "message")) {
  [06:53:46.271]                         invokeRestart("muffleMessage")
  [06:53:46.271]                         muffled <- TRUE
  [06:53:46.271]                       }
  [06:53:46.271]                       else if (inherits(cond, "warning")) {
  [06:53:46.271]                         invokeRestart("muffleWarning")
  [06:53:46.271]                         muffled <- TRUE
  [06:53:46.271]                       }
  [06:53:46.271]                       else if (inherits(cond, "condition")) {
  [06:53:46.271]                         computeRestarts <- base::computeRestarts
  [06:53:46.271]                         grepl <- base::grepl
  [06:53:46.271]                         is.null <- base::is.null
  [06:53:46.271]                         restarts <- computeRestarts(cond)
  [06:53:46.271]                         for (restart in restarts) {
  [06:53:46.271]                           name <- restart$name
  [06:53:46.271]                           if (is.null(name)) 
  [06:53:46.271]                             next
  [06:53:46.271]                           if (!grepl("^muffle", name)) 
  [06:53:46.271]                             next
  [06:53:46.271]                           invokeRestart(restart)
  [06:53:46.271]                           muffled <- TRUE
  [06:53:46.271]                           break
  [06:53:46.271]                         }
  [06:53:46.271]                       }
  [06:53:46.271]                       invisible(muffled)
  [06:53:46.271]                     }
  [06:53:46.271]                     muffleCondition(cond)
  [06:53:46.271]                   }
  [06:53:46.271]                 }
  [06:53:46.271]             }
  [06:53:46.271]         }))
  [06:53:46.271]     }, error = function(ex) {
  [06:53:46.271]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:46.271]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.271]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:46.271]     }, finally = {
  [06:53:46.271]         {
  [06:53:46.271]             NULL
  [06:53:46.271]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:46.271]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:46.271]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:46.271]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:46.271]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:46.271]                 ...) 
  [06:53:46.271]             {
  [06:53:46.271]                 if (substitute) 
  [06:53:46.271]                   expr <- substitute(expr)
  [06:53:46.271]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:46.271]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:46.271]                   globals = globals, persistent = persistent, 
  [06:53:46.271]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:46.271]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:46.271]                   label = label, ...)
  [06:53:46.271]                 if (!future$lazy) 
  [06:53:46.271]                   future <- run(future)
  [06:53:46.271]                 invisible(future)
  [06:53:46.271]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:46.271]         }
  [06:53:46.271]         base::options(...future.oldOptions)
  [06:53:46.271]     })
  [06:53:46.271]     Sys.time
  [06:53:46.271]     if (base::is.na(TRUE)) {
  [06:53:46.271]     }
  [06:53:46.271]     else {
  [06:53:46.271]         base::sink(type = "output", split = FALSE)
  [06:53:46.271]         if (TRUE) {
  [06:53:46.271]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:46.271]         }
  [06:53:46.271]         else {
  [06:53:46.271]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:46.271]         }
  [06:53:46.271]         base::close(...future.stdout)
  [06:53:46.271]         ...future.stdout <- NULL
  [06:53:46.271]     }
  [06:53:46.271]     ...future.result$conditions <- ...future.conditions
  [06:53:46.271]     ...future.result
  [06:53:46.271] }
  [06:53:46.291] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [06:53:46.291] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [06:53:46.293] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [06:53:46.293] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [06:53:46.294] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [06:53:46.294] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [06:53:46.295] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [06:53:46.296] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [06:53:46.297] ClusterFuture started
  [06:53:46.298] Chunk #1 of 2 ... DONE
  [06:53:46.298] Chunk #2 of 2 ...
  [06:53:46.298]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:46.299] getGlobalsAndPackages() ...
  [06:53:46.299] Searching for globals...
  [06:53:46.304] 
  [06:53:46.304] Searching for globals ... DONE
  [06:53:46.304] - globals: [0] <none>
  [06:53:46.305] getGlobalsAndPackages() ... DONE
  [06:53:46.305] 
  [06:53:46.305] 
  [06:53:46.306]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:46.308] getGlobalsAndPackages() ...
  [06:53:46.308] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.309] Resolving globals: FALSE
  [06:53:46.326] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:46.327] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.327] 
  [06:53:46.328] getGlobalsAndPackages() ... DONE
  [06:53:46.332] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:46.333] Packages needed by future strategies (n = 0): <none>
  [06:53:46.363] {
  [06:53:46.363]     {
  [06:53:46.363]         ...future.startTime <- base::Sys.time()
  [06:53:46.363]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:46.363]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:46.363]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:46.363]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:46.363]             future.resolve.recursive = NULL, width = 80L)
  [06:53:46.363]         {
  [06:53:46.363]             {
  [06:53:46.363]                 {
  [06:53:46.363]                   base::local({
  [06:53:46.363]                     has_future <- base::requireNamespace("future", 
  [06:53:46.363]                       quietly = TRUE)
  [06:53:46.363]                     version <- if (has_future) 
  [06:53:46.363]                       utils::packageVersion("future")
  [06:53:46.363]                     else NULL
  [06:53:46.363]                     if (!has_future || version < "1.8.0") {
  [06:53:46.363]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:46.363]                         "", base::R.version$version.string), 
  [06:53:46.363]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:46.363]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:46.363]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:46.363]                           "release", "version")], collapse = " "), 
  [06:53:46.363]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:46.363]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:46.363]                         info)
  [06:53:46.363]                       info <- base::paste(info, collapse = "; ")
  [06:53:46.363]                       if (!has_future) {
  [06:53:46.363]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:46.363]                           info)
  [06:53:46.363]                       }
  [06:53:46.363]                       else {
  [06:53:46.363]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:46.363]                           info, version)
  [06:53:46.363]                       }
  [06:53:46.363]                       base::stop(msg)
  [06:53:46.363]                     }
  [06:53:46.363]                   })
  [06:53:46.363]                 }
  [06:53:46.363]                 base::local({
  [06:53:46.363]                   for (pkg in c("doFuture", "stats")) {
  [06:53:46.363]                     base::loadNamespace(pkg)
  [06:53:46.363]                     base::library(pkg, character.only = TRUE)
  [06:53:46.363]                   }
  [06:53:46.363]                 })
  [06:53:46.363]             }
  [06:53:46.363]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:46.363]         }
  [06:53:46.363]     }
  [06:53:46.363]     if (base::is.na(TRUE)) {
  [06:53:46.363]     }
  [06:53:46.363]     else {
  [06:53:46.363]         if (TRUE) {
  [06:53:46.363]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:46.363]                 open = "w")
  [06:53:46.363]         }
  [06:53:46.363]         else {
  [06:53:46.363]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:46.363]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:46.363]         }
  [06:53:46.363]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:46.363]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:46.363]             base::sink(type = "output", split = FALSE)
  [06:53:46.363]             base::close(...future.stdout)
  [06:53:46.363]         }, add = TRUE)
  [06:53:46.363]     }
  [06:53:46.363]     ...future.frame <- base::sys.nframe()
  [06:53:46.363]     ...future.conditions <- base::list()
  [06:53:46.363]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:46.363]     ...future.result <- base::tryCatch({
  [06:53:46.363]         base::withCallingHandlers({
  [06:53:46.363]             ...future.value <- base::withVisible(base::local({
  [06:53:46.363]                 ...future.sendCondition <- local({
  [06:53:46.363]                   sendCondition <- NULL
  [06:53:46.363]                   function(frame = 1L) {
  [06:53:46.363]                     if (is.function(sendCondition)) 
  [06:53:46.363]                       return(sendCondition)
  [06:53:46.363]                     ns <- getNamespace("parallel")
  [06:53:46.363]                     if (exists("sendData", mode = "function", 
  [06:53:46.363]                       envir = ns)) {
  [06:53:46.363]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:46.363]                         envir = ns)
  [06:53:46.363]                       envir <- sys.frame(frame)
  [06:53:46.363]                       master <- NULL
  [06:53:46.363]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:46.363]                         !identical(envir, emptyenv())) {
  [06:53:46.363]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:46.363]                           inherits = FALSE)) {
  [06:53:46.363]                           master <- get("master", mode = "list", 
  [06:53:46.363]                             envir = envir, inherits = FALSE)
  [06:53:46.363]                           if (inherits(master, "SOCKnode")) {
  [06:53:46.363]                             sendCondition <<- function(cond) {
  [06:53:46.363]                               data <- list(type = "VALUE", value = cond, 
  [06:53:46.363]                                 success = TRUE)
  [06:53:46.363]                               parallel_sendData(master, data)
  [06:53:46.363]                             }
  [06:53:46.363]                             return(sendCondition)
  [06:53:46.363]                           }
  [06:53:46.363]                         }
  [06:53:46.363]                         frame <- frame + 1L
  [06:53:46.363]                         envir <- sys.frame(frame)
  [06:53:46.363]                       }
  [06:53:46.363]                     }
  [06:53:46.363]                     sendCondition <<- function(cond) NULL
  [06:53:46.363]                   }
  [06:53:46.363]                 })
  [06:53:46.363]                 withCallingHandlers({
  [06:53:46.363]                   {
  [06:53:46.363]                     doFuture::registerDoFuture()
  [06:53:46.363]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.363]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.363]                       i <- NULL
  [06:53:46.363]                       ...future.env <- environment()
  [06:53:46.363]                       local({
  [06:53:46.363]                         for (name in names(...future.x_jj)) {
  [06:53:46.363]                           assign(name, ...future.x_jj[[name]], 
  [06:53:46.363]                             envir = ...future.env, inherits = FALSE)
  [06:53:46.363]                         }
  [06:53:46.363]                       })
  [06:53:46.363]                       tryCatch({
  [06:53:46.363]                         if (i%%2 == 0) 
  [06:53:46.363]                           stop(sprintf("Index error ('pass'), because i = %d", 
  [06:53:46.363]                             i))
  [06:53:46.363]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:46.363]                       }, error = identity)
  [06:53:46.363]                     })
  [06:53:46.363]                   }
  [06:53:46.363]                 }, immediateCondition = function(cond) {
  [06:53:46.363]                   sendCondition <- ...future.sendCondition()
  [06:53:46.363]                   sendCondition(cond)
  [06:53:46.363]                   muffleCondition <- function (cond) 
  [06:53:46.363]                   {
  [06:53:46.363]                     inherits <- base::inherits
  [06:53:46.363]                     invokeRestart <- base::invokeRestart
  [06:53:46.363]                     muffled <- FALSE
  [06:53:46.363]                     if (inherits(cond, "message")) {
  [06:53:46.363]                       invokeRestart("muffleMessage")
  [06:53:46.363]                       muffled <- TRUE
  [06:53:46.363]                     }
  [06:53:46.363]                     else if (inherits(cond, "warning")) {
  [06:53:46.363]                       invokeRestart("muffleWarning")
  [06:53:46.363]                       muffled <- TRUE
  [06:53:46.363]                     }
  [06:53:46.363]                     else if (inherits(cond, "condition")) {
  [06:53:46.363]                       computeRestarts <- base::computeRestarts
  [06:53:46.363]                       grepl <- base::grepl
  [06:53:46.363]                       is.null <- base::is.null
  [06:53:46.363]                       restarts <- computeRestarts(cond)
  [06:53:46.363]                       for (restart in restarts) {
  [06:53:46.363]                         name <- restart$name
  [06:53:46.363]                         if (is.null(name)) 
  [06:53:46.363]                           next
  [06:53:46.363]                         if (!grepl("^muffle", name)) 
  [06:53:46.363]                           next
  [06:53:46.363]                         invokeRestart(restart)
  [06:53:46.363]                         muffled <- TRUE
  [06:53:46.363]                         break
  [06:53:46.363]                       }
  [06:53:46.363]                     }
  [06:53:46.363]                     invisible(muffled)
  [06:53:46.363]                   }
  [06:53:46.363]                   muffleCondition(cond)
  [06:53:46.363]                 })
  [06:53:46.363]             }))
  [06:53:46.363]             future::FutureResult(value = ...future.value$value, 
  [06:53:46.363]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.363]                   ...future.rng), started = ...future.startTime, 
  [06:53:46.363]                 version = "1.8")
  [06:53:46.363]         }, condition = base::local({
  [06:53:46.363]             c <- base::c
  [06:53:46.363]             inherits <- base::inherits
  [06:53:46.363]             invokeRestart <- base::invokeRestart
  [06:53:46.363]             length <- base::length
  [06:53:46.363]             list <- base::list
  [06:53:46.363]             seq.int <- base::seq.int
  [06:53:46.363]             signalCondition <- base::signalCondition
  [06:53:46.363]             sys.calls <- base::sys.calls
  [06:53:46.363]             Sys.time <- base::Sys.time
  [06:53:46.363]             `[[` <- base::`[[`
  [06:53:46.363]             `+` <- base::`+`
  [06:53:46.363]             `<<-` <- base::`<<-`
  [06:53:46.363]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:46.363]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:46.363]                   3L)]
  [06:53:46.363]             }
  [06:53:46.363]             function(cond) {
  [06:53:46.363]                 if (inherits(cond, "error")) {
  [06:53:46.363]                   sessionInformation <- function() {
  [06:53:46.363]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:46.363]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:46.363]                       search = base::search(), system = base::Sys.info())
  [06:53:46.363]                   }
  [06:53:46.363]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.363]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:46.363]                     cond$call), session = sessionInformation(), 
  [06:53:46.363]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:46.363]                   signalCondition(cond)
  [06:53:46.363]                 }
  [06:53:46.363]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:46.363]                 ))) {
  [06:53:46.363]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:46.363]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.363]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:46.363]                   if (!signal) {
  [06:53:46.363]                     muffleCondition <- function (cond) 
  [06:53:46.363]                     {
  [06:53:46.363]                       inherits <- base::inherits
  [06:53:46.363]                       invokeRestart <- base::invokeRestart
  [06:53:46.363]                       muffled <- FALSE
  [06:53:46.363]                       if (inherits(cond, "message")) {
  [06:53:46.363]                         invokeRestart("muffleMessage")
  [06:53:46.363]                         muffled <- TRUE
  [06:53:46.363]                       }
  [06:53:46.363]                       else if (inherits(cond, "warning")) {
  [06:53:46.363]                         invokeRestart("muffleWarning")
  [06:53:46.363]                         muffled <- TRUE
  [06:53:46.363]                       }
  [06:53:46.363]                       else if (inherits(cond, "condition")) {
  [06:53:46.363]                         computeRestarts <- base::computeRestarts
  [06:53:46.363]                         grepl <- base::grepl
  [06:53:46.363]                         is.null <- base::is.null
  [06:53:46.363]                         restarts <- computeRestarts(cond)
  [06:53:46.363]                         for (restart in restarts) {
  [06:53:46.363]                           name <- restart$name
  [06:53:46.363]                           if (is.null(name)) 
  [06:53:46.363]                             next
  [06:53:46.363]                           if (!grepl("^muffle", name)) 
  [06:53:46.363]                             next
  [06:53:46.363]                           invokeRestart(restart)
  [06:53:46.363]                           muffled <- TRUE
  [06:53:46.363]                           break
  [06:53:46.363]                         }
  [06:53:46.363]                       }
  [06:53:46.363]                       invisible(muffled)
  [06:53:46.363]                     }
  [06:53:46.363]                     muffleCondition(cond)
  [06:53:46.363]                   }
  [06:53:46.363]                 }
  [06:53:46.363]             }
  [06:53:46.363]         }))
  [06:53:46.363]     }, error = function(ex) {
  [06:53:46.363]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:46.363]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.363]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:46.363]     }, finally = {
  [06:53:46.363]         {
  [06:53:46.363]             NULL
  [06:53:46.363]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:46.363]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:46.363]                 globals = TRUE, persistent = FALSE, workers = availableWorkers(), 
  [06:53:46.363]                 user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [06:53:46.363]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:46.363]                 ...) 
  [06:53:46.363]             {
  [06:53:46.363]                 if (substitute) 
  [06:53:46.363]                   expr <- substitute(expr)
  [06:53:46.363]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [06:53:46.363]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:46.363]                   globals = globals, persistent = persistent, 
  [06:53:46.363]                   workers = workers, user = user, revtunnel = revtunnel, 
  [06:53:46.363]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [06:53:46.363]                   label = label, ...)
  [06:53:46.363]                 if (!future$lazy) 
  [06:53:46.363]                   future <- run(future)
  [06:53:46.363]                 invisible(future)
  [06:53:46.363]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:46.363]         }
  [06:53:46.363]         base::options(...future.oldOptions)
  [06:53:46.363]     })
  [06:53:46.363]     Sys.time
  [06:53:46.363]     if (base::is.na(TRUE)) {
  [06:53:46.363]     }
  [06:53:46.363]     else {
  [06:53:46.363]         base::sink(type = "output", split = FALSE)
  [06:53:46.363]         if (TRUE) {
  [06:53:46.363]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:46.363]         }
  [06:53:46.363]         else {
  [06:53:46.363]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:46.363]         }
  [06:53:46.363]         base::close(...future.stdout)
  [06:53:46.363]         ...future.stdout <- NULL
  [06:53:46.363]     }
  [06:53:46.363]     ...future.result$conditions <- ...future.conditions
  [06:53:46.363]     ...future.result
  [06:53:46.363] }
  [06:53:46.383] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [06:53:46.383] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [06:53:46.385] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [06:53:46.385] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [06:53:46.386] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [06:53:46.387] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [06:53:46.388] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [06:53:46.388] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [06:53:46.389] ClusterFuture started
  [06:53:46.390] Chunk #2 of 2 ... DONE
  [06:53:46.390] Launching 2 futures (chunks) ... DONE
  [06:53:46.390] - resolving futures
  [06:53:46.391]   - gathering results & relaying conditions (except errors)
  [06:53:46.391] resolve() on list ...
  [06:53:46.391]  recursive: 0
  [06:53:46.392]  length: 2
  [06:53:46.392] 
  [06:53:46.535] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:46.535] - Validating connection of ClusterFuture
  [06:53:46.536] - received message: FutureResult
  [06:53:46.536] - Received FutureResult
  [06:53:46.537] - Erased future from FutureRegistry
  [06:53:46.537] result() for ClusterFuture ...
  [06:53:46.538] - result already collected: FutureResult
  [06:53:46.538] result() for ClusterFuture ... done
  [06:53:46.538] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:46.539] Future #1
  [06:53:46.539] result() for ClusterFuture ...
  [06:53:46.539] - result already collected: FutureResult
  [06:53:46.540] result() for ClusterFuture ... done
  [06:53:46.540] result() for ClusterFuture ...
  [06:53:46.540] - result already collected: FutureResult
  [06:53:46.541] result() for ClusterFuture ... done
  [06:53:46.541] signalConditionsASAP(ClusterFuture, pos=1) ...
  [06:53:46.542] - nx: 2
  [06:53:46.542] - relay: TRUE
  [06:53:46.542] - stdout: TRUE
  [06:53:46.542] - signal: TRUE
  [06:53:46.543] - resignal: FALSE
  [06:53:46.543] - force: FALSE
  [06:53:46.543] - relayed: [n=2] FALSE, FALSE
  [06:53:46.544] - queued futures: [n=2] FALSE, FALSE
  [06:53:46.544]  - until=1
  [06:53:46.544]  - relaying element #1
  [06:53:46.545] result() for ClusterFuture ...
  [06:53:46.545] - result already collected: FutureResult
  [06:53:46.546] result() for ClusterFuture ... done
  [06:53:46.546] result() for ClusterFuture ...
  [06:53:46.546] - result already collected: FutureResult
  [06:53:46.547] result() for ClusterFuture ... done
  [06:53:46.547] result() for ClusterFuture ...
  [06:53:46.547] - result already collected: FutureResult
  [06:53:46.548] result() for ClusterFuture ... done
  [06:53:46.548] result() for ClusterFuture ...
  [06:53:46.549] - result already collected: FutureResult
  [06:53:46.549] result() for ClusterFuture ... done
  [06:53:46.549] - relayed: [n=2] TRUE, FALSE
  [06:53:46.550] - queued futures: [n=2] TRUE, FALSE
  [06:53:46.550] signalConditionsASAP(ClusterFuture, pos=1) ... done
  [06:53:46.550]  length: 1 (resolved future 1)
  [06:53:46.719] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:46.719] - Validating connection of ClusterFuture
  [06:53:46.720] - received message: FutureResult
  [06:53:46.720] - Received FutureResult
  [06:53:46.721] - Erased future from FutureRegistry
  [06:53:46.721] result() for ClusterFuture ...
  [06:53:46.721] - result already collected: FutureResult
  [06:53:46.722] result() for ClusterFuture ... done
  [06:53:46.722] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:46.723] Future #2
  [06:53:46.723] result() for ClusterFuture ...
  [06:53:46.723] - result already collected: FutureResult
  [06:53:46.724] result() for ClusterFuture ... done
  [06:53:46.724] result() for ClusterFuture ...
  [06:53:46.725] - result already collected: FutureResult
  [06:53:46.725] result() for ClusterFuture ... done
  [06:53:46.725] signalConditionsASAP(ClusterFuture, pos=2) ...
  [06:53:46.726] - nx: 2
  [06:53:46.726] - relay: TRUE
  [06:53:46.726] - stdout: TRUE
  [06:53:46.727] - signal: TRUE
  [06:53:46.727] - resignal: FALSE
  [06:53:46.727] - force: FALSE
  [06:53:46.728] - relayed: [n=2] TRUE, FALSE
  [06:53:46.728] - queued futures: [n=2] TRUE, FALSE
  [06:53:46.728]  - until=2
  [06:53:46.729]  - relaying element #2
  [06:53:46.729] result() for ClusterFuture ...
  [06:53:46.729] - result already collected: FutureResult
  [06:53:46.730] result() for ClusterFuture ... done
  [06:53:46.730] result() for ClusterFuture ...
  [06:53:46.736] - result already collected: FutureResult
  [06:53:46.737] result() for ClusterFuture ... done
  [06:53:46.737] result() for ClusterFuture ...
  [06:53:46.738] - result already collected: FutureResult
  [06:53:46.738] result() for ClusterFuture ... done
  [06:53:46.738] result() for ClusterFuture ...
  [06:53:46.739] - result already collected: FutureResult
  [06:53:46.739] result() for ClusterFuture ... done
  [06:53:46.739] - relayed: [n=2] TRUE, TRUE
  [06:53:46.740] - queued futures: [n=2] TRUE, TRUE
  [06:53:46.740] signalConditionsASAP(ClusterFuture, pos=2) ... done
  [06:53:46.741]  length: 0 (resolved future 2)
  [06:53:46.741] Relaying remaining futures
  [06:53:46.741] signalConditionsASAP(NULL, pos=0) ...
  [06:53:46.742] - nx: 2
  [06:53:46.742] - relay: TRUE
  [06:53:46.742] - stdout: TRUE
  [06:53:46.743] - signal: TRUE
  [06:53:46.743] - resignal: FALSE
  [06:53:46.743] - force: FALSE
  [06:53:46.743] - relayed: [n=2] TRUE, TRUE
  [06:53:46.744] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:46.744] - relayed: [n=2] TRUE, TRUE
  [06:53:46.745] - queued futures: [n=2] TRUE, TRUE
  [06:53:46.745] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:46.745] resolve() on list ... DONE
  [06:53:46.746] - collecting values of futures
  [06:53:46.746] result() for ClusterFuture ...
  [06:53:46.746] - result already collected: FutureResult
  [06:53:46.747] result() for ClusterFuture ... done
  [06:53:46.747] result() for ClusterFuture ...
  [06:53:46.748] - result already collected: FutureResult
  [06:53:46.748] result() for ClusterFuture ... done
  [06:53:46.748] result() for ClusterFuture ...
  [06:53:46.749] - result already collected: FutureResult
  [06:53:46.749] result() for ClusterFuture ... done
  [06:53:46.749] result() for ClusterFuture ...
  [06:53:46.750] - result already collected: FutureResult
  [06:53:46.750] result() for ClusterFuture ... done
  [06:53:46.751] - accumulating results
  [06:53:46.757] - processing errors (handler = 'pass')
  [06:53:46.757] - extracting results
  [06:53:46.758] doFuture() ... DONE
  List of 10
   $ : num 0.199
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 2"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.121
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 4"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.027
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 6"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 0.00222
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 8"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
   $ : num 6.69e-05
   $ :List of 2
    ..$ message: chr "Index error ('pass'), because i = 10"
    ..$ call   : language doTryCatch(return(expr), name, parentenv, handler)
    ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"
  - plan('cluster') ... DONE
  > 
  > message("*** doFuture() - error handling w/ 'pass' ... DONE")
  *** doFuture() - error handling w/ 'pass' ... DONE
  > 
  > 
  > message("*** doFuture() - error handling w/ 'remove' ...")
  *** doFuture() - error handling w/ 'remove' ...
  > 
  > for (strategy in strategies) {
  +   message(sprintf("- plan('%s') ...", strategy))
  +   plan(strategy)
  + 
  +   mu <- 1.0
  +   sigma <- 2.0
  +   res <- foreach(i = 1:10, .errorhandling = "remove") %dopar% {
  +     if (i %% 2 == 0) stop(sprintf("Index error ('remove'), because i = %d", i))
  +     dnorm(i, mean = mu, sd = sigma)
  +   }
  +   str(res)
  + 
  +   message(sprintf("- plan('%s') ... DONE", strategy))
  + } ## for (strategy ...)
  - plan('sequential') ...
  [06:53:46.858] plan(): Setting new future strategy stack:
  [06:53:46.859] List of future strategies:
  [06:53:46.859] 1. sequential:
  [06:53:46.859]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:46.859]    - tweaked: FALSE
  [06:53:46.859]    - call: plan(strategy)
  [06:53:46.869] plan(): nbrOfWorkers() = 1
  [06:53:46.869] doFuture() ...
  [06:53:46.872] - dummy globals (as locals): [1] 'i'
  [06:53:46.873] - R expression:
  [06:53:46.873] {
  [06:53:46.873]     doFuture::registerDoFuture()
  [06:53:46.873]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.873]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.873]         i <- NULL
  [06:53:46.873]         ...future.env <- environment()
  [06:53:46.873]         local({
  [06:53:46.873]             for (name in names(...future.x_jj)) {
  [06:53:46.873]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:46.873]                   inherits = FALSE)
  [06:53:46.873]             }
  [06:53:46.873]         })
  [06:53:46.873]         tryCatch({
  [06:53:46.873]             if (i%%2 == 0) 
  [06:53:46.873]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:46.873]                   i))
  [06:53:46.873]             dnorm(i, mean = mu, sd = sigma)
  [06:53:46.873]         }, error = identity)
  [06:53:46.873]     })
  [06:53:46.873] }
  [06:53:46.874] - identifying globals and packages ...
  [06:53:46.875] getGlobalsAndPackages() ...
  [06:53:46.879] Searching for globals...
  [06:53:46.902] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:46.902] Searching for globals ... DONE
  [06:53:46.903] Resolving globals: FALSE
  [06:53:46.905] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:46.906] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.906] - packages: [1] 'stats'
  [06:53:46.907] getGlobalsAndPackages() ... DONE
  [06:53:46.907] List of 3
  [06:53:46.907]  $ ...future.x_ii: NULL
  [06:53:46.907]  $ mu            : num 1
  [06:53:46.907]  $ sigma         : num 2
  [06:53:46.907]  - attr(*, "where")=List of 3
  [06:53:46.907]   ..$ ...future.x_ii:<environment: 0x557601302498> 
  [06:53:46.907]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:46.907]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:46.907]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:46.907]  - attr(*, "resolved")= logi FALSE
  [06:53:46.907]  - attr(*, "total_size")= num 112
  [06:53:46.920]   - R expression:
  [06:53:46.920] {
  [06:53:46.920]     doFuture::registerDoFuture()
  [06:53:46.920]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.920]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.920]         i <- NULL
  [06:53:46.920]         ...future.env <- environment()
  [06:53:46.920]         local({
  [06:53:46.920]             for (name in names(...future.x_jj)) {
  [06:53:46.920]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:46.920]                   inherits = FALSE)
  [06:53:46.920]             }
  [06:53:46.920]         })
  [06:53:46.920]         tryCatch({
  [06:53:46.920]             if (i%%2 == 0) 
  [06:53:46.920]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:46.920]                   i))
  [06:53:46.920]             dnorm(i, mean = mu, sd = sigma)
  [06:53:46.920]         }, error = identity)
  [06:53:46.920]     })
  [06:53:46.920] }
  [06:53:46.921]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.922] List of 3
  [06:53:46.922]  $ ...future.x_ii: NULL
  [06:53:46.922]  $ mu            : num 1
  [06:53:46.922]  $ sigma         : num 2
  [06:53:46.922]  - attr(*, "where")=List of 3
  [06:53:46.922]   ..$ ...future.x_ii:<environment: 0x557601302498> 
  [06:53:46.922]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:46.922]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:46.922]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:46.922]  - attr(*, "resolved")= logi FALSE
  [06:53:46.922]  - attr(*, "total_size")= num 112
  [06:53:46.934]   - packages: [2] 'doFuture', 'stats'
  [06:53:46.934] - identifying globals and packages ... DONE
  [06:53:46.934] Number of chunks: 1
  [06:53:46.935] Number of futures (= number of chunks): 1
  [06:53:46.936] Launching 1 futures (chunks) ...
  [06:53:46.936] Chunk #1 of 1 ...
  [06:53:46.936]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:46.937] getGlobalsAndPackages() ...
  [06:53:46.937] Searching for globals...
  [06:53:46.939] 
  [06:53:46.939] Searching for globals ... DONE
  [06:53:46.939] - globals: [0] <none>
  [06:53:46.940] getGlobalsAndPackages() ... DONE
  [06:53:46.940] 
  [06:53:46.940] 
  [06:53:46.941]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:46.941] getGlobalsAndPackages() ...
  [06:53:46.942] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.942] Resolving globals: FALSE
  [06:53:46.944] The total size of the 3 globals is 672 bytes (672 bytes)
  [06:53:46.944] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:46.945] 
  [06:53:46.945] getGlobalsAndPackages() ... DONE
  [06:53:46.950] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:46.951] Packages needed by future strategies (n = 0): <none>
  [06:53:46.966] {
  [06:53:46.966]     {
  [06:53:46.966]         ...future.startTime <- base::Sys.time()
  [06:53:46.966]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:46.966]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:46.966]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:46.966]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:46.966]             future.resolve.recursive = NULL, width = 80L)
  [06:53:46.966]         {
  [06:53:46.966]             {
  [06:53:46.966]                 {
  [06:53:46.966]                   base::local({
  [06:53:46.966]                     has_future <- base::requireNamespace("future", 
  [06:53:46.966]                       quietly = TRUE)
  [06:53:46.966]                     version <- if (has_future) 
  [06:53:46.966]                       utils::packageVersion("future")
  [06:53:46.966]                     else NULL
  [06:53:46.966]                     if (!has_future || version < "1.8.0") {
  [06:53:46.966]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:46.966]                         "", base::R.version$version.string), 
  [06:53:46.966]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:46.966]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:46.966]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:46.966]                           "release", "version")], collapse = " "), 
  [06:53:46.966]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:46.966]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:46.966]                         info)
  [06:53:46.966]                       info <- base::paste(info, collapse = "; ")
  [06:53:46.966]                       if (!has_future) {
  [06:53:46.966]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:46.966]                           info)
  [06:53:46.966]                       }
  [06:53:46.966]                       else {
  [06:53:46.966]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:46.966]                           info, version)
  [06:53:46.966]                       }
  [06:53:46.966]                       base::stop(msg)
  [06:53:46.966]                     }
  [06:53:46.966]                   })
  [06:53:46.966]                 }
  [06:53:46.966]                 base::local({
  [06:53:46.966]                   for (pkg in c("doFuture", "stats")) {
  [06:53:46.966]                     base::loadNamespace(pkg)
  [06:53:46.966]                     base::library(pkg, character.only = TRUE)
  [06:53:46.966]                   }
  [06:53:46.966]                 })
  [06:53:46.966]             }
  [06:53:46.966]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:46.966]         }
  [06:53:46.966]     }
  [06:53:46.966]     if (base::is.na(TRUE)) {
  [06:53:46.966]     }
  [06:53:46.966]     else {
  [06:53:46.966]         if (TRUE) {
  [06:53:46.966]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:46.966]                 open = "w")
  [06:53:46.966]         }
  [06:53:46.966]         else {
  [06:53:46.966]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:46.966]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:46.966]         }
  [06:53:46.966]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:46.966]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:46.966]             base::sink(type = "output", split = FALSE)
  [06:53:46.966]             base::close(...future.stdout)
  [06:53:46.966]         }, add = TRUE)
  [06:53:46.966]     }
  [06:53:46.966]     ...future.frame <- base::sys.nframe()
  [06:53:46.966]     ...future.conditions <- base::list()
  [06:53:46.966]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:46.966]     ...future.result <- base::tryCatch({
  [06:53:46.966]         base::withCallingHandlers({
  [06:53:46.966]             ...future.value <- base::withVisible(base::local({
  [06:53:46.966]                 doFuture::registerDoFuture()
  [06:53:46.966]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:46.966]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:46.966]                   i <- NULL
  [06:53:46.966]                   ...future.env <- environment()
  [06:53:46.966]                   local({
  [06:53:46.966]                     for (name in names(...future.x_jj)) {
  [06:53:46.966]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:46.966]                         inherits = FALSE)
  [06:53:46.966]                     }
  [06:53:46.966]                   })
  [06:53:46.966]                   tryCatch({
  [06:53:46.966]                     if (i%%2 == 0) 
  [06:53:46.966]                       stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:46.966]                         i))
  [06:53:46.966]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:46.966]                   }, error = identity)
  [06:53:46.966]                 })
  [06:53:46.966]             }))
  [06:53:46.966]             future::FutureResult(value = ...future.value$value, 
  [06:53:46.966]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.966]                   ...future.rng), started = ...future.startTime, 
  [06:53:46.966]                 version = "1.8")
  [06:53:46.966]         }, condition = base::local({
  [06:53:46.966]             c <- base::c
  [06:53:46.966]             inherits <- base::inherits
  [06:53:46.966]             invokeRestart <- base::invokeRestart
  [06:53:46.966]             length <- base::length
  [06:53:46.966]             list <- base::list
  [06:53:46.966]             seq.int <- base::seq.int
  [06:53:46.966]             signalCondition <- base::signalCondition
  [06:53:46.966]             sys.calls <- base::sys.calls
  [06:53:46.966]             Sys.time <- base::Sys.time
  [06:53:46.966]             `[[` <- base::`[[`
  [06:53:46.966]             `+` <- base::`+`
  [06:53:46.966]             `<<-` <- base::`<<-`
  [06:53:46.966]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:46.966]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:46.966]                   3L)]
  [06:53:46.966]             }
  [06:53:46.966]             function(cond) {
  [06:53:46.966]                 if (inherits(cond, "error")) {
  [06:53:46.966]                   sessionInformation <- function() {
  [06:53:46.966]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:46.966]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:46.966]                       search = base::search(), system = base::Sys.info())
  [06:53:46.966]                   }
  [06:53:46.966]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.966]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:46.966]                     cond$call), session = sessionInformation(), 
  [06:53:46.966]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:46.966]                   signalCondition(cond)
  [06:53:46.966]                 }
  [06:53:46.966]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:46.966]                 ))) {
  [06:53:46.966]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:46.966]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:46.966]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:46.966]                   if (!signal) {
  [06:53:46.966]                     muffleCondition <- function (cond) 
  [06:53:46.966]                     {
  [06:53:46.966]                       inherits <- base::inherits
  [06:53:46.966]                       invokeRestart <- base::invokeRestart
  [06:53:46.966]                       muffled <- FALSE
  [06:53:46.966]                       if (inherits(cond, "message")) {
  [06:53:46.966]                         invokeRestart("muffleMessage")
  [06:53:46.966]                         muffled <- TRUE
  [06:53:46.966]                       }
  [06:53:46.966]                       else if (inherits(cond, "warning")) {
  [06:53:46.966]                         invokeRestart("muffleWarning")
  [06:53:46.966]                         muffled <- TRUE
  [06:53:46.966]                       }
  [06:53:46.966]                       else if (inherits(cond, "condition")) {
  [06:53:46.966]                         computeRestarts <- base::computeRestarts
  [06:53:46.966]                         grepl <- base::grepl
  [06:53:46.966]                         is.null <- base::is.null
  [06:53:46.966]                         restarts <- computeRestarts(cond)
  [06:53:46.966]                         for (restart in restarts) {
  [06:53:46.966]                           name <- restart$name
  [06:53:46.966]                           if (is.null(name)) 
  [06:53:46.966]                             next
  [06:53:46.966]                           if (!grepl("^muffle", name)) 
  [06:53:46.966]                             next
  [06:53:46.966]                           invokeRestart(restart)
  [06:53:46.966]                           muffled <- TRUE
  [06:53:46.966]                           break
  [06:53:46.966]                         }
  [06:53:46.966]                       }
  [06:53:46.966]                       invisible(muffled)
  [06:53:46.966]                     }
  [06:53:46.966]                     muffleCondition(cond)
  [06:53:46.966]                   }
  [06:53:46.966]                 }
  [06:53:46.966]             }
  [06:53:46.966]         }))
  [06:53:46.966]     }, error = function(ex) {
  [06:53:46.966]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:46.966]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:46.966]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:46.966]     }, finally = {
  [06:53:46.966]         {
  [06:53:46.966]             NULL
  [06:53:46.966]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:46.966]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:46.966]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [06:53:46.966]                 label = NULL, ...) 
  [06:53:46.966]             {
  [06:53:46.966]                 if (substitute) 
  [06:53:46.966]                   expr <- substitute(expr)
  [06:53:46.966]                 local <- as.logical(local)
  [06:53:46.966]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [06:53:46.966]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:46.966]                   globals = globals, local = local, earlySignal = earlySignal, 
  [06:53:46.966]                   label = label, ...)
  [06:53:46.966]                 if (!future$lazy) 
  [06:53:46.966]                   future <- run(future)
  [06:53:46.966]                 invisible(future)
  [06:53:46.966]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:46.966]         }
  [06:53:46.966]         base::options(...future.oldOptions)
  [06:53:46.966]     })
  [06:53:46.966]     Sys.time
  [06:53:46.966]     if (base::is.na(TRUE)) {
  [06:53:46.966]     }
  [06:53:46.966]     else {
  [06:53:46.966]         base::sink(type = "output", split = FALSE)
  [06:53:46.966]         if (TRUE) {
  [06:53:46.966]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:46.966]         }
  [06:53:46.966]         else {
  [06:53:46.966]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:46.966]         }
  [06:53:46.966]         base::close(...future.stdout)
  [06:53:46.966]         ...future.stdout <- NULL
  [06:53:46.966]     }
  [06:53:46.966]     ...future.result$conditions <- ...future.conditions
  [06:53:46.966]     ...future.result
  [06:53:46.966] }
  [06:53:46.973] plan(): Setting new future strategy stack:
  [06:53:46.973] List of future strategies:
  [06:53:46.973] 1. sequential:
  [06:53:46.973]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:46.973]    - tweaked: FALSE
  [06:53:46.973]    - call: NULL
  [06:53:46.974] plan(): nbrOfWorkers() = 1
  [06:53:46.999] plan(): Setting new future strategy stack:
  [06:53:47.000] List of future strategies:
  [06:53:47.000] 1. sequential:
  [06:53:47.000]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:47.000]    - tweaked: FALSE
  [06:53:47.000]    - call: plan(strategy)
  [06:53:47.001] plan(): nbrOfWorkers() = 1
  [06:53:47.002] SequentialFuture started (and completed)
  [06:53:47.002] Chunk #1 of 1 ... DONE
  [06:53:47.003] Launching 1 futures (chunks) ... DONE
  [06:53:47.003] - resolving futures
  [06:53:47.003]   - gathering results & relaying conditions (except errors)
  [06:53:47.004] resolve() on list ...
  [06:53:47.004]  recursive: 0
  [06:53:47.004]  length: 1
  [06:53:47.005] 
  [06:53:47.005] Future #1
  [06:53:47.005] signalConditionsASAP(SequentialFuture, pos=1) ...
  [06:53:47.006] - nx: 1
  [06:53:47.006] - relay: TRUE
  [06:53:47.006] - stdout: TRUE
  [06:53:47.007] - signal: TRUE
  [06:53:47.007] - resignal: FALSE
  [06:53:47.007] - force: FALSE
  [06:53:47.008] - relayed: [n=1] FALSE
  [06:53:47.008] - queued futures: [n=1] FALSE
  [06:53:47.008]  - until=1
  [06:53:47.009]  - relaying element #1
  [06:53:47.009] - relayed: [n=1] TRUE
  [06:53:47.010] - queued futures: [n=1] TRUE
  [06:53:47.010] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [06:53:47.010]  length: 0 (resolved future 1)
  [06:53:47.011] Relaying remaining futures
  [06:53:47.011] signalConditionsASAP(NULL, pos=0) ...
  [06:53:47.011] - nx: 1
  [06:53:47.012] - relay: TRUE
  [06:53:47.012] - stdout: TRUE
  [06:53:47.012] - signal: TRUE
  [06:53:47.013] - resignal: FALSE
  [06:53:47.013] - force: FALSE
  [06:53:47.013] - relayed: [n=1] TRUE
  [06:53:47.014] - queued futures: [n=1] TRUE
   - flush all
  [06:53:47.014] - relayed: [n=1] TRUE
  [06:53:47.015] - queued futures: [n=1] TRUE
  [06:53:47.015] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:47.015] resolve() on list ... DONE
  [06:53:47.016] - collecting values of futures
  [06:53:47.016] - accumulating results
  [06:53:47.019] - processing errors (handler = 'remove')
  [06:53:47.020] - extracting results
  [06:53:47.020] doFuture() ... DONE
  List of 5
   $ : num 0.199
   $ : num 0.121
   $ : num 0.027
   $ : num 0.00222
   $ : num 6.69e-05
  - plan('sequential') ... DONE
  - plan('multicore') ...
  [06:53:47.031] plan(): Setting new future strategy stack:
  [06:53:47.032] List of future strategies:
  [06:53:47.032] 1. multicore:
  [06:53:47.032]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:47.032]    - tweaked: FALSE
  [06:53:47.032]    - call: plan(strategy)
  [06:53:47.034] plan(): nbrOfWorkers() = 2
  [06:53:47.034] doFuture() ...
  [06:53:47.037] - dummy globals (as locals): [1] 'i'
  [06:53:47.038] - R expression:
  [06:53:47.038] {
  [06:53:47.038]     doFuture::registerDoFuture()
  [06:53:47.038]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:47.038]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:47.038]         i <- NULL
  [06:53:47.038]         ...future.env <- environment()
  [06:53:47.038]         local({
  [06:53:47.038]             for (name in names(...future.x_jj)) {
  [06:53:47.038]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:47.038]                   inherits = FALSE)
  [06:53:47.038]             }
  [06:53:47.038]         })
  [06:53:47.038]         tryCatch({
  [06:53:47.038]             if (i%%2 == 0) 
  [06:53:47.038]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:47.038]                   i))
  [06:53:47.038]             dnorm(i, mean = mu, sd = sigma)
  [06:53:47.038]         }, error = identity)
  [06:53:47.038]     })
  [06:53:47.038] }
  [06:53:47.039] - identifying globals and packages ...
  [06:53:47.039] getGlobalsAndPackages() ...
  [06:53:47.040] Searching for globals...
  [06:53:47.059] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:47.059] Searching for globals ... DONE
  [06:53:47.059] Resolving globals: FALSE
  [06:53:47.062] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:47.062] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.063] - packages: [1] 'stats'
  [06:53:47.063] getGlobalsAndPackages() ... DONE
  [06:53:47.063] List of 3
  [06:53:47.063]  $ ...future.x_ii: NULL
  [06:53:47.063]  $ mu            : num 1
  [06:53:47.063]  $ sigma         : num 2
  [06:53:47.063]  - attr(*, "where")=List of 3
  [06:53:47.063]   ..$ ...future.x_ii:<environment: 0x5575fefedca8> 
  [06:53:47.063]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:47.063]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:47.063]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:47.063]  - attr(*, "resolved")= logi FALSE
  [06:53:47.063]  - attr(*, "total_size")= num 112
  [06:53:47.075]   - R expression:
  [06:53:47.075] {
  [06:53:47.075]     doFuture::registerDoFuture()
  [06:53:47.075]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:47.075]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:47.075]         i <- NULL
  [06:53:47.075]         ...future.env <- environment()
  [06:53:47.075]         local({
  [06:53:47.075]             for (name in names(...future.x_jj)) {
  [06:53:47.075]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:47.075]                   inherits = FALSE)
  [06:53:47.075]             }
  [06:53:47.075]         })
  [06:53:47.075]         tryCatch({
  [06:53:47.075]             if (i%%2 == 0) 
  [06:53:47.075]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:47.075]                   i))
  [06:53:47.075]             dnorm(i, mean = mu, sd = sigma)
  [06:53:47.075]         }, error = identity)
  [06:53:47.075]     })
  [06:53:47.075] }
  [06:53:47.076]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.076] List of 3
  [06:53:47.076]  $ ...future.x_ii: NULL
  [06:53:47.076]  $ mu            : num 1
  [06:53:47.076]  $ sigma         : num 2
  [06:53:47.076]  - attr(*, "where")=List of 3
  [06:53:47.076]   ..$ ...future.x_ii:<environment: 0x5575fefedca8> 
  [06:53:47.076]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:47.076]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:47.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:47.076]  - attr(*, "resolved")= logi FALSE
  [06:53:47.076]  - attr(*, "total_size")= num 112
  [06:53:47.091]   - packages: [2] 'doFuture', 'stats'
  [06:53:47.091] - identifying globals and packages ... DONE
  [06:53:47.093] Number of chunks: 2
  [06:53:47.093] Number of futures (= number of chunks): 2
  [06:53:47.094] Launching 2 futures (chunks) ...
  [06:53:47.095] Chunk #1 of 2 ...
  [06:53:47.095]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:47.095] getGlobalsAndPackages() ...
  [06:53:47.096] Searching for globals...
  [06:53:47.097] 
  [06:53:47.097] Searching for globals ... DONE
  [06:53:47.098] - globals: [0] <none>
  [06:53:47.098] getGlobalsAndPackages() ... DONE
  [06:53:47.098] 
  [06:53:47.099] 
  [06:53:47.099]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:47.100] getGlobalsAndPackages() ...
  [06:53:47.100] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.101] Resolving globals: FALSE
  [06:53:47.102] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:47.103] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.103] 
  [06:53:47.104] getGlobalsAndPackages() ... DONE
  [06:53:47.106] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:47.107] Packages needed by future strategies (n = 0): <none>
  [06:53:47.114] {
  [06:53:47.114]     {
  [06:53:47.114]         ...future.startTime <- base::Sys.time()
  [06:53:47.114]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:47.114]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:47.114]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:47.114]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:47.114]             future.resolve.recursive = NULL, width = 80L)
  [06:53:47.114]         {
  [06:53:47.114]             {
  [06:53:47.114]                 {
  [06:53:47.114]                   {
  [06:53:47.114]                     base::local({
  [06:53:47.114]                       has_future <- base::requireNamespace("future", 
  [06:53:47.114]                         quietly = TRUE)
  [06:53:47.114]                       version <- if (has_future) 
  [06:53:47.114]                         utils::packageVersion("future")
  [06:53:47.114]                       else NULL
  [06:53:47.114]                       if (!has_future || version < "1.8.0") {
  [06:53:47.114]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:47.114]                           "", base::R.version$version.string), 
  [06:53:47.114]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:47.114]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:47.114]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:47.114]                             "release", "version")], collapse = " "), 
  [06:53:47.114]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:47.114]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:47.114]                           info)
  [06:53:47.114]                         info <- base::paste(info, collapse = "; ")
  [06:53:47.114]                         if (!has_future) {
  [06:53:47.114]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:47.114]                             info)
  [06:53:47.114]                         }
  [06:53:47.114]                         else {
  [06:53:47.114]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:47.114]                             info, version)
  [06:53:47.114]                         }
  [06:53:47.114]                         base::stop(msg)
  [06:53:47.114]                       }
  [06:53:47.114]                     })
  [06:53:47.114]                   }
  [06:53:47.114]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:47.114]                   base::options(mc.cores = 1L)
  [06:53:47.114]                 }
  [06:53:47.114]                 base::local({
  [06:53:47.114]                   for (pkg in c("doFuture", "stats")) {
  [06:53:47.114]                     base::loadNamespace(pkg)
  [06:53:47.114]                     base::library(pkg, character.only = TRUE)
  [06:53:47.114]                   }
  [06:53:47.114]                 })
  [06:53:47.114]             }
  [06:53:47.114]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:47.114]         }
  [06:53:47.114]     }
  [06:53:47.114]     if (base::is.na(TRUE)) {
  [06:53:47.114]     }
  [06:53:47.114]     else {
  [06:53:47.114]         if (TRUE) {
  [06:53:47.114]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:47.114]                 open = "w")
  [06:53:47.114]         }
  [06:53:47.114]         else {
  [06:53:47.114]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:47.114]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:47.114]         }
  [06:53:47.114]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:47.114]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:47.114]             base::sink(type = "output", split = FALSE)
  [06:53:47.114]             base::close(...future.stdout)
  [06:53:47.114]         }, add = TRUE)
  [06:53:47.114]     }
  [06:53:47.114]     ...future.frame <- base::sys.nframe()
  [06:53:47.114]     ...future.conditions <- base::list()
  [06:53:47.114]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:47.114]     ...future.result <- base::tryCatch({
  [06:53:47.114]         base::withCallingHandlers({
  [06:53:47.114]             ...future.value <- base::withVisible(base::local({
  [06:53:47.114]                 doFuture::registerDoFuture()
  [06:53:47.114]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:47.114]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:47.114]                   i <- NULL
  [06:53:47.114]                   ...future.env <- environment()
  [06:53:47.114]                   local({
  [06:53:47.114]                     for (name in names(...future.x_jj)) {
  [06:53:47.114]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:47.114]                         inherits = FALSE)
  [06:53:47.114]                     }
  [06:53:47.114]                   })
  [06:53:47.114]                   tryCatch({
  [06:53:47.114]                     if (i%%2 == 0) 
  [06:53:47.114]                       stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:47.114]                         i))
  [06:53:47.114]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:47.114]                   }, error = identity)
  [06:53:47.114]                 })
  [06:53:47.114]             }))
  [06:53:47.114]             future::FutureResult(value = ...future.value$value, 
  [06:53:47.114]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:47.114]                   ...future.rng), started = ...future.startTime, 
  [06:53:47.114]                 version = "1.8")
  [06:53:47.114]         }, condition = base::local({
  [06:53:47.114]             c <- base::c
  [06:53:47.114]             inherits <- base::inherits
  [06:53:47.114]             invokeRestart <- base::invokeRestart
  [06:53:47.114]             length <- base::length
  [06:53:47.114]             list <- base::list
  [06:53:47.114]             seq.int <- base::seq.int
  [06:53:47.114]             signalCondition <- base::signalCondition
  [06:53:47.114]             sys.calls <- base::sys.calls
  [06:53:47.114]             Sys.time <- base::Sys.time
  [06:53:47.114]             `[[` <- base::`[[`
  [06:53:47.114]             `+` <- base::`+`
  [06:53:47.114]             `<<-` <- base::`<<-`
  [06:53:47.114]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:47.114]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:47.114]                   3L)]
  [06:53:47.114]             }
  [06:53:47.114]             function(cond) {
  [06:53:47.114]                 if (inherits(cond, "error")) {
  [06:53:47.114]                   sessionInformation <- function() {
  [06:53:47.114]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:47.114]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:47.114]                       search = base::search(), system = base::Sys.info())
  [06:53:47.114]                   }
  [06:53:47.114]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:47.114]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:47.114]                     cond$call), session = sessionInformation(), 
  [06:53:47.114]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:47.114]                   signalCondition(cond)
  [06:53:47.114]                 }
  [06:53:47.114]                 else if (inherits(cond, "condition")) {
  [06:53:47.114]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:47.114]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:47.114]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:47.114]                   if (!signal) {
  [06:53:47.114]                     muffleCondition <- function (cond) 
  [06:53:47.114]                     {
  [06:53:47.114]                       inherits <- base::inherits
  [06:53:47.114]                       invokeRestart <- base::invokeRestart
  [06:53:47.114]                       muffled <- FALSE
  [06:53:47.114]                       if (inherits(cond, "message")) {
  [06:53:47.114]                         invokeRestart("muffleMessage")
  [06:53:47.114]                         muffled <- TRUE
  [06:53:47.114]                       }
  [06:53:47.114]                       else if (inherits(cond, "warning")) {
  [06:53:47.114]                         invokeRestart("muffleWarning")
  [06:53:47.114]                         muffled <- TRUE
  [06:53:47.114]                       }
  [06:53:47.114]                       else if (inherits(cond, "condition")) {
  [06:53:47.114]                         computeRestarts <- base::computeRestarts
  [06:53:47.114]                         grepl <- base::grepl
  [06:53:47.114]                         is.null <- base::is.null
  [06:53:47.114]                         restarts <- computeRestarts(cond)
  [06:53:47.114]                         for (restart in restarts) {
  [06:53:47.114]                           name <- restart$name
  [06:53:47.114]                           if (is.null(name)) 
  [06:53:47.114]                             next
  [06:53:47.114]                           if (!grepl("^muffle", name)) 
  [06:53:47.114]                             next
  [06:53:47.114]                           invokeRestart(restart)
  [06:53:47.114]                           muffled <- TRUE
  [06:53:47.114]                           break
  [06:53:47.114]                         }
  [06:53:47.114]                       }
  [06:53:47.114]                       invisible(muffled)
  [06:53:47.114]                     }
  [06:53:47.114]                     muffleCondition(cond)
  [06:53:47.114]                   }
  [06:53:47.114]                 }
  [06:53:47.114]             }
  [06:53:47.114]         }))
  [06:53:47.114]     }, error = function(ex) {
  [06:53:47.114]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:47.114]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:47.114]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:47.114]     }, finally = {
  [06:53:47.114]         {
  [06:53:47.114]             {
  [06:53:47.114]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:47.114]             }
  [06:53:47.114]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:47.114]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:47.114]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:47.114]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:47.114]             {
  [06:53:47.114]                 if (substitute) 
  [06:53:47.114]                   expr <- substitute(expr)
  [06:53:47.114]                 if (is.function(workers)) 
  [06:53:47.114]                   workers <- workers()
  [06:53:47.114]                 workers <- as.integer(workers)
  [06:53:47.114]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:47.114]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:47.114]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:47.114]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:47.114]                     local = TRUE, label = label, ...))
  [06:53:47.114]                 }
  [06:53:47.114]                 oopts <- options(mc.cores = workers)
  [06:53:47.114]                 on.exit(options(oopts))
  [06:53:47.114]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:47.114]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:47.114]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:47.114]                   label = label, ...)
  [06:53:47.114]                 if (!future$lazy) 
  [06:53:47.114]                   future <- run(future)
  [06:53:47.114]                 invisible(future)
  [06:53:47.114]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:47.114]         }
  [06:53:47.114]         base::options(...future.oldOptions)
  [06:53:47.114]     })
  [06:53:47.114]     Sys.time
  [06:53:47.114]     if (base::is.na(TRUE)) {
  [06:53:47.114]     }
  [06:53:47.114]     else {
  [06:53:47.114]         base::sink(type = "output", split = FALSE)
  [06:53:47.114]         if (TRUE) {
  [06:53:47.114]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:47.114]         }
  [06:53:47.114]         else {
  [06:53:47.114]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:47.114]         }
  [06:53:47.114]         base::close(...future.stdout)
  [06:53:47.114]         ...future.stdout <- NULL
  [06:53:47.114]     }
  [06:53:47.114]     ...future.result$conditions <- ...future.conditions
  [06:53:47.114]     ...future.result
  [06:53:47.114] }
  [06:53:47.119] requestCore(): workers = 2
  [06:53:47.123] MulticoreFuture started
  [06:53:47.124] Chunk #1 of 2 ... DONE
  [06:53:47.125] Chunk #2 of 2 ...
  [06:53:47.125]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:47.126] getGlobalsAndPackages() ...
  [06:53:47.126] Searching for globals...
  [06:53:47.128] 
  [06:53:47.129] Searching for globals ... DONE
  [06:53:47.129] - globals: [0] <none>
  [06:53:47.130] getGlobalsAndPackages() ... DONE
  [06:53:47.130] 
  [06:53:47.131] 
  [06:53:47.131] plan(): Setting new future strategy stack:
  [06:53:47.131]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:47.132] List of future strategies:
  [06:53:47.132] 1. sequential:
  [06:53:47.132]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:47.132]    - tweaked: FALSE
  [06:53:47.132]    - call: NULL
  [06:53:47.133] getGlobalsAndPackages() ...
  [06:53:47.133] plan(): nbrOfWorkers() = 1
  [06:53:47.134] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.134] Resolving globals: FALSE
  [06:53:47.136] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:47.137] plan(): Setting new future strategy stack:
  [06:53:47.137] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:47.138] 
  [06:53:47.138] getGlobalsAndPackages() ... DONE
  [06:53:47.137] List of future strategies:
  [06:53:47.137] 1. multicore:
  [06:53:47.137]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:47.137]    - tweaked: FALSE
  [06:53:47.137]    - call: plan(strategy)
  [06:53:47.139] plan(): nbrOfWorkers() = 2
  [06:53:47.142] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:47.144] Packages needed by future strategies (n = 0): <none>
  [06:53:47.152] {
  [06:53:47.152]     {
  [06:53:47.152]         ...future.startTime <- base::Sys.time()
  [06:53:47.152]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:47.152]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:47.152]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:47.152]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:47.152]             future.resolve.recursive = NULL, width = 80L)
  [06:53:47.152]         {
  [06:53:47.152]             {
  [06:53:47.152]                 {
  [06:53:47.152]                   {
  [06:53:47.152]                     base::local({
  [06:53:47.152]                       has_future <- base::requireNamespace("future", 
  [06:53:47.152]                         quietly = TRUE)
  [06:53:47.152]                       version <- if (has_future) 
  [06:53:47.152]                         utils::packageVersion("future")
  [06:53:47.152]                       else NULL
  [06:53:47.152]                       if (!has_future || version < "1.8.0") {
  [06:53:47.152]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:47.152]                           "", base::R.version$version.string), 
  [06:53:47.152]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:47.152]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:47.152]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:47.152]                             "release", "version")], collapse = " "), 
  [06:53:47.152]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:47.152]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:47.152]                           info)
  [06:53:47.152]                         info <- base::paste(info, collapse = "; ")
  [06:53:47.152]                         if (!has_future) {
  [06:53:47.152]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:47.152]                             info)
  [06:53:47.152]                         }
  [06:53:47.152]                         else {
  [06:53:47.152]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:47.152]                             info, version)
  [06:53:47.152]                         }
  [06:53:47.152]                         base::stop(msg)
  [06:53:47.152]                       }
  [06:53:47.152]                     })
  [06:53:47.152]                   }
  [06:53:47.152]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:47.152]                   base::options(mc.cores = 1L)
  [06:53:47.152]                 }
  [06:53:47.152]                 base::local({
  [06:53:47.152]                   for (pkg in c("doFuture", "stats")) {
  [06:53:47.152]                     base::loadNamespace(pkg)
  [06:53:47.152]                     base::library(pkg, character.only = TRUE)
  [06:53:47.152]                   }
  [06:53:47.152]                 })
  [06:53:47.152]             }
  [06:53:47.152]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:47.152]         }
  [06:53:47.152]     }
  [06:53:47.152]     if (base::is.na(TRUE)) {
  [06:53:47.152]     }
  [06:53:47.152]     else {
  [06:53:47.152]         if (TRUE) {
  [06:53:47.152]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:47.152]                 open = "w")
  [06:53:47.152]         }
  [06:53:47.152]         else {
  [06:53:47.152]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:47.152]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:47.152]         }
  [06:53:47.152]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:47.152]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:47.152]             base::sink(type = "output", split = FALSE)
  [06:53:47.152]             base::close(...future.stdout)
  [06:53:47.152]         }, add = TRUE)
  [06:53:47.152]     }
  [06:53:47.152]     ...future.frame <- base::sys.nframe()
  [06:53:47.152]     ...future.conditions <- base::list()
  [06:53:47.152]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:47.152]     ...future.result <- base::tryCatch({
  [06:53:47.152]         base::withCallingHandlers({
  [06:53:47.152]             ...future.value <- base::withVisible(base::local({
  [06:53:47.152]                 doFuture::registerDoFuture()
  [06:53:47.152]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:47.152]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:47.152]                   i <- NULL
  [06:53:47.152]                   ...future.env <- environment()
  [06:53:47.152]                   local({
  [06:53:47.152]                     for (name in names(...future.x_jj)) {
  [06:53:47.152]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:47.152]                         inherits = FALSE)
  [06:53:47.152]                     }
  [06:53:47.152]                   })
  [06:53:47.152]                   tryCatch({
  [06:53:47.152]                     if (i%%2 == 0) 
  [06:53:47.152]                       stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:47.152]                         i))
  [06:53:47.152]                     dnorm(i, mean = mu, sd = sigma)
  [06:53:47.152]                   }, error = identity)
  [06:53:47.152]                 })
  [06:53:47.152]             }))
  [06:53:47.152]             future::FutureResult(value = ...future.value$value, 
  [06:53:47.152]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:47.152]                   ...future.rng), started = ...future.startTime, 
  [06:53:47.152]                 version = "1.8")
  [06:53:47.152]         }, condition = base::local({
  [06:53:47.152]             c <- base::c
  [06:53:47.152]             inherits <- base::inherits
  [06:53:47.152]             invokeRestart <- base::invokeRestart
  [06:53:47.152]             length <- base::length
  [06:53:47.152]             list <- base::list
  [06:53:47.152]             seq.int <- base::seq.int
  [06:53:47.152]             signalCondition <- base::signalCondition
  [06:53:47.152]             sys.calls <- base::sys.calls
  [06:53:47.152]             Sys.time <- base::Sys.time
  [06:53:47.152]             `[[` <- base::`[[`
  [06:53:47.152]             `+` <- base::`+`
  [06:53:47.152]             `<<-` <- base::`<<-`
  [06:53:47.152]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:47.152]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:47.152]                   3L)]
  [06:53:47.152]             }
  [06:53:47.152]             function(cond) {
  [06:53:47.152]                 if (inherits(cond, "error")) {
  [06:53:47.152]                   sessionInformation <- function() {
  [06:53:47.152]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:47.152]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:47.152]                       search = base::search(), system = base::Sys.info())
  [06:53:47.152]                   }
  [06:53:47.152]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:47.152]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:47.152]                     cond$call), session = sessionInformation(), 
  [06:53:47.152]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:47.152]                   signalCondition(cond)
  [06:53:47.152]                 }
  [06:53:47.152]                 else if (inherits(cond, "condition")) {
  [06:53:47.152]                   signal <- FALSE && inherits(cond, character(0))
  [06:53:47.152]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:47.152]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:47.152]                   if (!signal) {
  [06:53:47.152]                     muffleCondition <- function (cond) 
  [06:53:47.152]                     {
  [06:53:47.152]                       inherits <- base::inherits
  [06:53:47.152]                       invokeRestart <- base::invokeRestart
  [06:53:47.152]                       muffled <- FALSE
  [06:53:47.152]                       if (inherits(cond, "message")) {
  [06:53:47.152]                         invokeRestart("muffleMessage")
  [06:53:47.152]                         muffled <- TRUE
  [06:53:47.152]                       }
  [06:53:47.152]                       else if (inherits(cond, "warning")) {
  [06:53:47.152]                         invokeRestart("muffleWarning")
  [06:53:47.152]                         muffled <- TRUE
  [06:53:47.152]                       }
  [06:53:47.152]                       else if (inherits(cond, "condition")) {
  [06:53:47.152]                         computeRestarts <- base::computeRestarts
  [06:53:47.152]                         grepl <- base::grepl
  [06:53:47.152]                         is.null <- base::is.null
  [06:53:47.152]                         restarts <- computeRestarts(cond)
  [06:53:47.152]                         for (restart in restarts) {
  [06:53:47.152]                           name <- restart$name
  [06:53:47.152]                           if (is.null(name)) 
  [06:53:47.152]                             next
  [06:53:47.152]                           if (!grepl("^muffle", name)) 
  [06:53:47.152]                             next
  [06:53:47.152]                           invokeRestart(restart)
  [06:53:47.152]                           muffled <- TRUE
  [06:53:47.152]                           break
  [06:53:47.152]                         }
  [06:53:47.152]                       }
  [06:53:47.152]                       invisible(muffled)
  [06:53:47.152]                     }
  [06:53:47.152]                     muffleCondition(cond)
  [06:53:47.152]                   }
  [06:53:47.152]                 }
  [06:53:47.152]             }
  [06:53:47.152]         }))
  [06:53:47.152]     }, error = function(ex) {
  [06:53:47.152]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:47.152]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:47.152]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:47.152]     }, finally = {
  [06:53:47.152]         {
  [06:53:47.152]             {
  [06:53:47.152]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:47.152]             }
  [06:53:47.152]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:47.152]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:47.152]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [06:53:47.152]                 earlySignal = FALSE, label = NULL, ...) 
  [06:53:47.152]             {
  [06:53:47.152]                 if (substitute) 
  [06:53:47.152]                   expr <- substitute(expr)
  [06:53:47.152]                 if (is.function(workers)) 
  [06:53:47.152]                   workers <- workers()
  [06:53:47.152]                 workers <- as.integer(workers)
  [06:53:47.152]                 stop_if_not(is.finite(workers), workers >= 1L)
  [06:53:47.152]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [06:53:47.152]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:47.152]                     lazy = lazy, seed = seed, globals = globals, 
  [06:53:47.152]                     local = TRUE, label = label, ...))
  [06:53:47.152]                 }
  [06:53:47.152]                 oopts <- options(mc.cores = workers)
  [06:53:47.152]                 on.exit(options(oopts))
  [06:53:47.152]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [06:53:47.152]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:47.152]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [06:53:47.152]                   label = label, ...)
  [06:53:47.152]                 if (!future$lazy) 
  [06:53:47.152]                   future <- run(future)
  [06:53:47.152]                 invisible(future)
  [06:53:47.152]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:47.152]         }
  [06:53:47.152]         base::options(...future.oldOptions)
  [06:53:47.152]     })
  [06:53:47.152]     Sys.time
  [06:53:47.152]     if (base::is.na(TRUE)) {
  [06:53:47.152]     }
  [06:53:47.152]     else {
  [06:53:47.152]         base::sink(type = "output", split = FALSE)
  [06:53:47.152]         if (TRUE) {
  [06:53:47.152]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:47.152]         }
  [06:53:47.152]         else {
  [06:53:47.152]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:47.152]         }
  [06:53:47.152]         base::close(...future.stdout)
  [06:53:47.152]         ...future.stdout <- NULL
  [06:53:47.152]     }
  [06:53:47.152]     ...future.result$conditions <- ...future.conditions
  [06:53:47.152]     ...future.result
  [06:53:47.152] }
  [06:53:47.158] requestCore(): workers = 2
  [06:53:47.162] MulticoreFuture started
  [06:53:47.163] Chunk #2 of 2 ... DONE
  [06:53:47.164] Launching 2 futures (chunks) ... DONE
  [06:53:47.164] - resolving futures
  [06:53:47.165]   - gathering results & relaying conditions (except errors)
  [06:53:47.165] resolve() on list ...
  [06:53:47.166]  recursive: 0
  [06:53:47.166]  length: 2
  [06:53:47.167] 
  [06:53:47.168] Future #1
  [06:53:47.171] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [06:53:47.171] - nx: 2
  [06:53:47.172] - relay: TRUE
  [06:53:47.172] - stdout: TRUE
  [06:53:47.173] - signal: TRUE
  [06:53:47.173] - resignal: FALSE
  [06:53:47.174] - force: FALSE
  [06:53:47.174] - relayed: [n=2] FALSE, FALSE
  [06:53:47.174] - queued futures: [n=2] FALSE, FALSE
  [06:53:47.175]  - until=1
  [06:53:47.175]  - relaying element #1
  [06:53:47.176] - relayed: [n=2] TRUE, FALSE
  [06:53:47.177] - queued futures: [n=2] TRUE, FALSE
  [06:53:47.177] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [06:53:47.178]  length: 1 (resolved future 1)
  [06:53:47.180] plan(): Setting new future strategy stack:
  [06:53:47.181] List of future strategies:
  [06:53:47.181] 1. sequential:
  [06:53:47.181]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [06:53:47.181]    - tweaked: FALSE
  [06:53:47.181]    - call: NULL
  [06:53:47.183] plan(): nbrOfWorkers() = 1
  [06:53:47.186] plan(): Setting new future strategy stack:
  [06:53:47.187] List of future strategies:
  [06:53:47.187] 1. multicore:
  [06:53:47.187]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [06:53:47.187]    - tweaked: FALSE
  [06:53:47.187]    - call: plan(strategy)
  [06:53:47.189] plan(): nbrOfWorkers() = 2
  [06:53:47.190] Future #2
  [06:53:47.193] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [06:53:47.193] - nx: 2
  [06:53:47.194] - relay: TRUE
  [06:53:47.194] - stdout: TRUE
  [06:53:47.195] - signal: TRUE
  [06:53:47.195] - resignal: FALSE
  [06:53:47.195] - force: FALSE
  [06:53:47.196] - relayed: [n=2] TRUE, FALSE
  [06:53:47.196] - queued futures: [n=2] TRUE, FALSE
  [06:53:47.197]  - until=2
  [06:53:47.197]  - relaying element #2
  [06:53:47.198] - relayed: [n=2] TRUE, TRUE
  [06:53:47.198] - queued futures: [n=2] TRUE, TRUE
  [06:53:47.199] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [06:53:47.199]  length: 0 (resolved future 2)
  [06:53:47.200] Relaying remaining futures
  [06:53:47.200] signalConditionsASAP(NULL, pos=0) ...
  [06:53:47.200] - nx: 2
  [06:53:47.201] - relay: TRUE
  [06:53:47.201] - stdout: TRUE
  [06:53:47.202] - signal: TRUE
  [06:53:47.202] - resignal: FALSE
  [06:53:47.202] - force: FALSE
  [06:53:47.209] - relayed: [n=2] TRUE, TRUE
  [06:53:47.209] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:47.211] - relayed: [n=2] TRUE, TRUE
  [06:53:47.212] - queued futures: [n=2] TRUE, TRUE
  [06:53:47.213] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:47.214] resolve() on list ... DONE
  [06:53:47.219] - collecting values of futures
  [06:53:47.220] - accumulating results
  [06:53:47.223] - processing errors (handler = 'remove')
  [06:53:47.224] - extracting results
  [06:53:47.224] doFuture() ... DONE
  List of 5
   $ : num 0.199
   $ : num 0.121
   $ : num 0.027
   $ : num 0.00222
   $ : num 6.69e-05
  - plan('multicore') ... DONE
  - plan('multisession') ...
  [06:53:47.233] plan(): Setting new future strategy stack:
  [06:53:47.233] List of future strategies:
  [06:53:47.233] 1. multisession:
  [06:53:47.233]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:47.233]    - tweaked: FALSE
  [06:53:47.233]    - call: plan(strategy)
  [06:53:47.235] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:47.235] multisession:
  [06:53:47.235] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [06:53:47.235] - tweaked: FALSE
  [06:53:47.235] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 21442
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589538ade48.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.7589538ade48.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589538ade48.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=21442 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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589b3e7b77.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.7589b3e7b77.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.7589b3e7b77.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=21442 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [06:53:49.927] getGlobalsAndPackages() ...
  [06:53:49.928] Not searching for globals
  [06:53:49.928] - globals: [0] <none>
  [06:53:49.929] getGlobalsAndPackages() ... DONE
  [06:53:49.940] Packages needed by the future expression (n = 0): <none>
  [06:53:49.943] Packages needed by future strategies (n = 0): <none>
  [06:53:49.953] {
  [06:53:49.953]     {
  [06:53:49.953]         ...future.startTime <- base::Sys.time()
  [06:53:49.953]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:49.953]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:49.953]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:49.953]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:49.953]             future.resolve.recursive = NULL, width = 80L)
  [06:53:49.953]         {
  [06:53:49.953]             {
  [06:53:49.953]                 {
  [06:53:49.953]                   base::local({
  [06:53:49.953]                     has_future <- base::requireNamespace("future", 
  [06:53:49.953]                       quietly = TRUE)
  [06:53:49.953]                     version <- if (has_future) 
  [06:53:49.953]                       utils::packageVersion("future")
  [06:53:49.953]                     else NULL
  [06:53:49.953]                     if (!has_future || version < "1.8.0") {
  [06:53:49.953]                       info <- base::c(r_version = base::gsub("R version ", 
  [06:53:49.953]                         "", base::R.version$version.string), 
  [06:53:49.953]                         platform = base::sprintf("%s (%s-bit)", 
  [06:53:49.953]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:49.953]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:49.953]                           "release", "version")], collapse = " "), 
  [06:53:49.953]                         hostname = base::Sys.info()[["nodename"]])
  [06:53:49.953]                       info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:49.953]                         info)
  [06:53:49.953]                       info <- base::paste(info, collapse = "; ")
  [06:53:49.953]                       if (!has_future) {
  [06:53:49.953]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:49.953]                           info)
  [06:53:49.953]                       }
  [06:53:49.953]                       else {
  [06:53:49.953]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:49.953]                           info, version)
  [06:53:49.953]                       }
  [06:53:49.953]                       base::stop(msg)
  [06:53:49.953]                     }
  [06:53:49.953]                   })
  [06:53:49.953]                 }
  [06:53:49.953]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:49.953]                 base::options(mc.cores = 1L)
  [06:53:49.953]             }
  [06:53:49.953]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:49.953]         }
  [06:53:49.953]     }
  [06:53:49.953]     if (base::is.na(TRUE)) {
  [06:53:49.953]     }
  [06:53:49.953]     else {
  [06:53:49.953]         if (TRUE) {
  [06:53:49.953]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:49.953]                 open = "w")
  [06:53:49.953]         }
  [06:53:49.953]         else {
  [06:53:49.953]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:49.953]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:49.953]         }
  [06:53:49.953]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:49.953]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:49.953]             base::sink(type = "output", split = FALSE)
  [06:53:49.953]             base::close(...future.stdout)
  [06:53:49.953]         }, add = TRUE)
  [06:53:49.953]     }
  [06:53:49.953]     ...future.frame <- base::sys.nframe()
  [06:53:49.953]     ...future.conditions <- base::list()
  [06:53:49.953]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:49.953]     ...future.result <- base::tryCatch({
  [06:53:49.953]         base::withCallingHandlers({
  [06:53:49.953]             ...future.value <- base::withVisible(base::local({
  [06:53:49.953]                 ...future.sendCondition <- local({
  [06:53:49.953]                   sendCondition <- NULL
  [06:53:49.953]                   function(frame = 1L) {
  [06:53:49.953]                     if (is.function(sendCondition)) 
  [06:53:49.953]                       return(sendCondition)
  [06:53:49.953]                     ns <- getNamespace("parallel")
  [06:53:49.953]                     if (exists("sendData", mode = "function", 
  [06:53:49.953]                       envir = ns)) {
  [06:53:49.953]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:49.953]                         envir = ns)
  [06:53:49.953]                       envir <- sys.frame(frame)
  [06:53:49.953]                       master <- NULL
  [06:53:49.953]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:49.953]                         !identical(envir, emptyenv())) {
  [06:53:49.953]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:49.953]                           inherits = FALSE)) {
  [06:53:49.953]                           master <- get("master", mode = "list", 
  [06:53:49.953]                             envir = envir, inherits = FALSE)
  [06:53:49.953]                           if (inherits(master, "SOCKnode")) {
  [06:53:49.953]                             sendCondition <<- function(cond) {
  [06:53:49.953]                               data <- list(type = "VALUE", value = cond, 
  [06:53:49.953]                                 success = TRUE)
  [06:53:49.953]                               parallel_sendData(master, data)
  [06:53:49.953]                             }
  [06:53:49.953]                             return(sendCondition)
  [06:53:49.953]                           }
  [06:53:49.953]                         }
  [06:53:49.953]                         frame <- frame + 1L
  [06:53:49.953]                         envir <- sys.frame(frame)
  [06:53:49.953]                       }
  [06:53:49.953]                     }
  [06:53:49.953]                     sendCondition <<- function(cond) NULL
  [06:53:49.953]                   }
  [06:53:49.953]                 })
  [06:53:49.953]                 withCallingHandlers({
  [06:53:49.953]                   NA
  [06:53:49.953]                 }, immediateCondition = function(cond) {
  [06:53:49.953]                   sendCondition <- ...future.sendCondition()
  [06:53:49.953]                   sendCondition(cond)
  [06:53:49.953]                   muffleCondition <- function (cond) 
  [06:53:49.953]                   {
  [06:53:49.953]                     inherits <- base::inherits
  [06:53:49.953]                     invokeRestart <- base::invokeRestart
  [06:53:49.953]                     muffled <- FALSE
  [06:53:49.953]                     if (inherits(cond, "message")) {
  [06:53:49.953]                       invokeRestart("muffleMessage")
  [06:53:49.953]                       muffled <- TRUE
  [06:53:49.953]                     }
  [06:53:49.953]                     else if (inherits(cond, "warning")) {
  [06:53:49.953]                       invokeRestart("muffleWarning")
  [06:53:49.953]                       muffled <- TRUE
  [06:53:49.953]                     }
  [06:53:49.953]                     else if (inherits(cond, "condition")) {
  [06:53:49.953]                       computeRestarts <- base::computeRestarts
  [06:53:49.953]                       grepl <- base::grepl
  [06:53:49.953]                       is.null <- base::is.null
  [06:53:49.953]                       restarts <- computeRestarts(cond)
  [06:53:49.953]                       for (restart in restarts) {
  [06:53:49.953]                         name <- restart$name
  [06:53:49.953]                         if (is.null(name)) 
  [06:53:49.953]                           next
  [06:53:49.953]                         if (!grepl("^muffle", name)) 
  [06:53:49.953]                           next
  [06:53:49.953]                         invokeRestart(restart)
  [06:53:49.953]                         muffled <- TRUE
  [06:53:49.953]                         break
  [06:53:49.953]                       }
  [06:53:49.953]                     }
  [06:53:49.953]                     invisible(muffled)
  [06:53:49.953]                   }
  [06:53:49.953]                   muffleCondition(cond)
  [06:53:49.953]                 })
  [06:53:49.953]             }))
  [06:53:49.953]             future::FutureResult(value = ...future.value$value, 
  [06:53:49.953]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:49.953]                   ...future.rng), started = ...future.startTime, 
  [06:53:49.953]                 version = "1.8")
  [06:53:49.953]         }, condition = base::local({
  [06:53:49.953]             c <- base::c
  [06:53:49.953]             inherits <- base::inherits
  [06:53:49.953]             invokeRestart <- base::invokeRestart
  [06:53:49.953]             length <- base::length
  [06:53:49.953]             list <- base::list
  [06:53:49.953]             seq.int <- base::seq.int
  [06:53:49.953]             signalCondition <- base::signalCondition
  [06:53:49.953]             sys.calls <- base::sys.calls
  [06:53:49.953]             Sys.time <- base::Sys.time
  [06:53:49.953]             `[[` <- base::`[[`
  [06:53:49.953]             `+` <- base::`+`
  [06:53:49.953]             `<<-` <- base::`<<-`
  [06:53:49.953]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:49.953]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:49.953]                   3L)]
  [06:53:49.953]             }
  [06:53:49.953]             function(cond) {
  [06:53:49.953]                 if (inherits(cond, "error")) {
  [06:53:49.953]                   sessionInformation <- function() {
  [06:53:49.953]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:49.953]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:49.953]                       search = base::search(), system = base::Sys.info())
  [06:53:49.953]                   }
  [06:53:49.953]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:49.953]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:49.953]                     cond$call), session = sessionInformation(), 
  [06:53:49.953]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:49.953]                   signalCondition(cond)
  [06:53:49.953]                 }
  [06:53:49.953]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:49.953]                 ))) {
  [06:53:49.953]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:49.953]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:49.953]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:49.953]                   if (!signal) {
  [06:53:49.953]                     muffleCondition <- function (cond) 
  [06:53:49.953]                     {
  [06:53:49.953]                       inherits <- base::inherits
  [06:53:49.953]                       invokeRestart <- base::invokeRestart
  [06:53:49.953]                       muffled <- FALSE
  [06:53:49.953]                       if (inherits(cond, "message")) {
  [06:53:49.953]                         invokeRestart("muffleMessage")
  [06:53:49.953]                         muffled <- TRUE
  [06:53:49.953]                       }
  [06:53:49.953]                       else if (inherits(cond, "warning")) {
  [06:53:49.953]                         invokeRestart("muffleWarning")
  [06:53:49.953]                         muffled <- TRUE
  [06:53:49.953]                       }
  [06:53:49.953]                       else if (inherits(cond, "condition")) {
  [06:53:49.953]                         computeRestarts <- base::computeRestarts
  [06:53:49.953]                         grepl <- base::grepl
  [06:53:49.953]                         is.null <- base::is.null
  [06:53:49.953]                         restarts <- computeRestarts(cond)
  [06:53:49.953]                         for (restart in restarts) {
  [06:53:49.953]                           name <- restart$name
  [06:53:49.953]                           if (is.null(name)) 
  [06:53:49.953]                             next
  [06:53:49.953]                           if (!grepl("^muffle", name)) 
  [06:53:49.953]                             next
  [06:53:49.953]                           invokeRestart(restart)
  [06:53:49.953]                           muffled <- TRUE
  [06:53:49.953]                           break
  [06:53:49.953]                         }
  [06:53:49.953]                       }
  [06:53:49.953]                       invisible(muffled)
  [06:53:49.953]                     }
  [06:53:49.953]                     muffleCondition(cond)
  [06:53:49.953]                   }
  [06:53:49.953]                 }
  [06:53:49.953]             }
  [06:53:49.953]         }))
  [06:53:49.953]     }, error = function(ex) {
  [06:53:49.953]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:49.953]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:49.953]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:49.953]     }, finally = {
  [06:53:49.953]         {
  [06:53:49.953]             {
  [06:53:49.953]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:49.953]             }
  [06:53:49.953]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:49.953]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:49.953]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:49.953]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:49.953]                 ...) 
  [06:53:49.953]             {
  [06:53:49.953]                 if (substitute) 
  [06:53:49.953]                   expr <- substitute(expr)
  [06:53:49.953]                 if (is.function(workers)) 
  [06:53:49.953]                   workers <- workers()
  [06:53:49.953]                 workers <- as.integer(workers)
  [06:53:49.953]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:49.953]                   workers >= 1)
  [06:53:49.953]                 if (workers == 1L) {
  [06:53:49.953]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:49.953]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:49.953]                     local = TRUE, label = label, ...))
  [06:53:49.953]                 }
  [06:53:49.953]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:49.953]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:49.953]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:49.953]                   globals = globals, persistent = persistent, 
  [06:53:49.953]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:49.953]                   label = label, ...)
  [06:53:49.953]                 if (!future$lazy) 
  [06:53:49.953]                   future <- run(future)
  [06:53:49.953]                 invisible(future)
  [06:53:49.953]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:49.953]         }
  [06:53:49.953]         base::options(...future.oldOptions)
  [06:53:49.953]     })
  [06:53:49.953]     Sys.time
  [06:53:49.953]     if (base::is.na(TRUE)) {
  [06:53:49.953]     }
  [06:53:49.953]     else {
  [06:53:49.953]         base::sink(type = "output", split = FALSE)
  [06:53:49.953]         if (TRUE) {
  [06:53:49.953]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:49.953]         }
  [06:53:49.953]         else {
  [06:53:49.953]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:49.953]         }
  [06:53:49.953]         base::close(...future.stdout)
  [06:53:49.953]         ...future.stdout <- NULL
  [06:53:49.953]     }
  [06:53:49.953]     ...future.result$conditions <- ...future.conditions
  [06:53:49.953]     ...future.result
  [06:53:49.953] }
  [06:53:49.973] MultisessionFuture started
  [06:53:49.974] result() for ClusterFuture ...
  [06:53:49.974] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:49.975] - Validating connection of MultisessionFuture
  [06:53:50.177] - received message: FutureResult
  [06:53:50.178] - Received FutureResult
  [06:53:50.178] - Erased future from FutureRegistry
  [06:53:50.178] result() for ClusterFuture ...
  [06:53:50.179] - result already collected: FutureResult
  [06:53:50.179] result() for ClusterFuture ... done
  [06:53:50.180] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:50.180] result() for ClusterFuture ... done
  [06:53:50.181] result() for ClusterFuture ...
  [06:53:50.181] - result already collected: FutureResult
  [06:53:50.181] result() for ClusterFuture ... done
  [06:53:50.182] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [06:53:50.183] plan(): nbrOfWorkers() = 2
  [06:53:50.184] doFuture() ...
  [06:53:50.186] - dummy globals (as locals): [1] 'i'
  [06:53:50.187] - R expression:
  [06:53:50.187] {
  [06:53:50.187]     doFuture::registerDoFuture()
  [06:53:50.187]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:50.187]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:50.187]         i <- NULL
  [06:53:50.187]         ...future.env <- environment()
  [06:53:50.187]         local({
  [06:53:50.187]             for (name in names(...future.x_jj)) {
  [06:53:50.187]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:50.187]                   inherits = FALSE)
  [06:53:50.187]             }
  [06:53:50.187]         })
  [06:53:50.187]         tryCatch({
  [06:53:50.187]             if (i%%2 == 0) 
  [06:53:50.187]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:50.187]                   i))
  [06:53:50.187]             dnorm(i, mean = mu, sd = sigma)
  [06:53:50.187]         }, error = identity)
  [06:53:50.187]     })
  [06:53:50.187] }
  [06:53:50.188] - identifying globals and packages ...
  [06:53:50.189] getGlobalsAndPackages() ...
  [06:53:50.189] Searching for globals...
  [06:53:50.249] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [06:53:50.250] Searching for globals ... DONE
  [06:53:50.250] Resolving globals: FALSE
  [06:53:50.252] The total size of the 3 globals is 112 bytes (112 bytes)
  [06:53:50.253] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.253] - packages: [1] 'stats'
  [06:53:50.254] getGlobalsAndPackages() ... DONE
  [06:53:50.254] List of 3
  [06:53:50.254]  $ ...future.x_ii: NULL
  [06:53:50.254]  $ mu            : num 1
  [06:53:50.254]  $ sigma         : num 2
  [06:53:50.254]  - attr(*, "where")=List of 3
  [06:53:50.254]   ..$ ...future.x_ii:<environment: 0x557600cb4df0> 
  [06:53:50.254]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:50.254]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:50.254]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:50.254]  - attr(*, "resolved")= logi FALSE
  [06:53:50.254]  - attr(*, "total_size")= num 112
  [06:53:50.280]   - R expression:
  [06:53:50.281] {
  [06:53:50.281]     doFuture::registerDoFuture()
  [06:53:50.281]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:50.281]         ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:50.281]         i <- NULL
  [06:53:50.281]         ...future.env <- environment()
  [06:53:50.281]         local({
  [06:53:50.281]             for (name in names(...future.x_jj)) {
  [06:53:50.281]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [06:53:50.281]                   inherits = FALSE)
  [06:53:50.281]             }
  [06:53:50.281]         })
  [06:53:50.281]         tryCatch({
  [06:53:50.281]             if (i%%2 == 0) 
  [06:53:50.281]                 stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:50.281]                   i))
  [06:53:50.281]             dnorm(i, mean = mu, sd = sigma)
  [06:53:50.281]         }, error = identity)
  [06:53:50.281]     })
  [06:53:50.281] }
  [06:53:50.282]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.282] List of 3
  [06:53:50.282]  $ ...future.x_ii: NULL
  [06:53:50.282]  $ mu            : num 1
  [06:53:50.282]  $ sigma         : num 2
  [06:53:50.282]  - attr(*, "where")=List of 3
  [06:53:50.282]   ..$ ...future.x_ii:<environment: 0x557600cb4df0> 
  [06:53:50.282]   ..$ mu            :<environment: R_GlobalEnv> 
  [06:53:50.282]   ..$ sigma         :<environment: R_GlobalEnv> 
  [06:53:50.282]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [06:53:50.282]  - attr(*, "resolved")= logi FALSE
  [06:53:50.282]  - attr(*, "total_size")= num 112
  [06:53:50.321]   - packages: [2] 'doFuture', 'stats'
  [06:53:50.321] - identifying globals and packages ... DONE
  [06:53:50.323] Number of chunks: 2
  [06:53:50.323] Number of futures (= number of chunks): 2
  [06:53:50.324] Launching 2 futures (chunks) ...
  [06:53:50.324] Chunk #1 of 2 ...
  [06:53:50.324]  - Finding globals in 'args_list' chunk #1 ...
  [06:53:50.325] getGlobalsAndPackages() ...
  [06:53:50.325] Searching for globals...
  [06:53:50.326] 
  [06:53:50.327] Searching for globals ... DONE
  [06:53:50.327] - globals: [0] <none>
  [06:53:50.327] getGlobalsAndPackages() ... DONE
  [06:53:50.328] 
  [06:53:50.328] 
  [06:53:50.328]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [06:53:50.330] getGlobalsAndPackages() ...
  [06:53:50.330] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.331] Resolving globals: FALSE
  [06:53:50.332] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:50.332] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.333] 
  [06:53:50.333] getGlobalsAndPackages() ... DONE
  [06:53:50.338] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:50.339] Packages needed by future strategies (n = 0): <none>
  [06:53:50.366] {
  [06:53:50.366]     {
  [06:53:50.366]         ...future.startTime <- base::Sys.time()
  [06:53:50.366]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:50.366]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:50.366]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:50.366]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:50.366]             future.resolve.recursive = NULL, width = 80L)
  [06:53:50.366]         {
  [06:53:50.366]             {
  [06:53:50.366]                 {
  [06:53:50.366]                   {
  [06:53:50.366]                     base::local({
  [06:53:50.366]                       has_future <- base::requireNamespace("future", 
  [06:53:50.366]                         quietly = TRUE)
  [06:53:50.366]                       version <- if (has_future) 
  [06:53:50.366]                         utils::packageVersion("future")
  [06:53:50.366]                       else NULL
  [06:53:50.366]                       if (!has_future || version < "1.8.0") {
  [06:53:50.366]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:50.366]                           "", base::R.version$version.string), 
  [06:53:50.366]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:50.366]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:50.366]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:50.366]                             "release", "version")], collapse = " "), 
  [06:53:50.366]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:50.366]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:50.366]                           info)
  [06:53:50.366]                         info <- base::paste(info, collapse = "; ")
  [06:53:50.366]                         if (!has_future) {
  [06:53:50.366]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:50.366]                             info)
  [06:53:50.366]                         }
  [06:53:50.366]                         else {
  [06:53:50.366]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:50.366]                             info, version)
  [06:53:50.366]                         }
  [06:53:50.366]                         base::stop(msg)
  [06:53:50.366]                       }
  [06:53:50.366]                     })
  [06:53:50.366]                   }
  [06:53:50.366]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:50.366]                   base::options(mc.cores = 1L)
  [06:53:50.366]                 }
  [06:53:50.366]                 base::local({
  [06:53:50.366]                   for (pkg in c("doFuture", "stats")) {
  [06:53:50.366]                     base::loadNamespace(pkg)
  [06:53:50.366]                     base::library(pkg, character.only = TRUE)
  [06:53:50.366]                   }
  [06:53:50.366]                 })
  [06:53:50.366]             }
  [06:53:50.366]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:50.366]         }
  [06:53:50.366]     }
  [06:53:50.366]     if (base::is.na(TRUE)) {
  [06:53:50.366]     }
  [06:53:50.366]     else {
  [06:53:50.366]         if (TRUE) {
  [06:53:50.366]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:50.366]                 open = "w")
  [06:53:50.366]         }
  [06:53:50.366]         else {
  [06:53:50.366]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:50.366]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:50.366]         }
  [06:53:50.366]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:50.366]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:50.366]             base::sink(type = "output", split = FALSE)
  [06:53:50.366]             base::close(...future.stdout)
  [06:53:50.366]         }, add = TRUE)
  [06:53:50.366]     }
  [06:53:50.366]     ...future.frame <- base::sys.nframe()
  [06:53:50.366]     ...future.conditions <- base::list()
  [06:53:50.366]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:50.366]     ...future.result <- base::tryCatch({
  [06:53:50.366]         base::withCallingHandlers({
  [06:53:50.366]             ...future.value <- base::withVisible(base::local({
  [06:53:50.366]                 ...future.sendCondition <- local({
  [06:53:50.366]                   sendCondition <- NULL
  [06:53:50.366]                   function(frame = 1L) {
  [06:53:50.366]                     if (is.function(sendCondition)) 
  [06:53:50.366]                       return(sendCondition)
  [06:53:50.366]                     ns <- getNamespace("parallel")
  [06:53:50.366]                     if (exists("sendData", mode = "function", 
  [06:53:50.366]                       envir = ns)) {
  [06:53:50.366]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:50.366]                         envir = ns)
  [06:53:50.366]                       envir <- sys.frame(frame)
  [06:53:50.366]                       master <- NULL
  [06:53:50.366]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:50.366]                         !identical(envir, emptyenv())) {
  [06:53:50.366]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:50.366]                           inherits = FALSE)) {
  [06:53:50.366]                           master <- get("master", mode = "list", 
  [06:53:50.366]                             envir = envir, inherits = FALSE)
  [06:53:50.366]                           if (inherits(master, "SOCKnode")) {
  [06:53:50.366]                             sendCondition <<- function(cond) {
  [06:53:50.366]                               data <- list(type = "VALUE", value = cond, 
  [06:53:50.366]                                 success = TRUE)
  [06:53:50.366]                               parallel_sendData(master, data)
  [06:53:50.366]                             }
  [06:53:50.366]                             return(sendCondition)
  [06:53:50.366]                           }
  [06:53:50.366]                         }
  [06:53:50.366]                         frame <- frame + 1L
  [06:53:50.366]                         envir <- sys.frame(frame)
  [06:53:50.366]                       }
  [06:53:50.366]                     }
  [06:53:50.366]                     sendCondition <<- function(cond) NULL
  [06:53:50.366]                   }
  [06:53:50.366]                 })
  [06:53:50.366]                 withCallingHandlers({
  [06:53:50.366]                   {
  [06:53:50.366]                     doFuture::registerDoFuture()
  [06:53:50.366]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:50.366]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:50.366]                       i <- NULL
  [06:53:50.366]                       ...future.env <- environment()
  [06:53:50.366]                       local({
  [06:53:50.366]                         for (name in names(...future.x_jj)) {
  [06:53:50.366]                           assign(name, ...future.x_jj[[name]], 
  [06:53:50.366]                             envir = ...future.env, inherits = FALSE)
  [06:53:50.366]                         }
  [06:53:50.366]                       })
  [06:53:50.366]                       tryCatch({
  [06:53:50.366]                         if (i%%2 == 0) 
  [06:53:50.366]                           stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:50.366]                             i))
  [06:53:50.366]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:50.366]                       }, error = identity)
  [06:53:50.366]                     })
  [06:53:50.366]                   }
  [06:53:50.366]                 }, immediateCondition = function(cond) {
  [06:53:50.366]                   sendCondition <- ...future.sendCondition()
  [06:53:50.366]                   sendCondition(cond)
  [06:53:50.366]                   muffleCondition <- function (cond) 
  [06:53:50.366]                   {
  [06:53:50.366]                     inherits <- base::inherits
  [06:53:50.366]                     invokeRestart <- base::invokeRestart
  [06:53:50.366]                     muffled <- FALSE
  [06:53:50.366]                     if (inherits(cond, "message")) {
  [06:53:50.366]                       invokeRestart("muffleMessage")
  [06:53:50.366]                       muffled <- TRUE
  [06:53:50.366]                     }
  [06:53:50.366]                     else if (inherits(cond, "warning")) {
  [06:53:50.366]                       invokeRestart("muffleWarning")
  [06:53:50.366]                       muffled <- TRUE
  [06:53:50.366]                     }
  [06:53:50.366]                     else if (inherits(cond, "condition")) {
  [06:53:50.366]                       computeRestarts <- base::computeRestarts
  [06:53:50.366]                       grepl <- base::grepl
  [06:53:50.366]                       is.null <- base::is.null
  [06:53:50.366]                       restarts <- computeRestarts(cond)
  [06:53:50.366]                       for (restart in restarts) {
  [06:53:50.366]                         name <- restart$name
  [06:53:50.366]                         if (is.null(name)) 
  [06:53:50.366]                           next
  [06:53:50.366]                         if (!grepl("^muffle", name)) 
  [06:53:50.366]                           next
  [06:53:50.366]                         invokeRestart(restart)
  [06:53:50.366]                         muffled <- TRUE
  [06:53:50.366]                         break
  [06:53:50.366]                       }
  [06:53:50.366]                     }
  [06:53:50.366]                     invisible(muffled)
  [06:53:50.366]                   }
  [06:53:50.366]                   muffleCondition(cond)
  [06:53:50.366]                 })
  [06:53:50.366]             }))
  [06:53:50.366]             future::FutureResult(value = ...future.value$value, 
  [06:53:50.366]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:50.366]                   ...future.rng), started = ...future.startTime, 
  [06:53:50.366]                 version = "1.8")
  [06:53:50.366]         }, condition = base::local({
  [06:53:50.366]             c <- base::c
  [06:53:50.366]             inherits <- base::inherits
  [06:53:50.366]             invokeRestart <- base::invokeRestart
  [06:53:50.366]             length <- base::length
  [06:53:50.366]             list <- base::list
  [06:53:50.366]             seq.int <- base::seq.int
  [06:53:50.366]             signalCondition <- base::signalCondition
  [06:53:50.366]             sys.calls <- base::sys.calls
  [06:53:50.366]             Sys.time <- base::Sys.time
  [06:53:50.366]             `[[` <- base::`[[`
  [06:53:50.366]             `+` <- base::`+`
  [06:53:50.366]             `<<-` <- base::`<<-`
  [06:53:50.366]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:50.366]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:50.366]                   3L)]
  [06:53:50.366]             }
  [06:53:50.366]             function(cond) {
  [06:53:50.366]                 if (inherits(cond, "error")) {
  [06:53:50.366]                   sessionInformation <- function() {
  [06:53:50.366]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:50.366]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:50.366]                       search = base::search(), system = base::Sys.info())
  [06:53:50.366]                   }
  [06:53:50.366]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:50.366]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:50.366]                     cond$call), session = sessionInformation(), 
  [06:53:50.366]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:50.366]                   signalCondition(cond)
  [06:53:50.366]                 }
  [06:53:50.366]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:50.366]                 ))) {
  [06:53:50.366]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:50.366]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:50.366]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:50.366]                   if (!signal) {
  [06:53:50.366]                     muffleCondition <- function (cond) 
  [06:53:50.366]                     {
  [06:53:50.366]                       inherits <- base::inherits
  [06:53:50.366]                       invokeRestart <- base::invokeRestart
  [06:53:50.366]                       muffled <- FALSE
  [06:53:50.366]                       if (inherits(cond, "message")) {
  [06:53:50.366]                         invokeRestart("muffleMessage")
  [06:53:50.366]                         muffled <- TRUE
  [06:53:50.366]                       }
  [06:53:50.366]                       else if (inherits(cond, "warning")) {
  [06:53:50.366]                         invokeRestart("muffleWarning")
  [06:53:50.366]                         muffled <- TRUE
  [06:53:50.366]                       }
  [06:53:50.366]                       else if (inherits(cond, "condition")) {
  [06:53:50.366]                         computeRestarts <- base::computeRestarts
  [06:53:50.366]                         grepl <- base::grepl
  [06:53:50.366]                         is.null <- base::is.null
  [06:53:50.366]                         restarts <- computeRestarts(cond)
  [06:53:50.366]                         for (restart in restarts) {
  [06:53:50.366]                           name <- restart$name
  [06:53:50.366]                           if (is.null(name)) 
  [06:53:50.366]                             next
  [06:53:50.366]                           if (!grepl("^muffle", name)) 
  [06:53:50.366]                             next
  [06:53:50.366]                           invokeRestart(restart)
  [06:53:50.366]                           muffled <- TRUE
  [06:53:50.366]                           break
  [06:53:50.366]                         }
  [06:53:50.366]                       }
  [06:53:50.366]                       invisible(muffled)
  [06:53:50.366]                     }
  [06:53:50.366]                     muffleCondition(cond)
  [06:53:50.366]                   }
  [06:53:50.366]                 }
  [06:53:50.366]             }
  [06:53:50.366]         }))
  [06:53:50.366]     }, error = function(ex) {
  [06:53:50.366]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:50.366]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:50.366]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:50.366]     }, finally = {
  [06:53:50.366]         {
  [06:53:50.366]             {
  [06:53:50.366]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:50.366]             }
  [06:53:50.366]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:50.366]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:50.366]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:50.366]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:50.366]                 ...) 
  [06:53:50.366]             {
  [06:53:50.366]                 if (substitute) 
  [06:53:50.366]                   expr <- substitute(expr)
  [06:53:50.366]                 if (is.function(workers)) 
  [06:53:50.366]                   workers <- workers()
  [06:53:50.366]                 workers <- as.integer(workers)
  [06:53:50.366]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:50.366]                   workers >= 1)
  [06:53:50.366]                 if (workers == 1L) {
  [06:53:50.366]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:50.366]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:50.366]                     local = TRUE, label = label, ...))
  [06:53:50.366]                 }
  [06:53:50.366]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:50.366]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:50.366]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:50.366]                   globals = globals, persistent = persistent, 
  [06:53:50.366]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:50.366]                   label = label, ...)
  [06:53:50.366]                 if (!future$lazy) 
  [06:53:50.366]                   future <- run(future)
  [06:53:50.366]                 invisible(future)
  [06:53:50.366]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:50.366]         }
  [06:53:50.366]         base::options(...future.oldOptions)
  [06:53:50.366]     })
  [06:53:50.366]     Sys.time
  [06:53:50.366]     if (base::is.na(TRUE)) {
  [06:53:50.366]     }
  [06:53:50.366]     else {
  [06:53:50.366]         base::sink(type = "output", split = FALSE)
  [06:53:50.366]         if (TRUE) {
  [06:53:50.366]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:50.366]         }
  [06:53:50.366]         else {
  [06:53:50.366]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:50.366]         }
  [06:53:50.366]         base::close(...future.stdout)
  [06:53:50.366]         ...future.stdout <- NULL
  [06:53:50.366]     }
  [06:53:50.366]     ...future.result$conditions <- ...future.conditions
  [06:53:50.366]     ...future.result
  [06:53:50.366] }
  [06:53:50.387] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [06:53:50.387] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [06:53:50.389] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [06:53:50.389] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [06:53:50.391] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [06:53:50.391] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [06:53:50.392] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [06:53:50.393] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [06:53:50.407] MultisessionFuture started
  [06:53:50.408] Chunk #1 of 2 ... DONE
  [06:53:50.408] Chunk #2 of 2 ...
  [06:53:50.408]  - Finding globals in 'args_list' chunk #2 ...
  [06:53:50.409] getGlobalsAndPackages() ...
  [06:53:50.409] Searching for globals...
  [06:53:50.410] 
  [06:53:50.411] Searching for globals ... DONE
  [06:53:50.411] - globals: [0] <none>
  [06:53:50.411] getGlobalsAndPackages() ... DONE
  [06:53:50.412] 
  [06:53:50.412] 
  [06:53:50.412]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [06:53:50.414] getGlobalsAndPackages() ...
  [06:53:50.414] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.414] Resolving globals: FALSE
  [06:53:50.416] The total size of the 3 globals is 392 bytes (392 bytes)
  [06:53:50.416] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [06:53:50.417] 
  [06:53:50.417] getGlobalsAndPackages() ... DONE
  [06:53:50.422] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [06:53:50.422] Packages needed by future strategies (n = 0): <none>
  [06:53:50.436] {
  [06:53:50.436]     {
  [06:53:50.436]         ...future.startTime <- base::Sys.time()
  [06:53:50.436]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [06:53:50.436]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [06:53:50.436]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [06:53:50.436]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [06:53:50.436]             future.resolve.recursive = NULL, width = 80L)
  [06:53:50.436]         {
  [06:53:50.436]             {
  [06:53:50.436]                 {
  [06:53:50.436]                   {
  [06:53:50.436]                     base::local({
  [06:53:50.436]                       has_future <- base::requireNamespace("future", 
  [06:53:50.436]                         quietly = TRUE)
  [06:53:50.436]                       version <- if (has_future) 
  [06:53:50.436]                         utils::packageVersion("future")
  [06:53:50.436]                       else NULL
  [06:53:50.436]                       if (!has_future || version < "1.8.0") {
  [06:53:50.436]                         info <- base::c(r_version = base::gsub("R version ", 
  [06:53:50.436]                           "", base::R.version$version.string), 
  [06:53:50.436]                           platform = base::sprintf("%s (%s-bit)", 
  [06:53:50.436]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [06:53:50.436]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [06:53:50.436]                             "release", "version")], collapse = " "), 
  [06:53:50.436]                           hostname = base::Sys.info()[["nodename"]])
  [06:53:50.436]                         info <- base::sprintf("%s: %s", base::names(info), 
  [06:53:50.436]                           info)
  [06:53:50.436]                         info <- base::paste(info, collapse = "; ")
  [06:53:50.436]                         if (!has_future) {
  [06:53:50.436]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [06:53:50.436]                             info)
  [06:53:50.436]                         }
  [06:53:50.436]                         else {
  [06:53:50.436]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [06:53:50.436]                             info, version)
  [06:53:50.436]                         }
  [06:53:50.436]                         base::stop(msg)
  [06:53:50.436]                       }
  [06:53:50.436]                     })
  [06:53:50.436]                   }
  [06:53:50.436]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [06:53:50.436]                   base::options(mc.cores = 1L)
  [06:53:50.436]                 }
  [06:53:50.436]                 base::local({
  [06:53:50.436]                   for (pkg in c("doFuture", "stats")) {
  [06:53:50.436]                     base::loadNamespace(pkg)
  [06:53:50.436]                     base::library(pkg, character.only = TRUE)
  [06:53:50.436]                   }
  [06:53:50.436]                 })
  [06:53:50.436]             }
  [06:53:50.436]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [06:53:50.436]         }
  [06:53:50.436]     }
  [06:53:50.436]     if (base::is.na(TRUE)) {
  [06:53:50.436]     }
  [06:53:50.436]     else {
  [06:53:50.436]         if (TRUE) {
  [06:53:50.436]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [06:53:50.436]                 open = "w")
  [06:53:50.436]         }
  [06:53:50.436]         else {
  [06:53:50.436]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [06:53:50.436]                 windows = "NUL", "/dev/null"), open = "w")
  [06:53:50.436]         }
  [06:53:50.436]         base::sink(...future.stdout, type = "output", split = FALSE)
  [06:53:50.436]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [06:53:50.436]             base::sink(type = "output", split = FALSE)
  [06:53:50.436]             base::close(...future.stdout)
  [06:53:50.436]         }, add = TRUE)
  [06:53:50.436]     }
  [06:53:50.436]     ...future.frame <- base::sys.nframe()
  [06:53:50.436]     ...future.conditions <- base::list()
  [06:53:50.436]     ...future.rng <- base::globalenv()$.Random.seed
  [06:53:50.436]     ...future.result <- base::tryCatch({
  [06:53:50.436]         base::withCallingHandlers({
  [06:53:50.436]             ...future.value <- base::withVisible(base::local({
  [06:53:50.436]                 ...future.sendCondition <- local({
  [06:53:50.436]                   sendCondition <- NULL
  [06:53:50.436]                   function(frame = 1L) {
  [06:53:50.436]                     if (is.function(sendCondition)) 
  [06:53:50.436]                       return(sendCondition)
  [06:53:50.436]                     ns <- getNamespace("parallel")
  [06:53:50.436]                     if (exists("sendData", mode = "function", 
  [06:53:50.436]                       envir = ns)) {
  [06:53:50.436]                       parallel_sendData <- get("sendData", mode = "function", 
  [06:53:50.436]                         envir = ns)
  [06:53:50.436]                       envir <- sys.frame(frame)
  [06:53:50.436]                       master <- NULL
  [06:53:50.436]                       while (!identical(envir, .GlobalEnv) && 
  [06:53:50.436]                         !identical(envir, emptyenv())) {
  [06:53:50.436]                         if (exists("master", mode = "list", envir = envir, 
  [06:53:50.436]                           inherits = FALSE)) {
  [06:53:50.436]                           master <- get("master", mode = "list", 
  [06:53:50.436]                             envir = envir, inherits = FALSE)
  [06:53:50.436]                           if (inherits(master, "SOCKnode")) {
  [06:53:50.436]                             sendCondition <<- function(cond) {
  [06:53:50.436]                               data <- list(type = "VALUE", value = cond, 
  [06:53:50.436]                                 success = TRUE)
  [06:53:50.436]                               parallel_sendData(master, data)
  [06:53:50.436]                             }
  [06:53:50.436]                             return(sendCondition)
  [06:53:50.436]                           }
  [06:53:50.436]                         }
  [06:53:50.436]                         frame <- frame + 1L
  [06:53:50.436]                         envir <- sys.frame(frame)
  [06:53:50.436]                       }
  [06:53:50.436]                     }
  [06:53:50.436]                     sendCondition <<- function(cond) NULL
  [06:53:50.436]                   }
  [06:53:50.436]                 })
  [06:53:50.436]                 withCallingHandlers({
  [06:53:50.436]                   {
  [06:53:50.436]                     doFuture::registerDoFuture()
  [06:53:50.436]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [06:53:50.436]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [06:53:50.436]                       i <- NULL
  [06:53:50.436]                       ...future.env <- environment()
  [06:53:50.436]                       local({
  [06:53:50.436]                         for (name in names(...future.x_jj)) {
  [06:53:50.436]                           assign(name, ...future.x_jj[[name]], 
  [06:53:50.436]                             envir = ...future.env, inherits = FALSE)
  [06:53:50.436]                         }
  [06:53:50.436]                       })
  [06:53:50.436]                       tryCatch({
  [06:53:50.436]                         if (i%%2 == 0) 
  [06:53:50.436]                           stop(sprintf("Index error ('remove'), because i = %d", 
  [06:53:50.436]                             i))
  [06:53:50.436]                         dnorm(i, mean = mu, sd = sigma)
  [06:53:50.436]                       }, error = identity)
  [06:53:50.436]                     })
  [06:53:50.436]                   }
  [06:53:50.436]                 }, immediateCondition = function(cond) {
  [06:53:50.436]                   sendCondition <- ...future.sendCondition()
  [06:53:50.436]                   sendCondition(cond)
  [06:53:50.436]                   muffleCondition <- function (cond) 
  [06:53:50.436]                   {
  [06:53:50.436]                     inherits <- base::inherits
  [06:53:50.436]                     invokeRestart <- base::invokeRestart
  [06:53:50.436]                     muffled <- FALSE
  [06:53:50.436]                     if (inherits(cond, "message")) {
  [06:53:50.436]                       invokeRestart("muffleMessage")
  [06:53:50.436]                       muffled <- TRUE
  [06:53:50.436]                     }
  [06:53:50.436]                     else if (inherits(cond, "warning")) {
  [06:53:50.436]                       invokeRestart("muffleWarning")
  [06:53:50.436]                       muffled <- TRUE
  [06:53:50.436]                     }
  [06:53:50.436]                     else if (inherits(cond, "condition")) {
  [06:53:50.436]                       computeRestarts <- base::computeRestarts
  [06:53:50.436]                       grepl <- base::grepl
  [06:53:50.436]                       is.null <- base::is.null
  [06:53:50.436]                       restarts <- computeRestarts(cond)
  [06:53:50.436]                       for (restart in restarts) {
  [06:53:50.436]                         name <- restart$name
  [06:53:50.436]                         if (is.null(name)) 
  [06:53:50.436]                           next
  [06:53:50.436]                         if (!grepl("^muffle", name)) 
  [06:53:50.436]                           next
  [06:53:50.436]                         invokeRestart(restart)
  [06:53:50.436]                         muffled <- TRUE
  [06:53:50.436]                         break
  [06:53:50.436]                       }
  [06:53:50.436]                     }
  [06:53:50.436]                     invisible(muffled)
  [06:53:50.436]                   }
  [06:53:50.436]                   muffleCondition(cond)
  [06:53:50.436]                 })
  [06:53:50.436]             }))
  [06:53:50.436]             future::FutureResult(value = ...future.value$value, 
  [06:53:50.436]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:50.436]                   ...future.rng), started = ...future.startTime, 
  [06:53:50.436]                 version = "1.8")
  [06:53:50.436]         }, condition = base::local({
  [06:53:50.436]             c <- base::c
  [06:53:50.436]             inherits <- base::inherits
  [06:53:50.436]             invokeRestart <- base::invokeRestart
  [06:53:50.436]             length <- base::length
  [06:53:50.436]             list <- base::list
  [06:53:50.436]             seq.int <- base::seq.int
  [06:53:50.436]             signalCondition <- base::signalCondition
  [06:53:50.436]             sys.calls <- base::sys.calls
  [06:53:50.436]             Sys.time <- base::Sys.time
  [06:53:50.436]             `[[` <- base::`[[`
  [06:53:50.436]             `+` <- base::`+`
  [06:53:50.436]             `<<-` <- base::`<<-`
  [06:53:50.436]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [06:53:50.436]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [06:53:50.436]                   3L)]
  [06:53:50.436]             }
  [06:53:50.436]             function(cond) {
  [06:53:50.436]                 if (inherits(cond, "error")) {
  [06:53:50.436]                   sessionInformation <- function() {
  [06:53:50.436]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [06:53:50.436]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [06:53:50.436]                       search = base::search(), system = base::Sys.info())
  [06:53:50.436]                   }
  [06:53:50.436]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:50.436]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [06:53:50.436]                     cond$call), session = sessionInformation(), 
  [06:53:50.436]                     timestamp = Sys.time(), signaled = 0L)
  [06:53:50.436]                   signalCondition(cond)
  [06:53:50.436]                 }
  [06:53:50.436]                 else if (inherits(cond, c("condition", "immediateCondition"
  [06:53:50.436]                 ))) {
  [06:53:50.436]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [06:53:50.436]                   ...future.conditions[[length(...future.conditions) + 
  [06:53:50.436]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [06:53:50.436]                   if (!signal) {
  [06:53:50.436]                     muffleCondition <- function (cond) 
  [06:53:50.436]                     {
  [06:53:50.436]                       inherits <- base::inherits
  [06:53:50.436]                       invokeRestart <- base::invokeRestart
  [06:53:50.436]                       muffled <- FALSE
  [06:53:50.436]                       if (inherits(cond, "message")) {
  [06:53:50.436]                         invokeRestart("muffleMessage")
  [06:53:50.436]                         muffled <- TRUE
  [06:53:50.436]                       }
  [06:53:50.436]                       else if (inherits(cond, "warning")) {
  [06:53:50.436]                         invokeRestart("muffleWarning")
  [06:53:50.436]                         muffled <- TRUE
  [06:53:50.436]                       }
  [06:53:50.436]                       else if (inherits(cond, "condition")) {
  [06:53:50.436]                         computeRestarts <- base::computeRestarts
  [06:53:50.436]                         grepl <- base::grepl
  [06:53:50.436]                         is.null <- base::is.null
  [06:53:50.436]                         restarts <- computeRestarts(cond)
  [06:53:50.436]                         for (restart in restarts) {
  [06:53:50.436]                           name <- restart$name
  [06:53:50.436]                           if (is.null(name)) 
  [06:53:50.436]                             next
  [06:53:50.436]                           if (!grepl("^muffle", name)) 
  [06:53:50.436]                             next
  [06:53:50.436]                           invokeRestart(restart)
  [06:53:50.436]                           muffled <- TRUE
  [06:53:50.436]                           break
  [06:53:50.436]                         }
  [06:53:50.436]                       }
  [06:53:50.436]                       invisible(muffled)
  [06:53:50.436]                     }
  [06:53:50.436]                     muffleCondition(cond)
  [06:53:50.436]                   }
  [06:53:50.436]                 }
  [06:53:50.436]             }
  [06:53:50.436]         }))
  [06:53:50.436]     }, error = function(ex) {
  [06:53:50.436]         base::structure(base::list(value = NULL, visible = NULL, 
  [06:53:50.436]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [06:53:50.436]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [06:53:50.436]     }, finally = {
  [06:53:50.436]         {
  [06:53:50.436]             {
  [06:53:50.436]                 base::options(mc.cores = ...future.mc.cores.old)
  [06:53:50.436]             }
  [06:53:50.436]             future::plan(list(function (expr, envir = parent.frame(), 
  [06:53:50.436]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [06:53:50.436]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [06:53:50.436]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [06:53:50.436]                 ...) 
  [06:53:50.436]             {
  [06:53:50.436]                 if (substitute) 
  [06:53:50.436]                   expr <- substitute(expr)
  [06:53:50.436]                 if (is.function(workers)) 
  [06:53:50.436]                   workers <- workers()
  [06:53:50.436]                 workers <- as.integer(workers)
  [06:53:50.436]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [06:53:50.436]                   workers >= 1)
  [06:53:50.436]                 if (workers == 1L) {
  [06:53:50.436]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [06:53:50.436]                     lazy = TRUE, seed = seed, globals = globals, 
  [06:53:50.436]                     local = TRUE, label = label, ...))
  [06:53:50.436]                 }
  [06:53:50.436]                 workers <- ClusterRegistry("start", workers = workers)
  [06:53:50.436]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [06:53:50.436]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [06:53:50.436]                   globals = globals, persistent = persistent, 
  [06:53:50.436]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [06:53:50.436]                   label = label, ...)
  [06:53:50.436]                 if (!future$lazy) 
  [06:53:50.436]                   future <- run(future)
  [06:53:50.436]                 invisible(future)
  [06:53:50.436]             }), .cleanup = FALSE, .init = FALSE)
  [06:53:50.436]         }
  [06:53:50.436]         base::options(...future.oldOptions)
  [06:53:50.436]     })
  [06:53:50.436]     Sys.time
  [06:53:50.436]     if (base::is.na(TRUE)) {
  [06:53:50.436]     }
  [06:53:50.436]     else {
  [06:53:50.436]         base::sink(type = "output", split = FALSE)
  [06:53:50.436]         if (TRUE) {
  [06:53:50.436]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [06:53:50.436]         }
  [06:53:50.436]         else {
  [06:53:50.436]             ...future.result["stdout"] <- base::list(NULL)
  [06:53:50.436]         }
  [06:53:50.436]         base::close(...future.stdout)
  [06:53:50.436]         ...future.stdout <- NULL
  [06:53:50.436]     }
  [06:53:50.436]     ...future.result$conditions <- ...future.conditions
  [06:53:50.436]     ...future.result
  [06:53:50.436] }
  [06:53:50.455] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [06:53:50.456] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [06:53:50.457] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [06:53:50.457] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [06:53:50.458] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [06:53:50.459] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [06:53:50.460] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [06:53:50.461] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [06:53:50.462] MultisessionFuture started
  [06:53:50.463] Chunk #2 of 2 ... DONE
  [06:53:50.463] Launching 2 futures (chunks) ... DONE
  [06:53:50.464] - resolving futures
  [06:53:50.464]   - gathering results & relaying conditions (except errors)
  [06:53:50.464] resolve() on list ...
  [06:53:50.465]  recursive: 0
  [06:53:50.465]  length: 2
  [06:53:50.465] 
  [06:53:50.563] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:50.563] - Validating connection of MultisessionFuture
  [06:53:50.564] - received message: FutureResult
  [06:53:50.564] - Received FutureResult
  [06:53:50.564] - Erased future from FutureRegistry
  [06:53:50.565] result() for ClusterFuture ...
  [06:53:50.565] - result already collected: FutureResult
  [06:53:50.565] result() for ClusterFuture ... done
  [06:53:50.566] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:50.566] Future #1
  [06:53:50.566] result() for ClusterFuture ...
  [06:53:50.567] - result already collected: FutureResult
  [06:53:50.567] result() for ClusterFuture ... done
  [06:53:50.567] result() for ClusterFuture ...
  [06:53:50.568] - result already collected: FutureResult
  [06:53:50.568] result() for ClusterFuture ... done
  [06:53:50.569] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [06:53:50.569] - nx: 2
  [06:53:50.569] - relay: TRUE
  [06:53:50.570] - stdout: TRUE
  [06:53:50.570] - signal: TRUE
  [06:53:50.570] - resignal: FALSE
  [06:53:50.571] - force: FALSE
  [06:53:50.571] - relayed: [n=2] FALSE, FALSE
  [06:53:50.571] - queued futures: [n=2] FALSE, FALSE
  [06:53:50.572]  - until=1
  [06:53:50.572]  - relaying element #1
  [06:53:50.572] result() for ClusterFuture ...
  [06:53:50.573] - result already collected: FutureResult
  [06:53:50.573] result() for ClusterFuture ... done
  [06:53:50.573] result() for ClusterFuture ...
  [06:53:50.574] - result already collected: FutureResult
  [06:53:50.574] result() for ClusterFuture ... done
  [06:53:50.574] result() for ClusterFuture ...
  [06:53:50.575] - result already collected: FutureResult
  [06:53:50.575] result() for ClusterFuture ... done
  [06:53:50.575] result() for ClusterFuture ...
  [06:53:50.576] - result already collected: FutureResult
  [06:53:50.576] result() for ClusterFuture ... done
  [06:53:50.576] - relayed: [n=2] TRUE, FALSE
  [06:53:50.577] - queued futures: [n=2] TRUE, FALSE
  [06:53:50.577] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [06:53:50.577]  length: 1 (resolved future 1)
  [06:53:50.769] receiveMessageFromWorker() for ClusterFuture ...
  [06:53:50.769] - Validating connection of MultisessionFuture
  [06:53:50.770] - received message: FutureResult
  [06:53:50.770] - Received FutureResult
  [06:53:50.771] - Erased future from FutureRegistry
  [06:53:50.771] result() for ClusterFuture ...
  [06:53:50.772] - result already collected: FutureResult
  [06:53:50.772] result() for ClusterFuture ... done
  [06:53:50.772] receiveMessageFromWorker() for ClusterFuture ... done
  [06:53:50.773] Future #2
  [06:53:50.773] result() for ClusterFuture ...
  [06:53:50.773] - result already collected: FutureResult
  [06:53:50.774] result() for ClusterFuture ... done
  [06:53:50.774] result() for ClusterFuture ...
  [06:53:50.774] - result already collected: FutureResult
  [06:53:50.775] result() for ClusterFuture ... done
  [06:53:50.775] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [06:53:50.776] - nx: 2
  [06:53:50.776] - relay: TRUE
  [06:53:50.776] - stdout: TRUE
  [06:53:50.777] - signal: TRUE
  [06:53:50.777] - resignal: FALSE
  [06:53:50.777] - force: FALSE
  [06:53:50.778] - relayed: [n=2] TRUE, FALSE
  [06:53:50.781] - queued futures: [n=2] TRUE, FALSE
  [06:53:50.782]  - until=2
  [06:53:50.782]  - relaying element #2
  [06:53:50.782] result() for ClusterFuture ...
  [06:53:50.783] - result already collected: FutureResult
  [06:53:50.783] result() for ClusterFuture ... done
  [06:53:50.784] result() for ClusterFuture ...
  [06:53:50.784] - result already collected: FutureResult
  [06:53:50.784] result() for ClusterFuture ... done
  [06:53:50.785] result() for ClusterFuture ...
  [06:53:50.785] - result already collected: FutureResult
  [06:53:50.785] result() for ClusterFuture ... done
  [06:53:50.786] result() for ClusterFuture ...
  [06:53:50.786] - result already collected: FutureResult
  [06:53:50.787] result() for ClusterFuture ... done
  [06:53:50.787] - relayed: [n=2] TRUE, TRUE
  [06:53:50.787] - queued futures: [n=2] TRUE, TRUE
  [06:53:50.788] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [06:53:50.788]  length: 0 (resolved future 2)
  [06:53:50.788] Relaying remaining futures
  [06:53:50.789] signalConditionsASAP(NULL, pos=0) ...
  [06:53:50.789] - nx: 2
  [06:53:50.789] - relay: TRUE
  [06:53:50.790] - stdout: TRUE
  [06:53:50.790] - signal: TRUE
  [06:53:50.806] - resignal: FALSE
  [06:53:50.807] - force: FALSE
  [06:53:50.807] - relayed: [n=2] TRUE, TRUE
  [06:53:50.808] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [06:53:50.808] - relayed: [n=2] TRUE, TRUE
  [06:53:50.809] - queued futures: [n=2] TRUE, TRUE
  [06:53:50.809] signalConditionsASAP(NULL, pos=0) ... done
  [06:53:50.809] resolve() on list ... DONE
  [06:53:50.810] - collecting values of futures
  [06:53:50.810] result() for ClusterFuture ...
  [06:53:50.810] - result already collected: FutureResult
  [06:53:50.811] result() for ClusterFuture ... done
  [06:53:50.811] result() for ClusterFuture ...
  [06:53:50.811] - result already collected: FutureResult
  [06:53:50.812] result() for ClusterFuture ... done
  [06:53:50.812] result() for ClusterFuture ...
  [06:53:50.813] - result already collected: FutureResult
  [06:53:50.813] result() for ClusterFuture ... done
  [06:53:50.813] result() for ClusterFuture ...
  [06:53:50.814] - result already collected: FutureResult
  [06:53:50.814] result() for ClusterFuture ... done
  [06:53:50.814] - accumulating results
  [06:53:50.817] - processing errors (handler = 'remove')
  [06:53:50.818] - extracting results
  [06:53:50.818] doFuture() ... DONE
  List of 5
   $ : num 0.199
   $ : num 0.121
   $ : num 0.027
   $ : num 0.00222
   $ : num 6.69e-05
  - plan('multisession') ... DONE
  - plan('cluster') ...
  [06:53:50.842] plan(): Setting new future strategy stack:
  [06:53:50.843] List of future strategies:
  [06:53:50.843] 1. cluster:
  [06:53:50.843]    - 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, ...)
  [06:53:50.843]    - tweaked: FALSE
  [06:53:50.843]    - call: plan(strategy)
  [06:53:50.844] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [06:53:50.845] cluster:
  [06:53:50.845] - 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, ...)
  [06:53:50.845] - tweaked: FALSE
  [06:53:50.845] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 34356
  [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-release-gcc/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75897c85409d.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpCdCESm/future.parent=30089.75897c85409d.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75897c85409d.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=34356 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Detected a warning from socketConnection(): 'port 34356 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 34356 cannot be opened
  Killing worker process (PID 8815) if still alive
  [06:53:52.960] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(30089, signal = 0L)
  [1] TRUE
  Call: tools::pskill(30089, signal = 0L)
  [1] TRUE
  [06:53:52.961] - success
  [06:53:52.962] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 8815) 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 34356 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 34356 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-release-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:30089:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpCdCESm/future.parent=30089.75897c85409d.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=34356 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 8815) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted