Running '000.sessionDetails.R' [7s/8s]
  Running 'ClusterRegistry.R' [3s/49s]
  Running 'Future-class.R' [2s/18s]
  Running 'FutureError.R' [1s/1s]
  Running 'FutureGlobals.R' [1s/1s]
  Running 'FutureRegistry.R' [1s/1s]
  Running 'as.cluster.R' [1s/17s]
  Running 'availableCores.R' [1s/1s]
  Running 'availableWorkers.R' [1s/1s]
  Running 'backtrace.R' [1s/1s]
  Running 'cluster-missing-future-pkg.R' [1s/3s]
  Running 'cluster.R' [7s/115s]
  Running 'constant.R' [1s/1s]
  Running 'demo.R' [9s/26s]
  Running 'dotdotdot.R' [2s/18s]
  Running 'early-signaling.R' [2s/37s]
  Running 'future,labels.R' [2s/18s]
  Running 'future.R' [1s/1s]
  Running 'futureAssign.R' [2s/18s]
  Running 'futureAssign_OP.R' [4s/19s]
  Running 'futureAssign_OP_with_environment.R' [1s/1s]
  Running 'futureAssign_OP_with_listenv.R' [1s/1s]
  Running 'futureCall.R' [5s/22s]
  Running 'futureOf.R' [1s/1s]
  Running 'futureOf_with_environment.R' [1s/1s]
  Running 'futureOf_with_listenv.R' [1s/1s]
  Running 'futures.R' [21s/138s]
  Running 'globals,NSE.R' [3s/32s]
  Running 'globals,formulas.R' [4s/22s]
  Running 'globals,manual.R' [5s/24s]
  Running 'globals,resolve.R' [1s/17s]
  Running 'globals,subassignment.R' [4s/21s]
  Running 'globals,toolarge.R' [1s/17s]
  Running 'globals,tricky.R' [9s/28s]
  Running 'globals,tricky_recursive.R' [2s/19s]
  Running 'globalsOf,tweaks.R' [1s/1s]
  Running 'immediateCondition.R' [2s/20s]
  Running 'invalid-owner.R' [2s/19s]
  Running 'makeClusterPSOCK.R' [1s/8s]
  Running 'mandelbrot.R' [1s/1s]
  Running 'mpi.R' [1s/1s]
  Running 'multicore.R' [1s/1s]
  Running 'multiprocess.R' [1s/2s]
  Running 'multisession.R' [4s/49s]
  Running 'nbrOfWorkers.R' [5s/81s]
  Running 'nested_futures,mc.cores.R' [5s/116s]
  Running 'nested_futures.R' [5s/70s]
  Running 'non-exportable,connections.R' [1s/17s]
  Running 'objectSize.R' [1s/1s]
  Running 'plan.R' [4s/14s]
  Running 'relaying.R' [2s/21s]
  Running 'remote.R' [1s/17s]
  Running 'requestCore.R' [1s/3s]
  Running 'requestNode.R' [2s/29s]
  Running 'resolve.R' [7s/47s]
  Running 'rng.R' [7s/24s]
  Running 'sequential.R' [1s/1s]
  Running 'sessionDetails.R' [1s/1s]
  Running 'startup.R' [2s/34s]
  Running 'stdout.R' [3s/20s]
  Running 'transparent.R' [1s/1s]
  Running 'tweak.R' [1s/2s]
  Running 'utils.R' [7s/9s]
  Running 'uuid.R' [1s/2s]
  Running 'whichIndex.R' [1s/1s]
Running the tests in 'tests/futureCall.R' failed.
Complete output:
  > source("incl/start.R")
  [22:14:08.036] plan(): Setting new future strategy stack:
  [22:14:08.038] List of future strategies:
  [22:14:08.038] 1. sequential:
  [22:14:08.038]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.038]    - tweaked: FALSE
  [22:14:08.038]    - call: future::plan("sequential")
  [22:14:08.040] plan(): nbrOfWorkers() = 1
  > 
  > message("*** futureCall() ...")
  *** futureCall() ...
  > 
  > message("- futureCall() - sequential + lazy ...")
  - futureCall() - sequential + lazy ...
  > 
  > f1 <- future(do.call(rnorm, args = list(n = 100)), lazy = TRUE)
  [22:14:08.075] getGlobalsAndPackages() ...
  [22:14:08.075] Searching for globals...
  [22:14:08.085] - globals found: [3] 'do.call', 'rnorm', 'list'
  [22:14:08.086] Searching for globals ... DONE
  [22:14:08.086] Resolving globals: FALSE
  [22:14:08.097] 
  [22:14:08.097] - packages: [1] 'stats'
  [22:14:08.098] getGlobalsAndPackages() ... DONE
  > f2 <- futureCall(rnorm, args = list(n = 100), lazy = TRUE)
  [22:14:08.099] futureCall() ...
  [22:14:08.099] Finding globals ...
  [22:14:08.100] getGlobalsAndPackages() ...
  [22:14:08.100] Searching for globals...
  [22:14:08.129] - globals found: [5] 'do.call', 'FUN', 'args', '.Call', 'C_rnorm'
  [22:14:08.129] Searching for globals ... DONE
  [22:14:08.130] Resolving globals: FALSE
  [22:14:08.132] The total size of the 2 globals is 2.09 KiB (2144 bytes)
  [22:14:08.133] - globals: [2] 'FUN', 'args'
  [22:14:08.133] - packages: [1] 'stats'
  [22:14:08.133] getGlobalsAndPackages() ... DONE
  [22:14:08.134]  - globals found: [2] 'FUN', 'args'
  [22:14:08.134]  - needed namespaces: [1] 'stats'
  [22:14:08.134] Finding globals ... DONE
  [22:14:08.135] Globals to be used in the future:
  [22:14:08.135] List of 2
  [22:14:08.135]  $ FUN :function (n, mean = 0, sd = 1)  
  [22:14:08.135]  $ args:List of 1
  [22:14:08.135]   ..$ n: num 100
  [22:14:08.135]  - attr(*, "where")=List of 2
  [22:14:08.135]   ..$ FUN :<environment: 0x2a19e78> 
  [22:14:08.135]   ..$ args:<environment: 0x2a19e78> 
  [22:14:08.135]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.135]  - attr(*, "resolved")= logi FALSE
  [22:14:08.135]  - attr(*, "total_size")= num 2144
  [22:14:08.176] getGlobalsAndPackages() ...
  [22:14:08.177] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:08.177] Resolving globals: FALSE
  [22:14:08.178] The total size of the 2 globals is 2.09 KiB (2144 bytes)
  [22:14:08.178] - globals: [2] 'FUN', 'args'
  [22:14:08.179] - packages: [1] 'stats'
  [22:14:08.179] getGlobalsAndPackages() ... DONE
  [22:14:08.195] futureCall() ... DONE
  > 
  > set.seed(42L)
  > v0 <- rnorm(n = 100)
  > str(list(v0 = v0))
  List of 1
   $ v0: num [1:100] 1.371 -0.565 0.363 0.633 0.404 ...
  > 
  > set.seed(42L)
  > v1 <- value(f1)
  [22:14:08.211] Packages needed by the future expression (n = 1): 'stats'
  [22:14:08.211] Packages needed by future strategies (n = 0): <none>
  [22:14:08.217] {
  [22:14:08.217]     {
  [22:14:08.217]         ...future.startTime <- Sys.time()
  [22:14:08.217]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.217]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.217]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [22:14:08.217]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.217]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.217]         {
  [22:14:08.217]             {
  [22:14:08.217]                 {
  [22:14:08.217]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.217]                   version <- if (has_future) 
  [22:14:08.217]                     packageVersion("future")
  [22:14:08.217]                   else NULL
  [22:14:08.217]                   if (!has_future || version < "1.8.0") {
  [22:14:08.217]                     info <- c(r_version = gsub("R version ", 
  [22:14:08.217]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.217]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.217]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.217]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.217]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:08.217]                     info <- paste(info, collapse = "; ")
  [22:14:08.217]                     if (!has_future) {
  [22:14:08.217]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.217]                         info)
  [22:14:08.217]                     }
  [22:14:08.217]                     else {
  [22:14:08.217]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.217]                         info, version)
  [22:14:08.217]                     }
  [22:14:08.217]                     stop(msg)
  [22:14:08.217]                   }
  [22:14:08.217]                 }
  [22:14:08.217]                 local({
  [22:14:08.217]                   for (pkg in "stats") {
  [22:14:08.217]                     loadNamespace(pkg)
  [22:14:08.217]                     library(pkg, character.only = TRUE)
  [22:14:08.217]                   }
  [22:14:08.217]                 })
  [22:14:08.217]             }
  [22:14:08.217]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.217]         }
  [22:14:08.217]     }
  [22:14:08.217]     if (is.na(TRUE)) {
  [22:14:08.217]     }
  [22:14:08.217]     else {
  [22:14:08.217]         if (TRUE) {
  [22:14:08.217]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.217]         }
  [22:14:08.217]         else {
  [22:14:08.217]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.217]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.217]         }
  [22:14:08.217]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.217]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.217]             sink(type = "output", split = FALSE)
  [22:14:08.217]             close(...future.stdout)
  [22:14:08.217]         }, add = TRUE)
  [22:14:08.217]     }
  [22:14:08.217]     ...future.frame <- sys.nframe()
  [22:14:08.217]     ...future.conditions <- list()
  [22:14:08.217]     ...future.result <- tryCatch({
  [22:14:08.217]         withCallingHandlers({
  [22:14:08.217]             ...future.value <- local(do.call(rnorm, args = list(n = 100)))
  [22:14:08.217]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.217]                 version = "1.8")
  [22:14:08.217]         }, condition = local({
  [22:14:08.217]             inherits <- base::inherits
  [22:14:08.217]             invokeRestart <- base::invokeRestart
  [22:14:08.217]             length <- base::length
  [22:14:08.217]             seq.int <- base::seq.int
  [22:14:08.217]             sys.calls <- base::sys.calls
  [22:14:08.217]             `[[` <- base::`[[`
  [22:14:08.217]             `+` <- base::`+`
  [22:14:08.217]             `<<-` <- base::`<<-`
  [22:14:08.217]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.217]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.217]                   3L)]
  [22:14:08.217]             }
  [22:14:08.217]             function(cond) {
  [22:14:08.217]                 if (inherits(cond, "error")) {
  [22:14:08.217]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.217]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.217]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.217]                     signaled = 0L)
  [22:14:08.217]                   signalCondition(cond)
  [22:14:08.217]                 }
  [22:14:08.217]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.217]                 ))) {
  [22:14:08.217]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.217]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.217]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.217]                   if (inherits(cond, "message")) {
  [22:14:08.217]                     if (!signal) 
  [22:14:08.217]                       invokeRestart("muffleMessage")
  [22:14:08.217]                   }
  [22:14:08.217]                   else if (inherits(cond, "warning")) {
  [22:14:08.217]                     if (!signal) 
  [22:14:08.217]                       invokeRestart("muffleWarning")
  [22:14:08.217]                   }
  [22:14:08.217]                   else {
  [22:14:08.217]                     if (!signal) {
  [22:14:08.217]                       restarts <- computeRestarts(cond)
  [22:14:08.217]                       for (restart in restarts) {
  [22:14:08.217]                         name <- restart$name
  [22:14:08.217]                         if (is.null(name)) 
  [22:14:08.217]                           next
  [22:14:08.217]                         if (!grepl("^muffle", name)) 
  [22:14:08.217]                           next
  [22:14:08.217]                         invokeRestart(restart)
  [22:14:08.217]                         break
  [22:14:08.217]                       }
  [22:14:08.217]                     }
  [22:14:08.217]                   }
  [22:14:08.217]                 }
  [22:14:08.217]             }
  [22:14:08.217]         }))
  [22:14:08.217]     }, error = function(ex) {
  [22:14:08.217]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.217]             version = "1.8"), class = "FutureResult")
  [22:14:08.217]     }, finally = {
  [22:14:08.217]         {
  [22:14:08.217]             NULL
  [22:14:08.217]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.217]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.217]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.217]                 label = NULL, ...) 
  [22:14:08.217]             {
  [22:14:08.217]                 if (substitute) 
  [22:14:08.217]                   expr <- substitute(expr)
  [22:14:08.217]                 local <- as.logical(local)
  [22:14:08.217]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.217]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.217]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.217]                   label = label, ...)
  [22:14:08.217]                 if (!future$lazy) 
  [22:14:08.217]                   future <- run(future)
  [22:14:08.217]                 invisible(future)
  [22:14:08.217]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.217]         }
  [22:14:08.217]         options(...future.oldOptions)
  [22:14:08.217]     })
  [22:14:08.217]     if (is.na(TRUE)) {
  [22:14:08.217]     }
  [22:14:08.217]     else {
  [22:14:08.217]         sink(type = "output", split = FALSE)
  [22:14:08.217]         if (TRUE) {
  [22:14:08.217]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.217]         }
  [22:14:08.217]         else {
  [22:14:08.217]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.217]         }
  [22:14:08.217]         close(...future.stdout)
  [22:14:08.217]         ...future.stdout <- NULL
  [22:14:08.217]     }
  [22:14:08.217]     ...future.result$conditions <- ...future.conditions
  [22:14:08.217]     ...future.result
  [22:14:08.217] }
  [22:14:08.221] plan(): Setting new future strategy stack:
  [22:14:08.221] List of future strategies:
  [22:14:08.221] 1. sequential:
  [22:14:08.221]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.221]    - tweaked: FALSE
  [22:14:08.221]    - call: NULL
  [22:14:08.222] plan(): nbrOfWorkers() = 1
  [22:14:08.224] plan(): Setting new future strategy stack:
  [22:14:08.224] List of future strategies:
  [22:14:08.224] 1. sequential:
  [22:14:08.224]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.224]    - tweaked: FALSE
  [22:14:08.224]    - call: future::plan("sequential")
  [22:14:08.225] plan(): nbrOfWorkers() = 1
  [22:14:08.225] SequentialFuture started (and completed)
  > str(list(v1 = v1))
  List of 1
   $ v1: num [1:100] 1.371 -0.565 0.363 0.633 0.404 ...
  > 
  > set.seed(42L)
  > v2 <- value(f2)
  [22:14:08.230] Packages needed by the future expression (n = 1): 'stats'
  [22:14:08.230] Packages needed by future strategies (n = 0): <none>
  [22:14:08.235] {
  [22:14:08.235]     {
  [22:14:08.235]         ...future.startTime <- Sys.time()
  [22:14:08.235]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.235]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.235]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.235]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.235]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.235]         {
  [22:14:08.235]             {
  [22:14:08.235]                 {
  [22:14:08.235]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.235]                   version <- if (has_future) 
  [22:14:08.235]                     packageVersion("future")
  [22:14:08.235]                   else NULL
  [22:14:08.235]                   if (!has_future || version < "1.8.0") {
  [22:14:08.235]                     info <- c(r_version = gsub("R version ", 
  [22:14:08.235]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.235]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.235]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.235]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.235]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:08.235]                     info <- paste(info, collapse = "; ")
  [22:14:08.235]                     if (!has_future) {
  [22:14:08.235]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.235]                         info)
  [22:14:08.235]                     }
  [22:14:08.235]                     else {
  [22:14:08.235]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.235]                         info, version)
  [22:14:08.235]                     }
  [22:14:08.235]                     stop(msg)
  [22:14:08.235]                   }
  [22:14:08.235]                 }
  [22:14:08.235]                 local({
  [22:14:08.235]                   for (pkg in "stats") {
  [22:14:08.235]                     loadNamespace(pkg)
  [22:14:08.235]                     library(pkg, character.only = TRUE)
  [22:14:08.235]                   }
  [22:14:08.235]                 })
  [22:14:08.235]             }
  [22:14:08.235]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.235]         }
  [22:14:08.235]     }
  [22:14:08.235]     if (is.na(TRUE)) {
  [22:14:08.235]     }
  [22:14:08.235]     else {
  [22:14:08.235]         if (TRUE) {
  [22:14:08.235]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.235]         }
  [22:14:08.235]         else {
  [22:14:08.235]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.235]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.235]         }
  [22:14:08.235]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.235]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.235]             sink(type = "output", split = FALSE)
  [22:14:08.235]             close(...future.stdout)
  [22:14:08.235]         }, add = TRUE)
  [22:14:08.235]     }
  [22:14:08.235]     ...future.frame <- sys.nframe()
  [22:14:08.235]     ...future.conditions <- list()
  [22:14:08.235]     ...future.result <- tryCatch({
  [22:14:08.235]         withCallingHandlers({
  [22:14:08.235]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.235]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.235]                 version = "1.8")
  [22:14:08.235]         }, condition = local({
  [22:14:08.235]             inherits <- base::inherits
  [22:14:08.235]             invokeRestart <- base::invokeRestart
  [22:14:08.235]             length <- base::length
  [22:14:08.235]             seq.int <- base::seq.int
  [22:14:08.235]             sys.calls <- base::sys.calls
  [22:14:08.235]             `[[` <- base::`[[`
  [22:14:08.235]             `+` <- base::`+`
  [22:14:08.235]             `<<-` <- base::`<<-`
  [22:14:08.235]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.235]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.235]                   3L)]
  [22:14:08.235]             }
  [22:14:08.235]             function(cond) {
  [22:14:08.235]                 if (inherits(cond, "error")) {
  [22:14:08.235]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.235]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.235]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.235]                     signaled = 0L)
  [22:14:08.235]                   signalCondition(cond)
  [22:14:08.235]                 }
  [22:14:08.235]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.235]                 ))) {
  [22:14:08.235]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.235]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.235]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.235]                   if (inherits(cond, "message")) {
  [22:14:08.235]                     if (!signal) 
  [22:14:08.235]                       invokeRestart("muffleMessage")
  [22:14:08.235]                   }
  [22:14:08.235]                   else if (inherits(cond, "warning")) {
  [22:14:08.235]                     if (!signal) 
  [22:14:08.235]                       invokeRestart("muffleWarning")
  [22:14:08.235]                   }
  [22:14:08.235]                   else {
  [22:14:08.235]                     if (!signal) {
  [22:14:08.235]                       restarts <- computeRestarts(cond)
  [22:14:08.235]                       for (restart in restarts) {
  [22:14:08.235]                         name <- restart$name
  [22:14:08.235]                         if (is.null(name)) 
  [22:14:08.235]                           next
  [22:14:08.235]                         if (!grepl("^muffle", name)) 
  [22:14:08.235]                           next
  [22:14:08.235]                         invokeRestart(restart)
  [22:14:08.235]                         break
  [22:14:08.235]                       }
  [22:14:08.235]                     }
  [22:14:08.235]                   }
  [22:14:08.235]                 }
  [22:14:08.235]             }
  [22:14:08.235]         }))
  [22:14:08.235]     }, error = function(ex) {
  [22:14:08.235]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.235]             version = "1.8"), class = "FutureResult")
  [22:14:08.235]     }, finally = {
  [22:14:08.235]         {
  [22:14:08.235]             NULL
  [22:14:08.235]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.235]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.235]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.235]                 label = NULL, ...) 
  [22:14:08.235]             {
  [22:14:08.235]                 if (substitute) 
  [22:14:08.235]                   expr <- substitute(expr)
  [22:14:08.235]                 local <- as.logical(local)
  [22:14:08.235]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.235]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.235]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.235]                   label = label, ...)
  [22:14:08.235]                 if (!future$lazy) 
  [22:14:08.235]                   future <- run(future)
  [22:14:08.235]                 invisible(future)
  [22:14:08.235]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.235]         }
  [22:14:08.235]         options(...future.oldOptions)
  [22:14:08.235]     })
  [22:14:08.235]     if (is.na(TRUE)) {
  [22:14:08.235]     }
  [22:14:08.235]     else {
  [22:14:08.235]         sink(type = "output", split = FALSE)
  [22:14:08.235]         if (TRUE) {
  [22:14:08.235]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.235]         }
  [22:14:08.235]         else {
  [22:14:08.235]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.235]         }
  [22:14:08.235]         close(...future.stdout)
  [22:14:08.235]         ...future.stdout <- NULL
  [22:14:08.235]     }
  [22:14:08.235]     ...future.result$conditions <- ...future.conditions
  [22:14:08.235]     ...future.result
  [22:14:08.235] }
  [22:14:08.239] plan(): Setting new future strategy stack:
  [22:14:08.239] List of future strategies:
  [22:14:08.239] 1. sequential:
  [22:14:08.239]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.239]    - tweaked: FALSE
  [22:14:08.239]    - call: NULL
  [22:14:08.240] plan(): nbrOfWorkers() = 1
  [22:14:08.241] plan(): Setting new future strategy stack:
  [22:14:08.241] List of future strategies:
  [22:14:08.241] 1. sequential:
  [22:14:08.241]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.241]    - tweaked: FALSE
  [22:14:08.241]    - call: future::plan("sequential")
  [22:14:08.242] plan(): nbrOfWorkers() = 1
  [22:14:08.243] SequentialFuture started (and completed)
  > str(list(v2 = v2))
  List of 1
   $ v2: num [1:100] 1.371 -0.565 0.363 0.633 0.404 ...
  > 
  > ## Because we use lazy futures and set the
  > ## random seed just before they are resolved
  > stopifnot(all.equal(v1, v0))
  > stopifnot(all.equal(v1, v2))
  > 
  > message("- futureCall() - sequential + lazy ... DONE")
  - futureCall() - sequential + lazy ... DONE
  > 
  > message("- futureCall() - mix of strategies, cores, lazy and globals ...")
  - futureCall() - mix of strategies, cores, lazy and globals ...
  > 
  > a <- 3
  > args <- list(x = 42, y = 12)
  > v0 <- do.call(function(x, y) a * (x - y), args = args)
  > 
  > for (cores in 1:availCores) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  +   
  +   message(sprintf("Testing with %d cores ...", cores))
  +   options(mc.cores = cores)
  +   strategies <- supportedStrategies(cores)
  + 
  +   for (strategy in strategies) {
  +     message(sprintf("- plan('%s') ...", strategy))
  +     plan(strategy)
  + 
  +     for (lazy in c(FALSE, TRUE)) {
  +       for (globals in c(FALSE, TRUE)) {
  +         a <- 3
  +         args <- list(x = 42, y = 12)
  +         f <- futureCall(function(x, y) a * (x - y), args = args,
  +                         globals = globals, lazy = lazy)
  +         rm(list = c("a", "args"))
  +         print(f)
  +         res1 <- tryCatch({
  +           v1 <- value(f)
  +         }, error = identity)
  +         stopifnot(!inherits(res1, "FutureError"))
  +         if (!inherits(res1, "error")) {
  +           str(list(globals = globals, lazy = lazy, v0 = v0, v1 = v1))
  +           stopifnot(all.equal(v1, v0))
  +         } else {
  +           stopifnot(!globals)
  +         }
  + 
  +         a <- 3
  +         args <- list(x = 42, y = 12)
  +         f <- futureCall(function(x, y) a * (x - y), args = args,
  +                         globals = "a", lazy = lazy)
  +         rm(list = c("a", "args"))
  +         print(f)
  +         res2 <- tryCatch({
  +           v2 <- value(f)
  +         }, error = identity)
  +         stopifnot(!inherits(res2, "FutureError"))
  +         if (!inherits(res2, "error")) {
  +           str(list(globals = globals, lazy = lazy, v0 = v0, v2 = v2))
  +           stopifnot(all.equal(v2, v0))
  +         } else {
  +           stopifnot(!globals)
  +         }
  +         
  +         args <- list(x = 42, y = 12)
  +         f <- futureCall(function(x, y) a * (x - y), args = args,
  +                         globals = list(a = 3), lazy = lazy)
  +         rm(list = "args")
  +         print(f)
  +         res3 <- tryCatch({
  +           v3 <- value(f)
  +         }, error = identity)
  +         stopifnot(!inherits(res3, "FutureError"))
  +         if (!inherits(res3, "error")) {
  +           str(list(globals = globals, lazy = lazy, v0 = v0, v3 = v3))
  +           stopifnot(all.equal(v3, v0))
  +         } else {
  +           stopifnot(!globals)
  +         }
  + 
  +         rm(list = c("v1", "v2", "v3"))
  +       }
  +     }
  +   }
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + }
  Testing with 1 cores ...
  - plan('sequential') ...
  [22:14:08.352] plan(): Setting new future strategy stack:
  [22:14:08.353] List of future strategies:
  [22:14:08.353] 1. sequential:
  [22:14:08.353]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.353]    - tweaked: FALSE
  [22:14:08.353]    - call: plan(strategy)
  [22:14:08.393] plan(): nbrOfWorkers() = 1
  [22:14:08.393] futureCall() ...
  [22:14:08.394] Globals to be used in the future:
  [22:14:08.394] List of 2
  [22:14:08.394]  $ FUN :function (x, y)  
  [22:14:08.394]  $ args:List of 2
  [22:14:08.394]   ..$ x: num 42
  [22:14:08.394]   ..$ y: num 12
  [22:14:08.394]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.394]  - attr(*, "where")=List of 2
  [22:14:08.394]   ..$ FUN :<environment: 0x157be10> 
  [22:14:08.394]   ..$ args:<environment: 0x157be10> 
  [22:14:08.394]  - attr(*, "resolved")= logi FALSE
  [22:14:08.394]  - attr(*, "total_size")= num NA
  [22:14:08.404] getGlobalsAndPackages() ...
  [22:14:08.404] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:08.404] Resolving globals: FALSE
  [22:14:08.405] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:08.406] - globals: [2] 'FUN', 'args'
  [22:14:08.406] 
  [22:14:08.406] getGlobalsAndPackages() ... DONE
  [22:14:08.408] Packages needed by the future expression (n = 0): <none>
  [22:14:08.408] Packages needed by future strategies (n = 0): <none>
  [22:14:08.413] {
  [22:14:08.413]     {
  [22:14:08.413]         ...future.startTime <- Sys.time()
  [22:14:08.413]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.413]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.413]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.413]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.413]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.413]         {
  [22:14:08.413]             {
  [22:14:08.413]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.413]                 version <- if (has_future) 
  [22:14:08.413]                   packageVersion("future")
  [22:14:08.413]                 else NULL
  [22:14:08.413]                 if (!has_future || version < "1.8.0") {
  [22:14:08.413]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.413]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.413]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.413]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.413]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.413]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.413]                   info <- paste(info, collapse = "; ")
  [22:14:08.413]                   if (!has_future) {
  [22:14:08.413]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.413]                       info)
  [22:14:08.413]                   }
  [22:14:08.413]                   else {
  [22:14:08.413]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.413]                       info, version)
  [22:14:08.413]                   }
  [22:14:08.413]                   stop(msg)
  [22:14:08.413]                 }
  [22:14:08.413]             }
  [22:14:08.413]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.413]         }
  [22:14:08.413]     }
  [22:14:08.413]     if (is.na(TRUE)) {
  [22:14:08.413]     }
  [22:14:08.413]     else {
  [22:14:08.413]         if (TRUE) {
  [22:14:08.413]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.413]         }
  [22:14:08.413]         else {
  [22:14:08.413]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.413]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.413]         }
  [22:14:08.413]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.413]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.413]             sink(type = "output", split = FALSE)
  [22:14:08.413]             close(...future.stdout)
  [22:14:08.413]         }, add = TRUE)
  [22:14:08.413]     }
  [22:14:08.413]     ...future.frame <- sys.nframe()
  [22:14:08.413]     ...future.conditions <- list()
  [22:14:08.413]     ...future.result <- tryCatch({
  [22:14:08.413]         withCallingHandlers({
  [22:14:08.413]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.413]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.413]                 version = "1.8")
  [22:14:08.413]         }, condition = local({
  [22:14:08.413]             inherits <- base::inherits
  [22:14:08.413]             invokeRestart <- base::invokeRestart
  [22:14:08.413]             length <- base::length
  [22:14:08.413]             seq.int <- base::seq.int
  [22:14:08.413]             sys.calls <- base::sys.calls
  [22:14:08.413]             `[[` <- base::`[[`
  [22:14:08.413]             `+` <- base::`+`
  [22:14:08.413]             `<<-` <- base::`<<-`
  [22:14:08.413]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.413]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.413]                   3L)]
  [22:14:08.413]             }
  [22:14:08.413]             function(cond) {
  [22:14:08.413]                 if (inherits(cond, "error")) {
  [22:14:08.413]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.413]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.413]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.413]                     signaled = 0L)
  [22:14:08.413]                   signalCondition(cond)
  [22:14:08.413]                 }
  [22:14:08.413]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.413]                 ))) {
  [22:14:08.413]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.413]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.413]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.413]                   if (inherits(cond, "message")) {
  [22:14:08.413]                     if (!signal) 
  [22:14:08.413]                       invokeRestart("muffleMessage")
  [22:14:08.413]                   }
  [22:14:08.413]                   else if (inherits(cond, "warning")) {
  [22:14:08.413]                     if (!signal) 
  [22:14:08.413]                       invokeRestart("muffleWarning")
  [22:14:08.413]                   }
  [22:14:08.413]                   else {
  [22:14:08.413]                     if (!signal) {
  [22:14:08.413]                       restarts <- computeRestarts(cond)
  [22:14:08.413]                       for (restart in restarts) {
  [22:14:08.413]                         name <- restart$name
  [22:14:08.413]                         if (is.null(name)) 
  [22:14:08.413]                           next
  [22:14:08.413]                         if (!grepl("^muffle", name)) 
  [22:14:08.413]                           next
  [22:14:08.413]                         invokeRestart(restart)
  [22:14:08.413]                         break
  [22:14:08.413]                       }
  [22:14:08.413]                     }
  [22:14:08.413]                   }
  [22:14:08.413]                 }
  [22:14:08.413]             }
  [22:14:08.413]         }))
  [22:14:08.413]     }, error = function(ex) {
  [22:14:08.413]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.413]             version = "1.8"), class = "FutureResult")
  [22:14:08.413]     }, finally = {
  [22:14:08.413]         {
  [22:14:08.413]             NULL
  [22:14:08.413]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.413]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.413]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.413]                 label = NULL, ...) 
  [22:14:08.413]             {
  [22:14:08.413]                 if (substitute) 
  [22:14:08.413]                   expr <- substitute(expr)
  [22:14:08.413]                 local <- as.logical(local)
  [22:14:08.413]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.413]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.413]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.413]                   label = label, ...)
  [22:14:08.413]                 if (!future$lazy) 
  [22:14:08.413]                   future <- run(future)
  [22:14:08.413]                 invisible(future)
  [22:14:08.413]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.413]         }
  [22:14:08.413]         options(...future.oldOptions)
  [22:14:08.413]     })
  [22:14:08.413]     if (is.na(TRUE)) {
  [22:14:08.413]     }
  [22:14:08.413]     else {
  [22:14:08.413]         sink(type = "output", split = FALSE)
  [22:14:08.413]         if (TRUE) {
  [22:14:08.413]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.413]         }
  [22:14:08.413]         else {
  [22:14:08.413]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.413]         }
  [22:14:08.413]         close(...future.stdout)
  [22:14:08.413]         ...future.stdout <- NULL
  [22:14:08.413]     }
  [22:14:08.413]     ...future.result$conditions <- ...future.conditions
  [22:14:08.413]     ...future.result
  [22:14:08.413] }
  [22:14:08.416] plan(): Setting new future strategy stack:
  [22:14:08.416] List of future strategies:
  [22:14:08.416] 1. sequential:
  [22:14:08.416]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.416]    - tweaked: FALSE
  [22:14:08.416]    - call: NULL
  [22:14:08.417] plan(): nbrOfWorkers() = 1
  [22:14:08.418] plan(): Setting new future strategy stack:
  [22:14:08.418] List of future strategies:
  [22:14:08.418] 1. sequential:
  [22:14:08.418]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.418]    - tweaked: FALSE
  [22:14:08.418]    - call: plan(strategy)
  [22:14:08.419] plan(): nbrOfWorkers() = 1
  [22:14:08.420] SequentialFuture started (and completed)
  [22:14:08.420] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x157be10>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:08.428] futureCall() ...
  [22:14:08.429] Globals to be used in the future:
  [22:14:08.429] List of 3
  [22:14:08.429]  $ a   : num 3
  [22:14:08.429]  $ FUN :function (x, y)  
  [22:14:08.429]  $ args:List of 2
  [22:14:08.429]   ..$ x: num 42
  [22:14:08.429]   ..$ y: num 12
  [22:14:08.429]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.429]  - attr(*, "where")=List of 3
  [22:14:08.429]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.429]   ..$ FUN :<environment: 0x31c4538> 
  [22:14:08.429]   ..$ args:<environment: 0x2f48b08> 
  [22:14:08.429]  - attr(*, "resolved")= logi FALSE
  [22:14:08.429]  - attr(*, "total_size")= num NA
  [22:14:08.445] getGlobalsAndPackages() ...
  [22:14:08.445] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.446] Resolving globals: FALSE
  [22:14:08.447] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.447] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.447] 
  [22:14:08.448] getGlobalsAndPackages() ... DONE
  [22:14:08.449] Packages needed by the future expression (n = 0): <none>
  [22:14:08.449] Packages needed by future strategies (n = 0): <none>
  [22:14:08.454] {
  [22:14:08.454]     {
  [22:14:08.454]         ...future.startTime <- Sys.time()
  [22:14:08.454]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.454]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.454]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.454]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.454]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.454]         {
  [22:14:08.454]             {
  [22:14:08.454]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.454]                 version <- if (has_future) 
  [22:14:08.454]                   packageVersion("future")
  [22:14:08.454]                 else NULL
  [22:14:08.454]                 if (!has_future || version < "1.8.0") {
  [22:14:08.454]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.454]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.454]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.454]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.454]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.454]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.454]                   info <- paste(info, collapse = "; ")
  [22:14:08.454]                   if (!has_future) {
  [22:14:08.454]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.454]                       info)
  [22:14:08.454]                   }
  [22:14:08.454]                   else {
  [22:14:08.454]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.454]                       info, version)
  [22:14:08.454]                   }
  [22:14:08.454]                   stop(msg)
  [22:14:08.454]                 }
  [22:14:08.454]             }
  [22:14:08.454]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.454]         }
  [22:14:08.454]     }
  [22:14:08.454]     if (is.na(TRUE)) {
  [22:14:08.454]     }
  [22:14:08.454]     else {
  [22:14:08.454]         if (TRUE) {
  [22:14:08.454]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.454]         }
  [22:14:08.454]         else {
  [22:14:08.454]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.454]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.454]         }
  [22:14:08.454]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.454]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.454]             sink(type = "output", split = FALSE)
  [22:14:08.454]             close(...future.stdout)
  [22:14:08.454]         }, add = TRUE)
  [22:14:08.454]     }
  [22:14:08.454]     ...future.frame <- sys.nframe()
  [22:14:08.454]     ...future.conditions <- list()
  [22:14:08.454]     ...future.result <- tryCatch({
  [22:14:08.454]         withCallingHandlers({
  [22:14:08.454]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.454]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.454]                 version = "1.8")
  [22:14:08.454]         }, condition = local({
  [22:14:08.454]             inherits <- base::inherits
  [22:14:08.454]             invokeRestart <- base::invokeRestart
  [22:14:08.454]             length <- base::length
  [22:14:08.454]             seq.int <- base::seq.int
  [22:14:08.454]             sys.calls <- base::sys.calls
  [22:14:08.454]             `[[` <- base::`[[`
  [22:14:08.454]             `+` <- base::`+`
  [22:14:08.454]             `<<-` <- base::`<<-`
  [22:14:08.454]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.454]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.454]                   3L)]
  [22:14:08.454]             }
  [22:14:08.454]             function(cond) {
  [22:14:08.454]                 if (inherits(cond, "error")) {
  [22:14:08.454]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.454]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.454]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.454]                     signaled = 0L)
  [22:14:08.454]                   signalCondition(cond)
  [22:14:08.454]                 }
  [22:14:08.454]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.454]                 ))) {
  [22:14:08.454]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.454]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.454]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.454]                   if (inherits(cond, "message")) {
  [22:14:08.454]                     if (!signal) 
  [22:14:08.454]                       invokeRestart("muffleMessage")
  [22:14:08.454]                   }
  [22:14:08.454]                   else if (inherits(cond, "warning")) {
  [22:14:08.454]                     if (!signal) 
  [22:14:08.454]                       invokeRestart("muffleWarning")
  [22:14:08.454]                   }
  [22:14:08.454]                   else {
  [22:14:08.454]                     if (!signal) {
  [22:14:08.454]                       restarts <- computeRestarts(cond)
  [22:14:08.454]                       for (restart in restarts) {
  [22:14:08.454]                         name <- restart$name
  [22:14:08.454]                         if (is.null(name)) 
  [22:14:08.454]                           next
  [22:14:08.454]                         if (!grepl("^muffle", name)) 
  [22:14:08.454]                           next
  [22:14:08.454]                         invokeRestart(restart)
  [22:14:08.454]                         break
  [22:14:08.454]                       }
  [22:14:08.454]                     }
  [22:14:08.454]                   }
  [22:14:08.454]                 }
  [22:14:08.454]             }
  [22:14:08.454]         }))
  [22:14:08.454]     }, error = function(ex) {
  [22:14:08.454]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.454]             version = "1.8"), class = "FutureResult")
  [22:14:08.454]     }, finally = {
  [22:14:08.454]         {
  [22:14:08.454]             NULL
  [22:14:08.454]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.454]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.454]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.454]                 label = NULL, ...) 
  [22:14:08.454]             {
  [22:14:08.454]                 if (substitute) 
  [22:14:08.454]                   expr <- substitute(expr)
  [22:14:08.454]                 local <- as.logical(local)
  [22:14:08.454]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.454]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.454]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.454]                   label = label, ...)
  [22:14:08.454]                 if (!future$lazy) 
  [22:14:08.454]                   future <- run(future)
  [22:14:08.454]                 invisible(future)
  [22:14:08.454]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.454]         }
  [22:14:08.454]         options(...future.oldOptions)
  [22:14:08.454]     })
  [22:14:08.454]     if (is.na(TRUE)) {
  [22:14:08.454]     }
  [22:14:08.454]     else {
  [22:14:08.454]         sink(type = "output", split = FALSE)
  [22:14:08.454]         if (TRUE) {
  [22:14:08.454]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.454]         }
  [22:14:08.454]         else {
  [22:14:08.454]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.454]         }
  [22:14:08.454]         close(...future.stdout)
  [22:14:08.454]         ...future.stdout <- NULL
  [22:14:08.454]     }
  [22:14:08.454]     ...future.result$conditions <- ...future.conditions
  [22:14:08.454]     ...future.result
  [22:14:08.454] }
  [22:14:08.457] plan(): Setting new future strategy stack:
  [22:14:08.457] List of future strategies:
  [22:14:08.457] 1. sequential:
  [22:14:08.457]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.457]    - tweaked: FALSE
  [22:14:08.457]    - call: NULL
  [22:14:08.458] plan(): nbrOfWorkers() = 1
  [22:14:08.459] plan(): Setting new future strategy stack:
  [22:14:08.460] List of future strategies:
  [22:14:08.460] 1. sequential:
  [22:14:08.460]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.460]    - tweaked: FALSE
  [22:14:08.460]    - call: plan(strategy)
  [22:14:08.461] plan(): nbrOfWorkers() = 1
  [22:14:08.461] SequentialFuture started (and completed)
  [22:14:08.461] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2f48b08>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:08.468] futureCall() ...
  [22:14:08.470] Globals to be used in the future:
  [22:14:08.470] List of 3
  [22:14:08.470]  $ a   : num 3
  [22:14:08.470]  $ FUN :function (x, y)  
  [22:14:08.470]  $ args:List of 2
  [22:14:08.470]   ..$ x: num 42
  [22:14:08.470]   ..$ y: num 12
  [22:14:08.470]  - attr(*, "where")=List of 3
  [22:14:08.470]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:08.470]   ..$ FUN :<environment: 0x1b0ed00> 
  [22:14:08.470]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:08.470]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.470]  - attr(*, "resolved")= logi FALSE
  [22:14:08.470]  - attr(*, "total_size")= num NA
  [22:14:08.482] getGlobalsAndPackages() ...
  [22:14:08.482] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.483] Resolving globals: FALSE
  [22:14:08.484] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.484] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.485] 
  [22:14:08.485] getGlobalsAndPackages() ... DONE
  [22:14:08.487] Packages needed by the future expression (n = 0): <none>
  [22:14:08.487] Packages needed by future strategies (n = 0): <none>
  [22:14:08.491] {
  [22:14:08.491]     {
  [22:14:08.491]         ...future.startTime <- Sys.time()
  [22:14:08.491]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.491]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.491]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.491]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.491]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.491]         {
  [22:14:08.491]             {
  [22:14:08.491]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.491]                 version <- if (has_future) 
  [22:14:08.491]                   packageVersion("future")
  [22:14:08.491]                 else NULL
  [22:14:08.491]                 if (!has_future || version < "1.8.0") {
  [22:14:08.491]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.491]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.491]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.491]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.491]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.491]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.491]                   info <- paste(info, collapse = "; ")
  [22:14:08.491]                   if (!has_future) {
  [22:14:08.491]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.491]                       info)
  [22:14:08.491]                   }
  [22:14:08.491]                   else {
  [22:14:08.491]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.491]                       info, version)
  [22:14:08.491]                   }
  [22:14:08.491]                   stop(msg)
  [22:14:08.491]                 }
  [22:14:08.491]             }
  [22:14:08.491]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.491]         }
  [22:14:08.491]     }
  [22:14:08.491]     if (is.na(TRUE)) {
  [22:14:08.491]     }
  [22:14:08.491]     else {
  [22:14:08.491]         if (TRUE) {
  [22:14:08.491]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.491]         }
  [22:14:08.491]         else {
  [22:14:08.491]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.491]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.491]         }
  [22:14:08.491]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.491]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.491]             sink(type = "output", split = FALSE)
  [22:14:08.491]             close(...future.stdout)
  [22:14:08.491]         }, add = TRUE)
  [22:14:08.491]     }
  [22:14:08.491]     ...future.frame <- sys.nframe()
  [22:14:08.491]     ...future.conditions <- list()
  [22:14:08.491]     ...future.result <- tryCatch({
  [22:14:08.491]         withCallingHandlers({
  [22:14:08.491]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.491]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.491]                 version = "1.8")
  [22:14:08.491]         }, condition = local({
  [22:14:08.491]             inherits <- base::inherits
  [22:14:08.491]             invokeRestart <- base::invokeRestart
  [22:14:08.491]             length <- base::length
  [22:14:08.491]             seq.int <- base::seq.int
  [22:14:08.491]             sys.calls <- base::sys.calls
  [22:14:08.491]             `[[` <- base::`[[`
  [22:14:08.491]             `+` <- base::`+`
  [22:14:08.491]             `<<-` <- base::`<<-`
  [22:14:08.491]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.491]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.491]                   3L)]
  [22:14:08.491]             }
  [22:14:08.491]             function(cond) {
  [22:14:08.491]                 if (inherits(cond, "error")) {
  [22:14:08.491]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.491]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.491]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.491]                     signaled = 0L)
  [22:14:08.491]                   signalCondition(cond)
  [22:14:08.491]                 }
  [22:14:08.491]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.491]                 ))) {
  [22:14:08.491]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.491]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.491]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.491]                   if (inherits(cond, "message")) {
  [22:14:08.491]                     if (!signal) 
  [22:14:08.491]                       invokeRestart("muffleMessage")
  [22:14:08.491]                   }
  [22:14:08.491]                   else if (inherits(cond, "warning")) {
  [22:14:08.491]                     if (!signal) 
  [22:14:08.491]                       invokeRestart("muffleWarning")
  [22:14:08.491]                   }
  [22:14:08.491]                   else {
  [22:14:08.491]                     if (!signal) {
  [22:14:08.491]                       restarts <- computeRestarts(cond)
  [22:14:08.491]                       for (restart in restarts) {
  [22:14:08.491]                         name <- restart$name
  [22:14:08.491]                         if (is.null(name)) 
  [22:14:08.491]                           next
  [22:14:08.491]                         if (!grepl("^muffle", name)) 
  [22:14:08.491]                           next
  [22:14:08.491]                         invokeRestart(restart)
  [22:14:08.491]                         break
  [22:14:08.491]                       }
  [22:14:08.491]                     }
  [22:14:08.491]                   }
  [22:14:08.491]                 }
  [22:14:08.491]             }
  [22:14:08.491]         }))
  [22:14:08.491]     }, error = function(ex) {
  [22:14:08.491]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.491]             version = "1.8"), class = "FutureResult")
  [22:14:08.491]     }, finally = {
  [22:14:08.491]         {
  [22:14:08.491]             NULL
  [22:14:08.491]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.491]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.491]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.491]                 label = NULL, ...) 
  [22:14:08.491]             {
  [22:14:08.491]                 if (substitute) 
  [22:14:08.491]                   expr <- substitute(expr)
  [22:14:08.491]                 local <- as.logical(local)
  [22:14:08.491]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.491]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.491]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.491]                   label = label, ...)
  [22:14:08.491]                 if (!future$lazy) 
  [22:14:08.491]                   future <- run(future)
  [22:14:08.491]                 invisible(future)
  [22:14:08.491]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.491]         }
  [22:14:08.491]         options(...future.oldOptions)
  [22:14:08.491]     })
  [22:14:08.491]     if (is.na(TRUE)) {
  [22:14:08.491]     }
  [22:14:08.491]     else {
  [22:14:08.491]         sink(type = "output", split = FALSE)
  [22:14:08.491]         if (TRUE) {
  [22:14:08.491]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.491]         }
  [22:14:08.491]         else {
  [22:14:08.491]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.491]         }
  [22:14:08.491]         close(...future.stdout)
  [22:14:08.491]         ...future.stdout <- NULL
  [22:14:08.491]     }
  [22:14:08.491]     ...future.result$conditions <- ...future.conditions
  [22:14:08.491]     ...future.result
  [22:14:08.491] }
  [22:14:08.495] plan(): Setting new future strategy stack:
  [22:14:08.495] List of future strategies:
  [22:14:08.495] 1. sequential:
  [22:14:08.495]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.495]    - tweaked: FALSE
  [22:14:08.495]    - call: NULL
  [22:14:08.496] plan(): nbrOfWorkers() = 1
  [22:14:08.497] plan(): Setting new future strategy stack:
  [22:14:08.497] List of future strategies:
  [22:14:08.497] 1. sequential:
  [22:14:08.497]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.497]    - tweaked: FALSE
  [22:14:08.497]    - call: plan(strategy)
  [22:14:08.498] plan(): nbrOfWorkers() = 1
  [22:14:08.498] SequentialFuture started (and completed)
  [22:14:08.499] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1a978c0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:08.506] futureCall() ...
  [22:14:08.506] Finding globals ...
  [22:14:08.506] getGlobalsAndPackages() ...
  [22:14:08.507] Searching for globals...
  [22:14:08.514] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:08.515] Searching for globals ... DONE
  [22:14:08.515] Resolving globals: FALSE
  [22:14:08.516] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:08.517] - globals: [3] 'FUN', 'args', 'a'
  [22:14:08.517] 
  [22:14:08.517] getGlobalsAndPackages() ... DONE
  [22:14:08.518]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:08.518] 
  [22:14:08.518] Finding globals ... DONE
  [22:14:08.519] Globals to be used in the future:
  [22:14:08.519] List of 3
  [22:14:08.519]  $ FUN :function (x, y)  
  [22:14:08.519]  $ args:List of 2
  [22:14:08.519]   ..$ x: num 42
  [22:14:08.519]   ..$ y: num 12
  [22:14:08.519]  $ a   : num 3
  [22:14:08.519]  - attr(*, "where")=List of 3
  [22:14:08.519]   ..$ FUN :<environment: 0x179bf48> 
  [22:14:08.519]   ..$ args:<environment: 0x325cfa0> 
  [22:14:08.519]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.519]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.519]  - attr(*, "resolved")= logi FALSE
  [22:14:08.519]  - attr(*, "total_size")= num 2592
  [22:14:08.531] getGlobalsAndPackages() ...
  [22:14:08.531] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:08.532] Resolving globals: FALSE
  [22:14:08.533] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.533] - globals: [3] 'FUN', 'args', 'a'
  [22:14:08.533] 
  [22:14:08.534] getGlobalsAndPackages() ... DONE
  [22:14:08.535] Packages needed by the future expression (n = 0): <none>
  [22:14:08.536] Packages needed by future strategies (n = 0): <none>
  [22:14:08.540] {
  [22:14:08.540]     {
  [22:14:08.540]         ...future.startTime <- Sys.time()
  [22:14:08.540]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.540]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.540]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.540]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.540]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.540]         {
  [22:14:08.540]             {
  [22:14:08.540]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.540]                 version <- if (has_future) 
  [22:14:08.540]                   packageVersion("future")
  [22:14:08.540]                 else NULL
  [22:14:08.540]                 if (!has_future || version < "1.8.0") {
  [22:14:08.540]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.540]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.540]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.540]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.540]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.540]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.540]                   info <- paste(info, collapse = "; ")
  [22:14:08.540]                   if (!has_future) {
  [22:14:08.540]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.540]                       info)
  [22:14:08.540]                   }
  [22:14:08.540]                   else {
  [22:14:08.540]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.540]                       info, version)
  [22:14:08.540]                   }
  [22:14:08.540]                   stop(msg)
  [22:14:08.540]                 }
  [22:14:08.540]             }
  [22:14:08.540]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.540]         }
  [22:14:08.540]     }
  [22:14:08.540]     if (is.na(TRUE)) {
  [22:14:08.540]     }
  [22:14:08.540]     else {
  [22:14:08.540]         if (TRUE) {
  [22:14:08.540]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.540]         }
  [22:14:08.540]         else {
  [22:14:08.540]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.540]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.540]         }
  [22:14:08.540]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.540]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.540]             sink(type = "output", split = FALSE)
  [22:14:08.540]             close(...future.stdout)
  [22:14:08.540]         }, add = TRUE)
  [22:14:08.540]     }
  [22:14:08.540]     ...future.frame <- sys.nframe()
  [22:14:08.540]     ...future.conditions <- list()
  [22:14:08.540]     ...future.result <- tryCatch({
  [22:14:08.540]         withCallingHandlers({
  [22:14:08.540]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.540]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.540]                 version = "1.8")
  [22:14:08.540]         }, condition = local({
  [22:14:08.540]             inherits <- base::inherits
  [22:14:08.540]             invokeRestart <- base::invokeRestart
  [22:14:08.540]             length <- base::length
  [22:14:08.540]             seq.int <- base::seq.int
  [22:14:08.540]             sys.calls <- base::sys.calls
  [22:14:08.540]             `[[` <- base::`[[`
  [22:14:08.540]             `+` <- base::`+`
  [22:14:08.540]             `<<-` <- base::`<<-`
  [22:14:08.540]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.540]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.540]                   3L)]
  [22:14:08.540]             }
  [22:14:08.540]             function(cond) {
  [22:14:08.540]                 if (inherits(cond, "error")) {
  [22:14:08.540]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.540]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.540]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.540]                     signaled = 0L)
  [22:14:08.540]                   signalCondition(cond)
  [22:14:08.540]                 }
  [22:14:08.540]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.540]                 ))) {
  [22:14:08.540]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.540]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.540]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.540]                   if (inherits(cond, "message")) {
  [22:14:08.540]                     if (!signal) 
  [22:14:08.540]                       invokeRestart("muffleMessage")
  [22:14:08.540]                   }
  [22:14:08.540]                   else if (inherits(cond, "warning")) {
  [22:14:08.540]                     if (!signal) 
  [22:14:08.540]                       invokeRestart("muffleWarning")
  [22:14:08.540]                   }
  [22:14:08.540]                   else {
  [22:14:08.540]                     if (!signal) {
  [22:14:08.540]                       restarts <- computeRestarts(cond)
  [22:14:08.540]                       for (restart in restarts) {
  [22:14:08.540]                         name <- restart$name
  [22:14:08.540]                         if (is.null(name)) 
  [22:14:08.540]                           next
  [22:14:08.540]                         if (!grepl("^muffle", name)) 
  [22:14:08.540]                           next
  [22:14:08.540]                         invokeRestart(restart)
  [22:14:08.540]                         break
  [22:14:08.540]                       }
  [22:14:08.540]                     }
  [22:14:08.540]                   }
  [22:14:08.540]                 }
  [22:14:08.540]             }
  [22:14:08.540]         }))
  [22:14:08.540]     }, error = function(ex) {
  [22:14:08.540]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.540]             version = "1.8"), class = "FutureResult")
  [22:14:08.540]     }, finally = {
  [22:14:08.540]         {
  [22:14:08.540]             NULL
  [22:14:08.540]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.540]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.540]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.540]                 label = NULL, ...) 
  [22:14:08.540]             {
  [22:14:08.540]                 if (substitute) 
  [22:14:08.540]                   expr <- substitute(expr)
  [22:14:08.540]                 local <- as.logical(local)
  [22:14:08.540]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.540]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.540]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.540]                   label = label, ...)
  [22:14:08.540]                 if (!future$lazy) 
  [22:14:08.540]                   future <- run(future)
  [22:14:08.540]                 invisible(future)
  [22:14:08.540]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.540]         }
  [22:14:08.540]         options(...future.oldOptions)
  [22:14:08.540]     })
  [22:14:08.540]     if (is.na(TRUE)) {
  [22:14:08.540]     }
  [22:14:08.540]     else {
  [22:14:08.540]         sink(type = "output", split = FALSE)
  [22:14:08.540]         if (TRUE) {
  [22:14:08.540]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.540]         }
  [22:14:08.540]         else {
  [22:14:08.540]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.540]         }
  [22:14:08.540]         close(...future.stdout)
  [22:14:08.540]         ...future.stdout <- NULL
  [22:14:08.540]     }
  [22:14:08.540]     ...future.result$conditions <- ...future.conditions
  [22:14:08.540]     ...future.result
  [22:14:08.540] }
  [22:14:08.544] plan(): Setting new future strategy stack:
  [22:14:08.544] List of future strategies:
  [22:14:08.544] 1. sequential:
  [22:14:08.544]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.544]    - tweaked: FALSE
  [22:14:08.544]    - call: NULL
  [22:14:08.545] plan(): nbrOfWorkers() = 1
  [22:14:08.546] plan(): Setting new future strategy stack:
  [22:14:08.546] List of future strategies:
  [22:14:08.546] 1. sequential:
  [22:14:08.546]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.546]    - tweaked: FALSE
  [22:14:08.546]    - call: plan(strategy)
  [22:14:08.547] plan(): nbrOfWorkers() = 1
  [22:14:08.548] SequentialFuture started (and completed)
  [22:14:08.548] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x325cfa0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:08.555] futureCall() ...
  [22:14:08.556] Globals to be used in the future:
  [22:14:08.557] List of 3
  [22:14:08.557]  $ a   : num 3
  [22:14:08.557]  $ FUN :function (x, y)  
  [22:14:08.557]  $ args:List of 2
  [22:14:08.557]   ..$ x: num 42
  [22:14:08.557]   ..$ y: num 12
  [22:14:08.557]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.557]  - attr(*, "where")=List of 3
  [22:14:08.557]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.557]   ..$ FUN :<environment: 0x2ad98b0> 
  [22:14:08.557]   ..$ args:<environment: 0x2a93a50> 
  [22:14:08.557]  - attr(*, "resolved")= logi FALSE
  [22:14:08.557]  - attr(*, "total_size")= num NA
  [22:14:08.569] getGlobalsAndPackages() ...
  [22:14:08.569] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.570] Resolving globals: FALSE
  [22:14:08.571] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.571] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.572] 
  [22:14:08.572] getGlobalsAndPackages() ... DONE
  [22:14:08.574] Packages needed by the future expression (n = 0): <none>
  [22:14:08.574] Packages needed by future strategies (n = 0): <none>
  [22:14:08.578] {
  [22:14:08.578]     {
  [22:14:08.578]         ...future.startTime <- Sys.time()
  [22:14:08.578]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.578]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.578]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.578]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.578]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.578]         {
  [22:14:08.578]             {
  [22:14:08.578]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.578]                 version <- if (has_future) 
  [22:14:08.578]                   packageVersion("future")
  [22:14:08.578]                 else NULL
  [22:14:08.578]                 if (!has_future || version < "1.8.0") {
  [22:14:08.578]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.578]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.578]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.578]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.578]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.578]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.578]                   info <- paste(info, collapse = "; ")
  [22:14:08.578]                   if (!has_future) {
  [22:14:08.578]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.578]                       info)
  [22:14:08.578]                   }
  [22:14:08.578]                   else {
  [22:14:08.578]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.578]                       info, version)
  [22:14:08.578]                   }
  [22:14:08.578]                   stop(msg)
  [22:14:08.578]                 }
  [22:14:08.578]             }
  [22:14:08.578]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.578]         }
  [22:14:08.578]     }
  [22:14:08.578]     if (is.na(TRUE)) {
  [22:14:08.578]     }
  [22:14:08.578]     else {
  [22:14:08.578]         if (TRUE) {
  [22:14:08.578]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.578]         }
  [22:14:08.578]         else {
  [22:14:08.578]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.578]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.578]         }
  [22:14:08.578]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.578]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.578]             sink(type = "output", split = FALSE)
  [22:14:08.578]             close(...future.stdout)
  [22:14:08.578]         }, add = TRUE)
  [22:14:08.578]     }
  [22:14:08.578]     ...future.frame <- sys.nframe()
  [22:14:08.578]     ...future.conditions <- list()
  [22:14:08.578]     ...future.result <- tryCatch({
  [22:14:08.578]         withCallingHandlers({
  [22:14:08.578]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.578]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.578]                 version = "1.8")
  [22:14:08.578]         }, condition = local({
  [22:14:08.578]             inherits <- base::inherits
  [22:14:08.578]             invokeRestart <- base::invokeRestart
  [22:14:08.578]             length <- base::length
  [22:14:08.578]             seq.int <- base::seq.int
  [22:14:08.578]             sys.calls <- base::sys.calls
  [22:14:08.578]             `[[` <- base::`[[`
  [22:14:08.578]             `+` <- base::`+`
  [22:14:08.578]             `<<-` <- base::`<<-`
  [22:14:08.578]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.578]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.578]                   3L)]
  [22:14:08.578]             }
  [22:14:08.578]             function(cond) {
  [22:14:08.578]                 if (inherits(cond, "error")) {
  [22:14:08.578]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.578]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.578]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.578]                     signaled = 0L)
  [22:14:08.578]                   signalCondition(cond)
  [22:14:08.578]                 }
  [22:14:08.578]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.578]                 ))) {
  [22:14:08.578]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.578]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.578]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.578]                   if (inherits(cond, "message")) {
  [22:14:08.578]                     if (!signal) 
  [22:14:08.578]                       invokeRestart("muffleMessage")
  [22:14:08.578]                   }
  [22:14:08.578]                   else if (inherits(cond, "warning")) {
  [22:14:08.578]                     if (!signal) 
  [22:14:08.578]                       invokeRestart("muffleWarning")
  [22:14:08.578]                   }
  [22:14:08.578]                   else {
  [22:14:08.578]                     if (!signal) {
  [22:14:08.578]                       restarts <- computeRestarts(cond)
  [22:14:08.578]                       for (restart in restarts) {
  [22:14:08.578]                         name <- restart$name
  [22:14:08.578]                         if (is.null(name)) 
  [22:14:08.578]                           next
  [22:14:08.578]                         if (!grepl("^muffle", name)) 
  [22:14:08.578]                           next
  [22:14:08.578]                         invokeRestart(restart)
  [22:14:08.578]                         break
  [22:14:08.578]                       }
  [22:14:08.578]                     }
  [22:14:08.578]                   }
  [22:14:08.578]                 }
  [22:14:08.578]             }
  [22:14:08.578]         }))
  [22:14:08.578]     }, error = function(ex) {
  [22:14:08.578]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.578]             version = "1.8"), class = "FutureResult")
  [22:14:08.578]     }, finally = {
  [22:14:08.578]         {
  [22:14:08.578]             NULL
  [22:14:08.578]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.578]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.578]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.578]                 label = NULL, ...) 
  [22:14:08.578]             {
  [22:14:08.578]                 if (substitute) 
  [22:14:08.578]                   expr <- substitute(expr)
  [22:14:08.578]                 local <- as.logical(local)
  [22:14:08.578]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.578]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.578]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.578]                   label = label, ...)
  [22:14:08.578]                 if (!future$lazy) 
  [22:14:08.578]                   future <- run(future)
  [22:14:08.578]                 invisible(future)
  [22:14:08.578]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.578]         }
  [22:14:08.578]         options(...future.oldOptions)
  [22:14:08.578]     })
  [22:14:08.578]     if (is.na(TRUE)) {
  [22:14:08.578]     }
  [22:14:08.578]     else {
  [22:14:08.578]         sink(type = "output", split = FALSE)
  [22:14:08.578]         if (TRUE) {
  [22:14:08.578]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.578]         }
  [22:14:08.578]         else {
  [22:14:08.578]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.578]         }
  [22:14:08.578]         close(...future.stdout)
  [22:14:08.578]         ...future.stdout <- NULL
  [22:14:08.578]     }
  [22:14:08.578]     ...future.result$conditions <- ...future.conditions
  [22:14:08.578]     ...future.result
  [22:14:08.578] }
  [22:14:08.582] plan(): Setting new future strategy stack:
  [22:14:08.582] List of future strategies:
  [22:14:08.582] 1. sequential:
  [22:14:08.582]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.582]    - tweaked: FALSE
  [22:14:08.582]    - call: NULL
  [22:14:08.583] plan(): nbrOfWorkers() = 1
  [22:14:08.587] plan(): Setting new future strategy stack:
  [22:14:08.588] List of future strategies:
  [22:14:08.588] 1. sequential:
  [22:14:08.588]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.588]    - tweaked: FALSE
  [22:14:08.588]    - call: plan(strategy)
  [22:14:08.589] plan(): nbrOfWorkers() = 1
  [22:14:08.589] SequentialFuture started (and completed)
  [22:14:08.590] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2a93a50>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:08.597] futureCall() ...
  [22:14:08.598] Globals to be used in the future:
  [22:14:08.598] List of 3
  [22:14:08.598]  $ a   : num 3
  [22:14:08.598]  $ FUN :function (x, y)  
  [22:14:08.598]  $ args:List of 2
  [22:14:08.598]   ..$ x: num 42
  [22:14:08.598]   ..$ y: num 12
  [22:14:08.598]  - attr(*, "where")=List of 3
  [22:14:08.598]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:08.598]   ..$ FUN :<environment: 0x1c625d8> 
  [22:14:08.598]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:08.598]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.598]  - attr(*, "resolved")= logi FALSE
  [22:14:08.598]  - attr(*, "total_size")= num NA
  [22:14:08.610] getGlobalsAndPackages() ...
  [22:14:08.611] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.611] Resolving globals: FALSE
  [22:14:08.612] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.613] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.613] 
  [22:14:08.613] getGlobalsAndPackages() ... DONE
  [22:14:08.615] Packages needed by the future expression (n = 0): <none>
  [22:14:08.615] Packages needed by future strategies (n = 0): <none>
  [22:14:08.620] {
  [22:14:08.620]     {
  [22:14:08.620]         ...future.startTime <- Sys.time()
  [22:14:08.620]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.620]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.620]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.620]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.620]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.620]         {
  [22:14:08.620]             {
  [22:14:08.620]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.620]                 version <- if (has_future) 
  [22:14:08.620]                   packageVersion("future")
  [22:14:08.620]                 else NULL
  [22:14:08.620]                 if (!has_future || version < "1.8.0") {
  [22:14:08.620]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.620]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.620]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.620]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.620]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.620]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.620]                   info <- paste(info, collapse = "; ")
  [22:14:08.620]                   if (!has_future) {
  [22:14:08.620]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.620]                       info)
  [22:14:08.620]                   }
  [22:14:08.620]                   else {
  [22:14:08.620]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.620]                       info, version)
  [22:14:08.620]                   }
  [22:14:08.620]                   stop(msg)
  [22:14:08.620]                 }
  [22:14:08.620]             }
  [22:14:08.620]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.620]         }
  [22:14:08.620]     }
  [22:14:08.620]     if (is.na(TRUE)) {
  [22:14:08.620]     }
  [22:14:08.620]     else {
  [22:14:08.620]         if (TRUE) {
  [22:14:08.620]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.620]         }
  [22:14:08.620]         else {
  [22:14:08.620]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.620]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.620]         }
  [22:14:08.620]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.620]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.620]             sink(type = "output", split = FALSE)
  [22:14:08.620]             close(...future.stdout)
  [22:14:08.620]         }, add = TRUE)
  [22:14:08.620]     }
  [22:14:08.620]     ...future.frame <- sys.nframe()
  [22:14:08.620]     ...future.conditions <- list()
  [22:14:08.620]     ...future.result <- tryCatch({
  [22:14:08.620]         withCallingHandlers({
  [22:14:08.620]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.620]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.620]                 version = "1.8")
  [22:14:08.620]         }, condition = local({
  [22:14:08.620]             inherits <- base::inherits
  [22:14:08.620]             invokeRestart <- base::invokeRestart
  [22:14:08.620]             length <- base::length
  [22:14:08.620]             seq.int <- base::seq.int
  [22:14:08.620]             sys.calls <- base::sys.calls
  [22:14:08.620]             `[[` <- base::`[[`
  [22:14:08.620]             `+` <- base::`+`
  [22:14:08.620]             `<<-` <- base::`<<-`
  [22:14:08.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.620]                   3L)]
  [22:14:08.620]             }
  [22:14:08.620]             function(cond) {
  [22:14:08.620]                 if (inherits(cond, "error")) {
  [22:14:08.620]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.620]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.620]                     signaled = 0L)
  [22:14:08.620]                   signalCondition(cond)
  [22:14:08.620]                 }
  [22:14:08.620]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.620]                 ))) {
  [22:14:08.620]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.620]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.620]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.620]                   if (inherits(cond, "message")) {
  [22:14:08.620]                     if (!signal) 
  [22:14:08.620]                       invokeRestart("muffleMessage")
  [22:14:08.620]                   }
  [22:14:08.620]                   else if (inherits(cond, "warning")) {
  [22:14:08.620]                     if (!signal) 
  [22:14:08.620]                       invokeRestart("muffleWarning")
  [22:14:08.620]                   }
  [22:14:08.620]                   else {
  [22:14:08.620]                     if (!signal) {
  [22:14:08.620]                       restarts <- computeRestarts(cond)
  [22:14:08.620]                       for (restart in restarts) {
  [22:14:08.620]                         name <- restart$name
  [22:14:08.620]                         if (is.null(name)) 
  [22:14:08.620]                           next
  [22:14:08.620]                         if (!grepl("^muffle", name)) 
  [22:14:08.620]                           next
  [22:14:08.620]                         invokeRestart(restart)
  [22:14:08.620]                         break
  [22:14:08.620]                       }
  [22:14:08.620]                     }
  [22:14:08.620]                   }
  [22:14:08.620]                 }
  [22:14:08.620]             }
  [22:14:08.620]         }))
  [22:14:08.620]     }, error = function(ex) {
  [22:14:08.620]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.620]             version = "1.8"), class = "FutureResult")
  [22:14:08.620]     }, finally = {
  [22:14:08.620]         {
  [22:14:08.620]             NULL
  [22:14:08.620]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.620]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.620]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.620]                 label = NULL, ...) 
  [22:14:08.620]             {
  [22:14:08.620]                 if (substitute) 
  [22:14:08.620]                   expr <- substitute(expr)
  [22:14:08.620]                 local <- as.logical(local)
  [22:14:08.620]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.620]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.620]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.620]                   label = label, ...)
  [22:14:08.620]                 if (!future$lazy) 
  [22:14:08.620]                   future <- run(future)
  [22:14:08.620]                 invisible(future)
  [22:14:08.620]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.620]         }
  [22:14:08.620]         options(...future.oldOptions)
  [22:14:08.620]     })
  [22:14:08.620]     if (is.na(TRUE)) {
  [22:14:08.620]     }
  [22:14:08.620]     else {
  [22:14:08.620]         sink(type = "output", split = FALSE)
  [22:14:08.620]         if (TRUE) {
  [22:14:08.620]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.620]         }
  [22:14:08.620]         else {
  [22:14:08.620]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.620]         }
  [22:14:08.620]         close(...future.stdout)
  [22:14:08.620]         ...future.stdout <- NULL
  [22:14:08.620]     }
  [22:14:08.620]     ...future.result$conditions <- ...future.conditions
  [22:14:08.620]     ...future.result
  [22:14:08.620] }
  [22:14:08.623] plan(): Setting new future strategy stack:
  [22:14:08.623] List of future strategies:
  [22:14:08.623] 1. sequential:
  [22:14:08.623]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.623]    - tweaked: FALSE
  [22:14:08.623]    - call: NULL
  [22:14:08.624] plan(): nbrOfWorkers() = 1
  [22:14:08.625] plan(): Setting new future strategy stack:
  [22:14:08.626] List of future strategies:
  [22:14:08.626] 1. sequential:
  [22:14:08.626]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.626]    - tweaked: FALSE
  [22:14:08.626]    - call: plan(strategy)
  [22:14:08.626] plan(): nbrOfWorkers() = 1
  [22:14:08.627] SequentialFuture started (and completed)
  [22:14:08.627] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1cef6b8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:08.634] futureCall() ...
  [22:14:08.635] Globals to be used in the future:
  [22:14:08.635] List of 2
  [22:14:08.635]  $ FUN :function (x, y)  
  [22:14:08.635]  $ args:List of 2
  [22:14:08.635]   ..$ x: num 42
  [22:14:08.635]   ..$ y: num 12
  [22:14:08.635]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.635]  - attr(*, "where")=List of 2
  [22:14:08.635]   ..$ FUN :<environment: 0x2bb75b8> 
  [22:14:08.635]   ..$ args:<environment: 0x2bb75b8> 
  [22:14:08.635]  - attr(*, "resolved")= logi FALSE
  [22:14:08.635]  - attr(*, "total_size")= num NA
  [22:14:08.646] getGlobalsAndPackages() ...
  [22:14:08.646] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:08.647] Resolving globals: FALSE
  [22:14:08.648] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:08.648] - globals: [2] 'FUN', 'args'
  [22:14:08.649] 
  [22:14:08.649] getGlobalsAndPackages() ... DONE
  [22:14:08.650] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2bb75b8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.653] Packages needed by the future expression (n = 0): <none>
  [22:14:08.653] Packages needed by future strategies (n = 0): <none>
  [22:14:08.661] {
  [22:14:08.661]     {
  [22:14:08.661]         ...future.startTime <- Sys.time()
  [22:14:08.661]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.661]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.661]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.661]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.661]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.661]         {
  [22:14:08.661]             {
  [22:14:08.661]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.661]                 version <- if (has_future) 
  [22:14:08.661]                   packageVersion("future")
  [22:14:08.661]                 else NULL
  [22:14:08.661]                 if (!has_future || version < "1.8.0") {
  [22:14:08.661]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.661]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.661]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.661]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.661]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.661]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.661]                   info <- paste(info, collapse = "; ")
  [22:14:08.661]                   if (!has_future) {
  [22:14:08.661]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.661]                       info)
  [22:14:08.661]                   }
  [22:14:08.661]                   else {
  [22:14:08.661]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.661]                       info, version)
  [22:14:08.661]                   }
  [22:14:08.661]                   stop(msg)
  [22:14:08.661]                 }
  [22:14:08.661]             }
  [22:14:08.661]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.661]         }
  [22:14:08.661]     }
  [22:14:08.661]     if (is.na(TRUE)) {
  [22:14:08.661]     }
  [22:14:08.661]     else {
  [22:14:08.661]         if (TRUE) {
  [22:14:08.661]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.661]         }
  [22:14:08.661]         else {
  [22:14:08.661]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.661]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.661]         }
  [22:14:08.661]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.661]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.661]             sink(type = "output", split = FALSE)
  [22:14:08.661]             close(...future.stdout)
  [22:14:08.661]         }, add = TRUE)
  [22:14:08.661]     }
  [22:14:08.661]     ...future.frame <- sys.nframe()
  [22:14:08.661]     ...future.conditions <- list()
  [22:14:08.661]     ...future.result <- tryCatch({
  [22:14:08.661]         withCallingHandlers({
  [22:14:08.661]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.661]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.661]                 version = "1.8")
  [22:14:08.661]         }, condition = local({
  [22:14:08.661]             inherits <- base::inherits
  [22:14:08.661]             invokeRestart <- base::invokeRestart
  [22:14:08.661]             length <- base::length
  [22:14:08.661]             seq.int <- base::seq.int
  [22:14:08.661]             sys.calls <- base::sys.calls
  [22:14:08.661]             `[[` <- base::`[[`
  [22:14:08.661]             `+` <- base::`+`
  [22:14:08.661]             `<<-` <- base::`<<-`
  [22:14:08.661]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.661]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.661]                   3L)]
  [22:14:08.661]             }
  [22:14:08.661]             function(cond) {
  [22:14:08.661]                 if (inherits(cond, "error")) {
  [22:14:08.661]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.661]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.661]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.661]                     signaled = 0L)
  [22:14:08.661]                   signalCondition(cond)
  [22:14:08.661]                 }
  [22:14:08.661]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.661]                 ))) {
  [22:14:08.661]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.661]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.661]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.661]                   if (inherits(cond, "message")) {
  [22:14:08.661]                     if (!signal) 
  [22:14:08.661]                       invokeRestart("muffleMessage")
  [22:14:08.661]                   }
  [22:14:08.661]                   else if (inherits(cond, "warning")) {
  [22:14:08.661]                     if (!signal) 
  [22:14:08.661]                       invokeRestart("muffleWarning")
  [22:14:08.661]                   }
  [22:14:08.661]                   else {
  [22:14:08.661]                     if (!signal) {
  [22:14:08.661]                       restarts <- computeRestarts(cond)
  [22:14:08.661]                       for (restart in restarts) {
  [22:14:08.661]                         name <- restart$name
  [22:14:08.661]                         if (is.null(name)) 
  [22:14:08.661]                           next
  [22:14:08.661]                         if (!grepl("^muffle", name)) 
  [22:14:08.661]                           next
  [22:14:08.661]                         invokeRestart(restart)
  [22:14:08.661]                         break
  [22:14:08.661]                       }
  [22:14:08.661]                     }
  [22:14:08.661]                   }
  [22:14:08.661]                 }
  [22:14:08.661]             }
  [22:14:08.661]         }))
  [22:14:08.661]     }, error = function(ex) {
  [22:14:08.661]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.661]             version = "1.8"), class = "FutureResult")
  [22:14:08.661]     }, finally = {
  [22:14:08.661]         {
  [22:14:08.661]             NULL
  [22:14:08.661]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.661]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.661]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.661]                 label = NULL, ...) 
  [22:14:08.661]             {
  [22:14:08.661]                 if (substitute) 
  [22:14:08.661]                   expr <- substitute(expr)
  [22:14:08.661]                 local <- as.logical(local)
  [22:14:08.661]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.661]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.661]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.661]                   label = label, ...)
  [22:14:08.661]                 if (!future$lazy) 
  [22:14:08.661]                   future <- run(future)
  [22:14:08.661]                 invisible(future)
  [22:14:08.661]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.661]         }
  [22:14:08.661]         options(...future.oldOptions)
  [22:14:08.661]     })
  [22:14:08.661]     if (is.na(TRUE)) {
  [22:14:08.661]     }
  [22:14:08.661]     else {
  [22:14:08.661]         sink(type = "output", split = FALSE)
  [22:14:08.661]         if (TRUE) {
  [22:14:08.661]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.661]         }
  [22:14:08.661]         else {
  [22:14:08.661]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.661]         }
  [22:14:08.661]         close(...future.stdout)
  [22:14:08.661]         ...future.stdout <- NULL
  [22:14:08.661]     }
  [22:14:08.661]     ...future.result$conditions <- ...future.conditions
  [22:14:08.661]     ...future.result
  [22:14:08.661] }
  [22:14:08.664] plan(): Setting new future strategy stack:
  [22:14:08.664] List of future strategies:
  [22:14:08.664] 1. sequential:
  [22:14:08.664]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.664]    - tweaked: FALSE
  [22:14:08.664]    - call: NULL
  [22:14:08.665] plan(): nbrOfWorkers() = 1
  [22:14:08.667] plan(): Setting new future strategy stack:
  [22:14:08.667] List of future strategies:
  [22:14:08.667] 1. sequential:
  [22:14:08.667]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.667]    - tweaked: FALSE
  [22:14:08.667]    - call: plan(strategy)
  [22:14:08.668] plan(): nbrOfWorkers() = 1
  [22:14:08.668] SequentialFuture started (and completed)
  [22:14:08.669] signalConditions() ...
  [22:14:08.669]  - include = 'immediateCondition'
  [22:14:08.669]  - exclude = 
  [22:14:08.670]  - resignal = FALSE
  [22:14:08.670]  - Number of conditions: 1
  [22:14:08.670] signalConditions() ... done
  [22:14:08.671] signalConditions() ...
  [22:14:08.671]  - include = 'immediateCondition'
  [22:14:08.671]  - exclude = 
  [22:14:08.671]  - resignal = FALSE
  [22:14:08.672]  - Number of conditions: 1
  [22:14:08.672] signalConditions() ... done
  [22:14:08.672] Future state: 'finished'
  [22:14:08.673] signalConditions() ...
  [22:14:08.673]  - include = 'condition'
  [22:14:08.673]  - exclude = 'immediateCondition'
  [22:14:08.673]  - resignal = TRUE
  [22:14:08.674]  - Number of conditions: 1
  [22:14:08.674]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:08.674] signalConditions() ... done
  [22:14:08.675] futureCall() ...
  [22:14:08.676] Globals to be used in the future:
  [22:14:08.676] List of 3
  [22:14:08.676]  $ a   : num 3
  [22:14:08.676]  $ FUN :function (x, y)  
  [22:14:08.676]  $ args:List of 2
  [22:14:08.676]   ..$ x: num 42
  [22:14:08.676]   ..$ y: num 12
  [22:14:08.676]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.676]  - attr(*, "where")=List of 3
  [22:14:08.676]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.676]   ..$ FUN :<environment: 0x1381d28> 
  [22:14:08.676]   ..$ args:<environment: 0x1d0b2b8> 
  [22:14:08.676]  - attr(*, "resolved")= logi FALSE
  [22:14:08.676]  - attr(*, "total_size")= num NA
  [22:14:08.688] getGlobalsAndPackages() ...
  [22:14:08.688] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.688] Resolving globals: FALSE
  [22:14:08.689] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.690] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.690] 
  [22:14:08.690] getGlobalsAndPackages() ... DONE
  [22:14:08.691] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1d0b2b8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.694] Packages needed by the future expression (n = 0): <none>
  [22:14:08.695] Packages needed by future strategies (n = 0): <none>
  [22:14:08.699] {
  [22:14:08.699]     {
  [22:14:08.699]         ...future.startTime <- Sys.time()
  [22:14:08.699]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.699]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.699]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.699]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.699]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.699]         {
  [22:14:08.699]             {
  [22:14:08.699]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.699]                 version <- if (has_future) 
  [22:14:08.699]                   packageVersion("future")
  [22:14:08.699]                 else NULL
  [22:14:08.699]                 if (!has_future || version < "1.8.0") {
  [22:14:08.699]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.699]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.699]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.699]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.699]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.699]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.699]                   info <- paste(info, collapse = "; ")
  [22:14:08.699]                   if (!has_future) {
  [22:14:08.699]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.699]                       info)
  [22:14:08.699]                   }
  [22:14:08.699]                   else {
  [22:14:08.699]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.699]                       info, version)
  [22:14:08.699]                   }
  [22:14:08.699]                   stop(msg)
  [22:14:08.699]                 }
  [22:14:08.699]             }
  [22:14:08.699]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.699]         }
  [22:14:08.699]     }
  [22:14:08.699]     if (is.na(TRUE)) {
  [22:14:08.699]     }
  [22:14:08.699]     else {
  [22:14:08.699]         if (TRUE) {
  [22:14:08.699]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.699]         }
  [22:14:08.699]         else {
  [22:14:08.699]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.699]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.699]         }
  [22:14:08.699]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.699]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.699]             sink(type = "output", split = FALSE)
  [22:14:08.699]             close(...future.stdout)
  [22:14:08.699]         }, add = TRUE)
  [22:14:08.699]     }
  [22:14:08.699]     ...future.frame <- sys.nframe()
  [22:14:08.699]     ...future.conditions <- list()
  [22:14:08.699]     ...future.result <- tryCatch({
  [22:14:08.699]         withCallingHandlers({
  [22:14:08.699]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.699]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.699]                 version = "1.8")
  [22:14:08.699]         }, condition = local({
  [22:14:08.699]             inherits <- base::inherits
  [22:14:08.699]             invokeRestart <- base::invokeRestart
  [22:14:08.699]             length <- base::length
  [22:14:08.699]             seq.int <- base::seq.int
  [22:14:08.699]             sys.calls <- base::sys.calls
  [22:14:08.699]             `[[` <- base::`[[`
  [22:14:08.699]             `+` <- base::`+`
  [22:14:08.699]             `<<-` <- base::`<<-`
  [22:14:08.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.699]                   3L)]
  [22:14:08.699]             }
  [22:14:08.699]             function(cond) {
  [22:14:08.699]                 if (inherits(cond, "error")) {
  [22:14:08.699]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.699]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.699]                     signaled = 0L)
  [22:14:08.699]                   signalCondition(cond)
  [22:14:08.699]                 }
  [22:14:08.699]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.699]                 ))) {
  [22:14:08.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.699]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.699]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.699]                   if (inherits(cond, "message")) {
  [22:14:08.699]                     if (!signal) 
  [22:14:08.699]                       invokeRestart("muffleMessage")
  [22:14:08.699]                   }
  [22:14:08.699]                   else if (inherits(cond, "warning")) {
  [22:14:08.699]                     if (!signal) 
  [22:14:08.699]                       invokeRestart("muffleWarning")
  [22:14:08.699]                   }
  [22:14:08.699]                   else {
  [22:14:08.699]                     if (!signal) {
  [22:14:08.699]                       restarts <- computeRestarts(cond)
  [22:14:08.699]                       for (restart in restarts) {
  [22:14:08.699]                         name <- restart$name
  [22:14:08.699]                         if (is.null(name)) 
  [22:14:08.699]                           next
  [22:14:08.699]                         if (!grepl("^muffle", name)) 
  [22:14:08.699]                           next
  [22:14:08.699]                         invokeRestart(restart)
  [22:14:08.699]                         break
  [22:14:08.699]                       }
  [22:14:08.699]                     }
  [22:14:08.699]                   }
  [22:14:08.699]                 }
  [22:14:08.699]             }
  [22:14:08.699]         }))
  [22:14:08.699]     }, error = function(ex) {
  [22:14:08.699]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.699]             version = "1.8"), class = "FutureResult")
  [22:14:08.699]     }, finally = {
  [22:14:08.699]         {
  [22:14:08.699]             NULL
  [22:14:08.699]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.699]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.699]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.699]                 label = NULL, ...) 
  [22:14:08.699]             {
  [22:14:08.699]                 if (substitute) 
  [22:14:08.699]                   expr <- substitute(expr)
  [22:14:08.699]                 local <- as.logical(local)
  [22:14:08.699]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.699]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.699]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.699]                   label = label, ...)
  [22:14:08.699]                 if (!future$lazy) 
  [22:14:08.699]                   future <- run(future)
  [22:14:08.699]                 invisible(future)
  [22:14:08.699]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.699]         }
  [22:14:08.699]         options(...future.oldOptions)
  [22:14:08.699]     })
  [22:14:08.699]     if (is.na(TRUE)) {
  [22:14:08.699]     }
  [22:14:08.699]     else {
  [22:14:08.699]         sink(type = "output", split = FALSE)
  [22:14:08.699]         if (TRUE) {
  [22:14:08.699]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.699]         }
  [22:14:08.699]         else {
  [22:14:08.699]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.699]         }
  [22:14:08.699]         close(...future.stdout)
  [22:14:08.699]         ...future.stdout <- NULL
  [22:14:08.699]     }
  [22:14:08.699]     ...future.result$conditions <- ...future.conditions
  [22:14:08.699]     ...future.result
  [22:14:08.699] }
  [22:14:08.702] plan(): Setting new future strategy stack:
  [22:14:08.703] List of future strategies:
  [22:14:08.703] 1. sequential:
  [22:14:08.703]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.703]    - tweaked: FALSE
  [22:14:08.703]    - call: NULL
  [22:14:08.704] plan(): nbrOfWorkers() = 1
  [22:14:08.704] plan(): Setting new future strategy stack:
  [22:14:08.705] List of future strategies:
  [22:14:08.705] 1. sequential:
  [22:14:08.705]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.705]    - tweaked: FALSE
  [22:14:08.705]    - call: plan(strategy)
  [22:14:08.706] plan(): nbrOfWorkers() = 1
  [22:14:08.706] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:08.711] futureCall() ...
  [22:14:08.712] Globals to be used in the future:
  [22:14:08.712] List of 3
  [22:14:08.712]  $ a   : num 3
  [22:14:08.712]  $ FUN :function (x, y)  
  [22:14:08.712]  $ args:List of 2
  [22:14:08.712]   ..$ x: num 42
  [22:14:08.712]   ..$ y: num 12
  [22:14:08.712]  - attr(*, "where")=List of 3
  [22:14:08.712]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:08.712]   ..$ FUN :<environment: 0x2c1cad8> 
  [22:14:08.712]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:08.712]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.712]  - attr(*, "resolved")= logi FALSE
  [22:14:08.712]  - attr(*, "total_size")= num NA
  [22:14:08.724] getGlobalsAndPackages() ...
  [22:14:08.724] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.725] Resolving globals: FALSE
  [22:14:08.726] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.726] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.726] 
  [22:14:08.727] getGlobalsAndPackages() ... DONE
  [22:14:08.727] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2c063d8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.730] Packages needed by the future expression (n = 0): <none>
  [22:14:08.734] Packages needed by future strategies (n = 0): <none>
  [22:14:08.739] {
  [22:14:08.739]     {
  [22:14:08.739]         ...future.startTime <- Sys.time()
  [22:14:08.739]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.739]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.739]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.739]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.739]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.739]         {
  [22:14:08.739]             {
  [22:14:08.739]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.739]                 version <- if (has_future) 
  [22:14:08.739]                   packageVersion("future")
  [22:14:08.739]                 else NULL
  [22:14:08.739]                 if (!has_future || version < "1.8.0") {
  [22:14:08.739]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.739]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.739]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.739]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.739]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.739]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.739]                   info <- paste(info, collapse = "; ")
  [22:14:08.739]                   if (!has_future) {
  [22:14:08.739]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.739]                       info)
  [22:14:08.739]                   }
  [22:14:08.739]                   else {
  [22:14:08.739]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.739]                       info, version)
  [22:14:08.739]                   }
  [22:14:08.739]                   stop(msg)
  [22:14:08.739]                 }
  [22:14:08.739]             }
  [22:14:08.739]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.739]         }
  [22:14:08.739]     }
  [22:14:08.739]     if (is.na(TRUE)) {
  [22:14:08.739]     }
  [22:14:08.739]     else {
  [22:14:08.739]         if (TRUE) {
  [22:14:08.739]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.739]         }
  [22:14:08.739]         else {
  [22:14:08.739]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.739]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.739]         }
  [22:14:08.739]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.739]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.739]             sink(type = "output", split = FALSE)
  [22:14:08.739]             close(...future.stdout)
  [22:14:08.739]         }, add = TRUE)
  [22:14:08.739]     }
  [22:14:08.739]     ...future.frame <- sys.nframe()
  [22:14:08.739]     ...future.conditions <- list()
  [22:14:08.739]     ...future.result <- tryCatch({
  [22:14:08.739]         withCallingHandlers({
  [22:14:08.739]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.739]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.739]                 version = "1.8")
  [22:14:08.739]         }, condition = local({
  [22:14:08.739]             inherits <- base::inherits
  [22:14:08.739]             invokeRestart <- base::invokeRestart
  [22:14:08.739]             length <- base::length
  [22:14:08.739]             seq.int <- base::seq.int
  [22:14:08.739]             sys.calls <- base::sys.calls
  [22:14:08.739]             `[[` <- base::`[[`
  [22:14:08.739]             `+` <- base::`+`
  [22:14:08.739]             `<<-` <- base::`<<-`
  [22:14:08.739]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.739]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.739]                   3L)]
  [22:14:08.739]             }
  [22:14:08.739]             function(cond) {
  [22:14:08.739]                 if (inherits(cond, "error")) {
  [22:14:08.739]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.739]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.739]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.739]                     signaled = 0L)
  [22:14:08.739]                   signalCondition(cond)
  [22:14:08.739]                 }
  [22:14:08.739]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.739]                 ))) {
  [22:14:08.739]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.739]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.739]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.739]                   if (inherits(cond, "message")) {
  [22:14:08.739]                     if (!signal) 
  [22:14:08.739]                       invokeRestart("muffleMessage")
  [22:14:08.739]                   }
  [22:14:08.739]                   else if (inherits(cond, "warning")) {
  [22:14:08.739]                     if (!signal) 
  [22:14:08.739]                       invokeRestart("muffleWarning")
  [22:14:08.739]                   }
  [22:14:08.739]                   else {
  [22:14:08.739]                     if (!signal) {
  [22:14:08.739]                       restarts <- computeRestarts(cond)
  [22:14:08.739]                       for (restart in restarts) {
  [22:14:08.739]                         name <- restart$name
  [22:14:08.739]                         if (is.null(name)) 
  [22:14:08.739]                           next
  [22:14:08.739]                         if (!grepl("^muffle", name)) 
  [22:14:08.739]                           next
  [22:14:08.739]                         invokeRestart(restart)
  [22:14:08.739]                         break
  [22:14:08.739]                       }
  [22:14:08.739]                     }
  [22:14:08.739]                   }
  [22:14:08.739]                 }
  [22:14:08.739]             }
  [22:14:08.739]         }))
  [22:14:08.739]     }, error = function(ex) {
  [22:14:08.739]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.739]             version = "1.8"), class = "FutureResult")
  [22:14:08.739]     }, finally = {
  [22:14:08.739]         {
  [22:14:08.739]             NULL
  [22:14:08.739]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.739]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.739]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.739]                 label = NULL, ...) 
  [22:14:08.739]             {
  [22:14:08.739]                 if (substitute) 
  [22:14:08.739]                   expr <- substitute(expr)
  [22:14:08.739]                 local <- as.logical(local)
  [22:14:08.739]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.739]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.739]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.739]                   label = label, ...)
  [22:14:08.739]                 if (!future$lazy) 
  [22:14:08.739]                   future <- run(future)
  [22:14:08.739]                 invisible(future)
  [22:14:08.739]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.739]         }
  [22:14:08.739]         options(...future.oldOptions)
  [22:14:08.739]     })
  [22:14:08.739]     if (is.na(TRUE)) {
  [22:14:08.739]     }
  [22:14:08.739]     else {
  [22:14:08.739]         sink(type = "output", split = FALSE)
  [22:14:08.739]         if (TRUE) {
  [22:14:08.739]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.739]         }
  [22:14:08.739]         else {
  [22:14:08.739]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.739]         }
  [22:14:08.739]         close(...future.stdout)
  [22:14:08.739]         ...future.stdout <- NULL
  [22:14:08.739]     }
  [22:14:08.739]     ...future.result$conditions <- ...future.conditions
  [22:14:08.739]     ...future.result
  [22:14:08.739] }
  [22:14:08.742] plan(): Setting new future strategy stack:
  [22:14:08.743] List of future strategies:
  [22:14:08.743] 1. sequential:
  [22:14:08.743]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.743]    - tweaked: FALSE
  [22:14:08.743]    - call: NULL
  [22:14:08.744] plan(): nbrOfWorkers() = 1
  [22:14:08.744] plan(): Setting new future strategy stack:
  [22:14:08.745] List of future strategies:
  [22:14:08.745] 1. sequential:
  [22:14:08.745]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.745]    - tweaked: FALSE
  [22:14:08.745]    - call: plan(strategy)
  [22:14:08.746] plan(): nbrOfWorkers() = 1
  [22:14:08.746] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:08.752] futureCall() ...
  [22:14:08.752] Finding globals ...
  [22:14:08.752] getGlobalsAndPackages() ...
  [22:14:08.752] Searching for globals...
  [22:14:08.757] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:08.758] Searching for globals ... DONE
  [22:14:08.758] Resolving globals: FALSE
  [22:14:08.759] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:08.760] - globals: [3] 'FUN', 'args', 'a'
  [22:14:08.760] 
  [22:14:08.760] getGlobalsAndPackages() ... DONE
  [22:14:08.761]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:08.761] 
  [22:14:08.761] Finding globals ... DONE
  [22:14:08.762] Globals to be used in the future:
  [22:14:08.762] List of 3
  [22:14:08.762]  $ FUN :function (x, y)  
  [22:14:08.762]  $ args:List of 2
  [22:14:08.762]   ..$ x: num 42
  [22:14:08.762]   ..$ y: num 12
  [22:14:08.762]  $ a   : num 3
  [22:14:08.762]  - attr(*, "where")=List of 3
  [22:14:08.762]   ..$ FUN :<environment: 0x1f47a60> 
  [22:14:08.762]   ..$ args:<environment: 0x1d49990> 
  [22:14:08.762]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.762]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.762]  - attr(*, "resolved")= logi FALSE
  [22:14:08.762]  - attr(*, "total_size")= num 2592
  [22:14:08.774] getGlobalsAndPackages() ...
  [22:14:08.774] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:08.775] Resolving globals: FALSE
  [22:14:08.776] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.776] - globals: [3] 'FUN', 'args', 'a'
  [22:14:08.776] 
  [22:14:08.777] getGlobalsAndPackages() ... DONE
  [22:14:08.777] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1d49990>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.781] Packages needed by the future expression (n = 0): <none>
  [22:14:08.781] Packages needed by future strategies (n = 0): <none>
  [22:14:08.785] {
  [22:14:08.785]     {
  [22:14:08.785]         ...future.startTime <- Sys.time()
  [22:14:08.785]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.785]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.785]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.785]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.785]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.785]         {
  [22:14:08.785]             {
  [22:14:08.785]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.785]                 version <- if (has_future) 
  [22:14:08.785]                   packageVersion("future")
  [22:14:08.785]                 else NULL
  [22:14:08.785]                 if (!has_future || version < "1.8.0") {
  [22:14:08.785]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.785]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.785]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.785]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.785]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.785]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.785]                   info <- paste(info, collapse = "; ")
  [22:14:08.785]                   if (!has_future) {
  [22:14:08.785]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.785]                       info)
  [22:14:08.785]                   }
  [22:14:08.785]                   else {
  [22:14:08.785]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.785]                       info, version)
  [22:14:08.785]                   }
  [22:14:08.785]                   stop(msg)
  [22:14:08.785]                 }
  [22:14:08.785]             }
  [22:14:08.785]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.785]         }
  [22:14:08.785]     }
  [22:14:08.785]     if (is.na(TRUE)) {
  [22:14:08.785]     }
  [22:14:08.785]     else {
  [22:14:08.785]         if (TRUE) {
  [22:14:08.785]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.785]         }
  [22:14:08.785]         else {
  [22:14:08.785]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.785]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.785]         }
  [22:14:08.785]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.785]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.785]             sink(type = "output", split = FALSE)
  [22:14:08.785]             close(...future.stdout)
  [22:14:08.785]         }, add = TRUE)
  [22:14:08.785]     }
  [22:14:08.785]     ...future.frame <- sys.nframe()
  [22:14:08.785]     ...future.conditions <- list()
  [22:14:08.785]     ...future.result <- tryCatch({
  [22:14:08.785]         withCallingHandlers({
  [22:14:08.785]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.785]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.785]                 version = "1.8")
  [22:14:08.785]         }, condition = local({
  [22:14:08.785]             inherits <- base::inherits
  [22:14:08.785]             invokeRestart <- base::invokeRestart
  [22:14:08.785]             length <- base::length
  [22:14:08.785]             seq.int <- base::seq.int
  [22:14:08.785]             sys.calls <- base::sys.calls
  [22:14:08.785]             `[[` <- base::`[[`
  [22:14:08.785]             `+` <- base::`+`
  [22:14:08.785]             `<<-` <- base::`<<-`
  [22:14:08.785]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.785]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.785]                   3L)]
  [22:14:08.785]             }
  [22:14:08.785]             function(cond) {
  [22:14:08.785]                 if (inherits(cond, "error")) {
  [22:14:08.785]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.785]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.785]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.785]                     signaled = 0L)
  [22:14:08.785]                   signalCondition(cond)
  [22:14:08.785]                 }
  [22:14:08.785]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.785]                 ))) {
  [22:14:08.785]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.785]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.785]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.785]                   if (inherits(cond, "message")) {
  [22:14:08.785]                     if (!signal) 
  [22:14:08.785]                       invokeRestart("muffleMessage")
  [22:14:08.785]                   }
  [22:14:08.785]                   else if (inherits(cond, "warning")) {
  [22:14:08.785]                     if (!signal) 
  [22:14:08.785]                       invokeRestart("muffleWarning")
  [22:14:08.785]                   }
  [22:14:08.785]                   else {
  [22:14:08.785]                     if (!signal) {
  [22:14:08.785]                       restarts <- computeRestarts(cond)
  [22:14:08.785]                       for (restart in restarts) {
  [22:14:08.785]                         name <- restart$name
  [22:14:08.785]                         if (is.null(name)) 
  [22:14:08.785]                           next
  [22:14:08.785]                         if (!grepl("^muffle", name)) 
  [22:14:08.785]                           next
  [22:14:08.785]                         invokeRestart(restart)
  [22:14:08.785]                         break
  [22:14:08.785]                       }
  [22:14:08.785]                     }
  [22:14:08.785]                   }
  [22:14:08.785]                 }
  [22:14:08.785]             }
  [22:14:08.785]         }))
  [22:14:08.785]     }, error = function(ex) {
  [22:14:08.785]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.785]             version = "1.8"), class = "FutureResult")
  [22:14:08.785]     }, finally = {
  [22:14:08.785]         {
  [22:14:08.785]             NULL
  [22:14:08.785]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.785]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.785]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.785]                 label = NULL, ...) 
  [22:14:08.785]             {
  [22:14:08.785]                 if (substitute) 
  [22:14:08.785]                   expr <- substitute(expr)
  [22:14:08.785]                 local <- as.logical(local)
  [22:14:08.785]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.785]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.785]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.785]                   label = label, ...)
  [22:14:08.785]                 if (!future$lazy) 
  [22:14:08.785]                   future <- run(future)
  [22:14:08.785]                 invisible(future)
  [22:14:08.785]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.785]         }
  [22:14:08.785]         options(...future.oldOptions)
  [22:14:08.785]     })
  [22:14:08.785]     if (is.na(TRUE)) {
  [22:14:08.785]     }
  [22:14:08.785]     else {
  [22:14:08.785]         sink(type = "output", split = FALSE)
  [22:14:08.785]         if (TRUE) {
  [22:14:08.785]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.785]         }
  [22:14:08.785]         else {
  [22:14:08.785]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.785]         }
  [22:14:08.785]         close(...future.stdout)
  [22:14:08.785]         ...future.stdout <- NULL
  [22:14:08.785]     }
  [22:14:08.785]     ...future.result$conditions <- ...future.conditions
  [22:14:08.785]     ...future.result
  [22:14:08.785] }
  [22:14:08.788] plan(): Setting new future strategy stack:
  [22:14:08.789] List of future strategies:
  [22:14:08.789] 1. sequential:
  [22:14:08.789]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.789]    - tweaked: FALSE
  [22:14:08.789]    - call: NULL
  [22:14:08.790] plan(): nbrOfWorkers() = 1
  [22:14:08.791] plan(): Setting new future strategy stack:
  [22:14:08.791] List of future strategies:
  [22:14:08.791] 1. sequential:
  [22:14:08.791]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.791]    - tweaked: FALSE
  [22:14:08.791]    - call: plan(strategy)
  [22:14:08.792] plan(): nbrOfWorkers() = 1
  [22:14:08.793] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:08.798] futureCall() ...
  [22:14:08.799] Globals to be used in the future:
  [22:14:08.799] List of 3
  [22:14:08.799]  $ a   : num 3
  [22:14:08.799]  $ FUN :function (x, y)  
  [22:14:08.799]  $ args:List of 2
  [22:14:08.799]   ..$ x: num 42
  [22:14:08.799]   ..$ y: num 12
  [22:14:08.799]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.799]  - attr(*, "where")=List of 3
  [22:14:08.799]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.799]   ..$ FUN :<environment: 0x31db540> 
  [22:14:08.799]   ..$ args:<environment: 0x2fd2f40> 
  [22:14:08.799]  - attr(*, "resolved")= logi FALSE
  [22:14:08.799]  - attr(*, "total_size")= num NA
  [22:14:08.815] getGlobalsAndPackages() ...
  [22:14:08.815] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.816] Resolving globals: FALSE
  [22:14:08.817] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.817] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.818] 
  [22:14:08.818] getGlobalsAndPackages() ... DONE
  [22:14:08.818] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2fd2f40>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.822] Packages needed by the future expression (n = 0): <none>
  [22:14:08.822] Packages needed by future strategies (n = 0): <none>
  [22:14:08.826] {
  [22:14:08.826]     {
  [22:14:08.826]         ...future.startTime <- Sys.time()
  [22:14:08.826]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.826]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.826]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.826]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.826]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.826]         {
  [22:14:08.826]             {
  [22:14:08.826]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.826]                 version <- if (has_future) 
  [22:14:08.826]                   packageVersion("future")
  [22:14:08.826]                 else NULL
  [22:14:08.826]                 if (!has_future || version < "1.8.0") {
  [22:14:08.826]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.826]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.826]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.826]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.826]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.826]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.826]                   info <- paste(info, collapse = "; ")
  [22:14:08.826]                   if (!has_future) {
  [22:14:08.826]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.826]                       info)
  [22:14:08.826]                   }
  [22:14:08.826]                   else {
  [22:14:08.826]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.826]                       info, version)
  [22:14:08.826]                   }
  [22:14:08.826]                   stop(msg)
  [22:14:08.826]                 }
  [22:14:08.826]             }
  [22:14:08.826]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.826]         }
  [22:14:08.826]     }
  [22:14:08.826]     if (is.na(TRUE)) {
  [22:14:08.826]     }
  [22:14:08.826]     else {
  [22:14:08.826]         if (TRUE) {
  [22:14:08.826]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.826]         }
  [22:14:08.826]         else {
  [22:14:08.826]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.826]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.826]         }
  [22:14:08.826]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.826]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.826]             sink(type = "output", split = FALSE)
  [22:14:08.826]             close(...future.stdout)
  [22:14:08.826]         }, add = TRUE)
  [22:14:08.826]     }
  [22:14:08.826]     ...future.frame <- sys.nframe()
  [22:14:08.826]     ...future.conditions <- list()
  [22:14:08.826]     ...future.result <- tryCatch({
  [22:14:08.826]         withCallingHandlers({
  [22:14:08.826]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.826]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.826]                 version = "1.8")
  [22:14:08.826]         }, condition = local({
  [22:14:08.826]             inherits <- base::inherits
  [22:14:08.826]             invokeRestart <- base::invokeRestart
  [22:14:08.826]             length <- base::length
  [22:14:08.826]             seq.int <- base::seq.int
  [22:14:08.826]             sys.calls <- base::sys.calls
  [22:14:08.826]             `[[` <- base::`[[`
  [22:14:08.826]             `+` <- base::`+`
  [22:14:08.826]             `<<-` <- base::`<<-`
  [22:14:08.826]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.826]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.826]                   3L)]
  [22:14:08.826]             }
  [22:14:08.826]             function(cond) {
  [22:14:08.826]                 if (inherits(cond, "error")) {
  [22:14:08.826]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.826]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.826]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.826]                     signaled = 0L)
  [22:14:08.826]                   signalCondition(cond)
  [22:14:08.826]                 }
  [22:14:08.826]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.826]                 ))) {
  [22:14:08.826]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.826]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.826]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.826]                   if (inherits(cond, "message")) {
  [22:14:08.826]                     if (!signal) 
  [22:14:08.826]                       invokeRestart("muffleMessage")
  [22:14:08.826]                   }
  [22:14:08.826]                   else if (inherits(cond, "warning")) {
  [22:14:08.826]                     if (!signal) 
  [22:14:08.826]                       invokeRestart("muffleWarning")
  [22:14:08.826]                   }
  [22:14:08.826]                   else {
  [22:14:08.826]                     if (!signal) {
  [22:14:08.826]                       restarts <- computeRestarts(cond)
  [22:14:08.826]                       for (restart in restarts) {
  [22:14:08.826]                         name <- restart$name
  [22:14:08.826]                         if (is.null(name)) 
  [22:14:08.826]                           next
  [22:14:08.826]                         if (!grepl("^muffle", name)) 
  [22:14:08.826]                           next
  [22:14:08.826]                         invokeRestart(restart)
  [22:14:08.826]                         break
  [22:14:08.826]                       }
  [22:14:08.826]                     }
  [22:14:08.826]                   }
  [22:14:08.826]                 }
  [22:14:08.826]             }
  [22:14:08.826]         }))
  [22:14:08.826]     }, error = function(ex) {
  [22:14:08.826]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.826]             version = "1.8"), class = "FutureResult")
  [22:14:08.826]     }, finally = {
  [22:14:08.826]         {
  [22:14:08.826]             NULL
  [22:14:08.826]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.826]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.826]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.826]                 label = NULL, ...) 
  [22:14:08.826]             {
  [22:14:08.826]                 if (substitute) 
  [22:14:08.826]                   expr <- substitute(expr)
  [22:14:08.826]                 local <- as.logical(local)
  [22:14:08.826]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.826]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.826]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.826]                   label = label, ...)
  [22:14:08.826]                 if (!future$lazy) 
  [22:14:08.826]                   future <- run(future)
  [22:14:08.826]                 invisible(future)
  [22:14:08.826]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.826]         }
  [22:14:08.826]         options(...future.oldOptions)
  [22:14:08.826]     })
  [22:14:08.826]     if (is.na(TRUE)) {
  [22:14:08.826]     }
  [22:14:08.826]     else {
  [22:14:08.826]         sink(type = "output", split = FALSE)
  [22:14:08.826]         if (TRUE) {
  [22:14:08.826]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.826]         }
  [22:14:08.826]         else {
  [22:14:08.826]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.826]         }
  [22:14:08.826]         close(...future.stdout)
  [22:14:08.826]         ...future.stdout <- NULL
  [22:14:08.826]     }
  [22:14:08.826]     ...future.result$conditions <- ...future.conditions
  [22:14:08.826]     ...future.result
  [22:14:08.826] }
  [22:14:08.830] plan(): Setting new future strategy stack:
  [22:14:08.830] List of future strategies:
  [22:14:08.830] 1. sequential:
  [22:14:08.830]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.830]    - tweaked: FALSE
  [22:14:08.830]    - call: NULL
  [22:14:08.831] plan(): nbrOfWorkers() = 1
  [22:14:08.832] plan(): Setting new future strategy stack:
  [22:14:08.832] List of future strategies:
  [22:14:08.832] 1. sequential:
  [22:14:08.832]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.832]    - tweaked: FALSE
  [22:14:08.832]    - call: plan(strategy)
  [22:14:08.833] plan(): nbrOfWorkers() = 1
  [22:14:08.834] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:08.839] futureCall() ...
  [22:14:08.839] Globals to be used in the future:
  [22:14:08.840] List of 3
  [22:14:08.840]  $ a   : num 3
  [22:14:08.840]  $ FUN :function (x, y)  
  [22:14:08.840]  $ args:List of 2
  [22:14:08.840]   ..$ x: num 42
  [22:14:08.840]   ..$ y: num 12
  [22:14:08.840]  - attr(*, "where")=List of 3
  [22:14:08.840]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:08.840]   ..$ FUN :<environment: 0x271fb88> 
  [22:14:08.840]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:08.840]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.840]  - attr(*, "resolved")= logi FALSE
  [22:14:08.840]  - attr(*, "total_size")= num NA
  [22:14:08.851] getGlobalsAndPackages() ...
  [22:14:08.852] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.852] Resolving globals: FALSE
  [22:14:08.853] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.854] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.854] 
  [22:14:08.854] getGlobalsAndPackages() ... DONE
  [22:14:08.855] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2706288>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:08.858] Packages needed by the future expression (n = 0): <none>
  [22:14:08.859] Packages needed by future strategies (n = 0): <none>
  [22:14:08.863] {
  [22:14:08.863]     {
  [22:14:08.863]         ...future.startTime <- Sys.time()
  [22:14:08.863]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.863]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.863]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.863]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.863]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.863]         {
  [22:14:08.863]             {
  [22:14:08.863]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.863]                 version <- if (has_future) 
  [22:14:08.863]                   packageVersion("future")
  [22:14:08.863]                 else NULL
  [22:14:08.863]                 if (!has_future || version < "1.8.0") {
  [22:14:08.863]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.863]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.863]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.863]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.863]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.863]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.863]                   info <- paste(info, collapse = "; ")
  [22:14:08.863]                   if (!has_future) {
  [22:14:08.863]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.863]                       info)
  [22:14:08.863]                   }
  [22:14:08.863]                   else {
  [22:14:08.863]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.863]                       info, version)
  [22:14:08.863]                   }
  [22:14:08.863]                   stop(msg)
  [22:14:08.863]                 }
  [22:14:08.863]             }
  [22:14:08.863]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.863]         }
  [22:14:08.863]     }
  [22:14:08.863]     if (is.na(TRUE)) {
  [22:14:08.863]     }
  [22:14:08.863]     else {
  [22:14:08.863]         if (TRUE) {
  [22:14:08.863]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.863]         }
  [22:14:08.863]         else {
  [22:14:08.863]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.863]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.863]         }
  [22:14:08.863]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.863]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.863]             sink(type = "output", split = FALSE)
  [22:14:08.863]             close(...future.stdout)
  [22:14:08.863]         }, add = TRUE)
  [22:14:08.863]     }
  [22:14:08.863]     ...future.frame <- sys.nframe()
  [22:14:08.863]     ...future.conditions <- list()
  [22:14:08.863]     ...future.result <- tryCatch({
  [22:14:08.863]         withCallingHandlers({
  [22:14:08.863]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.863]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.863]                 version = "1.8")
  [22:14:08.863]         }, condition = local({
  [22:14:08.863]             inherits <- base::inherits
  [22:14:08.863]             invokeRestart <- base::invokeRestart
  [22:14:08.863]             length <- base::length
  [22:14:08.863]             seq.int <- base::seq.int
  [22:14:08.863]             sys.calls <- base::sys.calls
  [22:14:08.863]             `[[` <- base::`[[`
  [22:14:08.863]             `+` <- base::`+`
  [22:14:08.863]             `<<-` <- base::`<<-`
  [22:14:08.863]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.863]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.863]                   3L)]
  [22:14:08.863]             }
  [22:14:08.863]             function(cond) {
  [22:14:08.863]                 if (inherits(cond, "error")) {
  [22:14:08.863]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.863]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.863]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.863]                     signaled = 0L)
  [22:14:08.863]                   signalCondition(cond)
  [22:14:08.863]                 }
  [22:14:08.863]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.863]                 ))) {
  [22:14:08.863]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.863]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.863]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.863]                   if (inherits(cond, "message")) {
  [22:14:08.863]                     if (!signal) 
  [22:14:08.863]                       invokeRestart("muffleMessage")
  [22:14:08.863]                   }
  [22:14:08.863]                   else if (inherits(cond, "warning")) {
  [22:14:08.863]                     if (!signal) 
  [22:14:08.863]                       invokeRestart("muffleWarning")
  [22:14:08.863]                   }
  [22:14:08.863]                   else {
  [22:14:08.863]                     if (!signal) {
  [22:14:08.863]                       restarts <- computeRestarts(cond)
  [22:14:08.863]                       for (restart in restarts) {
  [22:14:08.863]                         name <- restart$name
  [22:14:08.863]                         if (is.null(name)) 
  [22:14:08.863]                           next
  [22:14:08.863]                         if (!grepl("^muffle", name)) 
  [22:14:08.863]                           next
  [22:14:08.863]                         invokeRestart(restart)
  [22:14:08.863]                         break
  [22:14:08.863]                       }
  [22:14:08.863]                     }
  [22:14:08.863]                   }
  [22:14:08.863]                 }
  [22:14:08.863]             }
  [22:14:08.863]         }))
  [22:14:08.863]     }, error = function(ex) {
  [22:14:08.863]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.863]             version = "1.8"), class = "FutureResult")
  [22:14:08.863]     }, finally = {
  [22:14:08.863]         {
  [22:14:08.863]             NULL
  [22:14:08.863]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.863]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.863]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:14:08.863]                 label = NULL, ...) 
  [22:14:08.863]             {
  [22:14:08.863]                 if (substitute) 
  [22:14:08.863]                   expr <- substitute(expr)
  [22:14:08.863]                 local <- as.logical(local)
  [22:14:08.863]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:14:08.863]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.863]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:14:08.863]                   label = label, ...)
  [22:14:08.863]                 if (!future$lazy) 
  [22:14:08.863]                   future <- run(future)
  [22:14:08.863]                 invisible(future)
  [22:14:08.863]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.863]         }
  [22:14:08.863]         options(...future.oldOptions)
  [22:14:08.863]     })
  [22:14:08.863]     if (is.na(TRUE)) {
  [22:14:08.863]     }
  [22:14:08.863]     else {
  [22:14:08.863]         sink(type = "output", split = FALSE)
  [22:14:08.863]         if (TRUE) {
  [22:14:08.863]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.863]         }
  [22:14:08.863]         else {
  [22:14:08.863]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.863]         }
  [22:14:08.863]         close(...future.stdout)
  [22:14:08.863]         ...future.stdout <- NULL
  [22:14:08.863]     }
  [22:14:08.863]     ...future.result$conditions <- ...future.conditions
  [22:14:08.863]     ...future.result
  [22:14:08.863] }
  [22:14:08.866] plan(): Setting new future strategy stack:
  [22:14:08.867] List of future strategies:
  [22:14:08.867] 1. sequential:
  [22:14:08.867]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.867]    - tweaked: FALSE
  [22:14:08.867]    - call: NULL
  [22:14:08.868] plan(): nbrOfWorkers() = 1
  [22:14:08.869] plan(): Setting new future strategy stack:
  [22:14:08.869] List of future strategies:
  [22:14:08.869] 1. sequential:
  [22:14:08.869]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.869]    - tweaked: FALSE
  [22:14:08.869]    - call: plan(strategy)
  [22:14:08.870] plan(): nbrOfWorkers() = 1
  [22:14:08.871] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  - plan('multicore') ...
  [22:14:08.881] plan(): Setting new future strategy stack:
  [22:14:08.882] List of future strategies:
  [22:14:08.882] 1. multicore:
  [22:14:08.882]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:08.882]    - tweaked: FALSE
  [22:14:08.882]    - call: plan(strategy)
  [22:14:08.884] plan(): nbrOfWorkers() = 1
  [22:14:08.884] futureCall() ...
  [22:14:08.885] Globals to be used in the future:
  [22:14:08.885] List of 2
  [22:14:08.885]  $ FUN :function (x, y)  
  [22:14:08.885]  $ args:List of 2
  [22:14:08.885]   ..$ x: num 42
  [22:14:08.885]   ..$ y: num 12
  [22:14:08.885]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.885]  - attr(*, "where")=List of 2
  [22:14:08.885]   ..$ FUN :<environment: 0x1a945e8> 
  [22:14:08.885]   ..$ args:<environment: 0x1a945e8> 
  [22:14:08.885]  - attr(*, "resolved")= logi FALSE
  [22:14:08.885]  - attr(*, "total_size")= num NA
  [22:14:08.896] getGlobalsAndPackages() ...
  [22:14:08.896] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:08.896] Resolving globals: FALSE
  [22:14:08.897] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:08.898] - globals: [2] 'FUN', 'args'
  [22:14:08.898] 
  [22:14:08.899] getGlobalsAndPackages() ... DONE
  [22:14:08.900] Packages needed by the future expression (n = 0): <none>
  [22:14:08.901] Packages needed by future strategies (n = 0): <none>
  [22:14:08.905] {
  [22:14:08.905]     {
  [22:14:08.905]         ...future.startTime <- Sys.time()
  [22:14:08.905]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.905]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.905]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.905]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.905]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.905]         {
  [22:14:08.905]             {
  [22:14:08.905]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.905]                 version <- if (has_future) 
  [22:14:08.905]                   packageVersion("future")
  [22:14:08.905]                 else NULL
  [22:14:08.905]                 if (!has_future || version < "1.8.0") {
  [22:14:08.905]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.905]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.905]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.905]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.905]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.905]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.905]                   info <- paste(info, collapse = "; ")
  [22:14:08.905]                   if (!has_future) {
  [22:14:08.905]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.905]                       info)
  [22:14:08.905]                   }
  [22:14:08.905]                   else {
  [22:14:08.905]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.905]                       info, version)
  [22:14:08.905]                   }
  [22:14:08.905]                   stop(msg)
  [22:14:08.905]                 }
  [22:14:08.905]             }
  [22:14:08.905]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.905]         }
  [22:14:08.905]     }
  [22:14:08.905]     if (is.na(TRUE)) {
  [22:14:08.905]     }
  [22:14:08.905]     else {
  [22:14:08.905]         if (TRUE) {
  [22:14:08.905]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.905]         }
  [22:14:08.905]         else {
  [22:14:08.905]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.905]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.905]         }
  [22:14:08.905]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.905]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.905]             sink(type = "output", split = FALSE)
  [22:14:08.905]             close(...future.stdout)
  [22:14:08.905]         }, add = TRUE)
  [22:14:08.905]     }
  [22:14:08.905]     ...future.frame <- sys.nframe()
  [22:14:08.905]     ...future.conditions <- list()
  [22:14:08.905]     ...future.result <- tryCatch({
  [22:14:08.905]         withCallingHandlers({
  [22:14:08.905]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.905]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.905]                 version = "1.8")
  [22:14:08.905]         }, condition = local({
  [22:14:08.905]             inherits <- base::inherits
  [22:14:08.905]             invokeRestart <- base::invokeRestart
  [22:14:08.905]             length <- base::length
  [22:14:08.905]             seq.int <- base::seq.int
  [22:14:08.905]             sys.calls <- base::sys.calls
  [22:14:08.905]             `[[` <- base::`[[`
  [22:14:08.905]             `+` <- base::`+`
  [22:14:08.905]             `<<-` <- base::`<<-`
  [22:14:08.905]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.905]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.905]                   3L)]
  [22:14:08.905]             }
  [22:14:08.905]             function(cond) {
  [22:14:08.905]                 if (inherits(cond, "error")) {
  [22:14:08.905]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.905]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.905]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.905]                     signaled = 0L)
  [22:14:08.905]                   signalCondition(cond)
  [22:14:08.905]                 }
  [22:14:08.905]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.905]                 ))) {
  [22:14:08.905]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.905]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.905]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.905]                   if (inherits(cond, "message")) {
  [22:14:08.905]                     if (!signal) 
  [22:14:08.905]                       invokeRestart("muffleMessage")
  [22:14:08.905]                   }
  [22:14:08.905]                   else if (inherits(cond, "warning")) {
  [22:14:08.905]                     if (!signal) 
  [22:14:08.905]                       invokeRestart("muffleWarning")
  [22:14:08.905]                   }
  [22:14:08.905]                   else {
  [22:14:08.905]                     if (!signal) {
  [22:14:08.905]                       restarts <- computeRestarts(cond)
  [22:14:08.905]                       for (restart in restarts) {
  [22:14:08.905]                         name <- restart$name
  [22:14:08.905]                         if (is.null(name)) 
  [22:14:08.905]                           next
  [22:14:08.905]                         if (!grepl("^muffle", name)) 
  [22:14:08.905]                           next
  [22:14:08.905]                         invokeRestart(restart)
  [22:14:08.905]                         break
  [22:14:08.905]                       }
  [22:14:08.905]                     }
  [22:14:08.905]                   }
  [22:14:08.905]                 }
  [22:14:08.905]             }
  [22:14:08.905]         }))
  [22:14:08.905]     }, error = function(ex) {
  [22:14:08.905]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.905]             version = "1.8"), class = "FutureResult")
  [22:14:08.905]     }, finally = {
  [22:14:08.905]         {
  [22:14:08.905]             NULL
  [22:14:08.905]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.905]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.905]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:08.905]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:08.905]             {
  [22:14:08.905]                 if (substitute) 
  [22:14:08.905]                   expr <- substitute(expr)
  [22:14:08.905]                 if (is.function(workers)) 
  [22:14:08.905]                   workers <- workers()
  [22:14:08.905]                 workers <- as.integer(workers)
  [22:14:08.905]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:08.905]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:08.905]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:08.905]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:08.905]                     local = TRUE, label = label, ...))
  [22:14:08.905]                 }
  [22:14:08.905]                 oopts <- options(mc.cores = workers)
  [22:14:08.905]                 on.exit(options(oopts))
  [22:14:08.905]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:08.905]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.905]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:08.905]                   label = label, ...)
  [22:14:08.905]                 if (!future$lazy) 
  [22:14:08.905]                   future <- run(future)
  [22:14:08.905]                 invisible(future)
  [22:14:08.905]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.905]         }
  [22:14:08.905]         options(...future.oldOptions)
  [22:14:08.905]     })
  [22:14:08.905]     if (is.na(TRUE)) {
  [22:14:08.905]     }
  [22:14:08.905]     else {
  [22:14:08.905]         sink(type = "output", split = FALSE)
  [22:14:08.905]         if (TRUE) {
  [22:14:08.905]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.905]         }
  [22:14:08.905]         else {
  [22:14:08.905]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.905]         }
  [22:14:08.905]         close(...future.stdout)
  [22:14:08.905]         ...future.stdout <- NULL
  [22:14:08.905]     }
  [22:14:08.905]     ...future.result$conditions <- ...future.conditions
  [22:14:08.905]     ...future.result
  [22:14:08.905] }
  [22:14:08.908] plan(): Setting new future strategy stack:
  [22:14:08.909] List of future strategies:
  [22:14:08.909] 1. sequential:
  [22:14:08.909]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.909]    - tweaked: FALSE
  [22:14:08.909]    - call: NULL
  [22:14:08.910] plan(): nbrOfWorkers() = 1
  [22:14:08.910] plan(): Setting new future strategy stack:
  [22:14:08.911] List of future strategies:
  [22:14:08.911] 1. multicore:
  [22:14:08.911]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:08.911]    - tweaked: FALSE
  [22:14:08.911]    - call: plan(strategy)
  [22:14:08.912] plan(): nbrOfWorkers() = 1
  [22:14:08.913] SequentialFuture started (and completed)
  [22:14:08.913] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1a945e8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:08.920] futureCall() ...
  [22:14:08.921] Globals to be used in the future:
  [22:14:08.921] List of 3
  [22:14:08.921]  $ a   : num 3
  [22:14:08.921]  $ FUN :function (x, y)  
  [22:14:08.921]  $ args:List of 2
  [22:14:08.921]   ..$ x: num 42
  [22:14:08.921]   ..$ y: num 12
  [22:14:08.921]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.921]  - attr(*, "where")=List of 3
  [22:14:08.921]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:08.921]   ..$ FUN :<environment: 0x29fab90> 
  [22:14:08.921]   ..$ args:<environment: 0x29d9938> 
  [22:14:08.921]  - attr(*, "resolved")= logi FALSE
  [22:14:08.921]  - attr(*, "total_size")= num NA
  [22:14:08.933] getGlobalsAndPackages() ...
  [22:14:08.934] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.934] Resolving globals: FALSE
  [22:14:08.935] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.936] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.936] 
  [22:14:08.936] getGlobalsAndPackages() ... DONE
  [22:14:08.938] Packages needed by the future expression (n = 0): <none>
  [22:14:08.938] Packages needed by future strategies (n = 0): <none>
  [22:14:08.944] {
  [22:14:08.944]     {
  [22:14:08.944]         ...future.startTime <- Sys.time()
  [22:14:08.944]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.944]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.944]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.944]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.944]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.944]         {
  [22:14:08.944]             {
  [22:14:08.944]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.944]                 version <- if (has_future) 
  [22:14:08.944]                   packageVersion("future")
  [22:14:08.944]                 else NULL
  [22:14:08.944]                 if (!has_future || version < "1.8.0") {
  [22:14:08.944]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.944]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.944]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.944]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.944]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.944]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.944]                   info <- paste(info, collapse = "; ")
  [22:14:08.944]                   if (!has_future) {
  [22:14:08.944]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.944]                       info)
  [22:14:08.944]                   }
  [22:14:08.944]                   else {
  [22:14:08.944]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.944]                       info, version)
  [22:14:08.944]                   }
  [22:14:08.944]                   stop(msg)
  [22:14:08.944]                 }
  [22:14:08.944]             }
  [22:14:08.944]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.944]         }
  [22:14:08.944]     }
  [22:14:08.944]     if (is.na(TRUE)) {
  [22:14:08.944]     }
  [22:14:08.944]     else {
  [22:14:08.944]         if (TRUE) {
  [22:14:08.944]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.944]         }
  [22:14:08.944]         else {
  [22:14:08.944]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.944]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.944]         }
  [22:14:08.944]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.944]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.944]             sink(type = "output", split = FALSE)
  [22:14:08.944]             close(...future.stdout)
  [22:14:08.944]         }, add = TRUE)
  [22:14:08.944]     }
  [22:14:08.944]     ...future.frame <- sys.nframe()
  [22:14:08.944]     ...future.conditions <- list()
  [22:14:08.944]     ...future.result <- tryCatch({
  [22:14:08.944]         withCallingHandlers({
  [22:14:08.944]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.944]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.944]                 version = "1.8")
  [22:14:08.944]         }, condition = local({
  [22:14:08.944]             inherits <- base::inherits
  [22:14:08.944]             invokeRestart <- base::invokeRestart
  [22:14:08.944]             length <- base::length
  [22:14:08.944]             seq.int <- base::seq.int
  [22:14:08.944]             sys.calls <- base::sys.calls
  [22:14:08.944]             `[[` <- base::`[[`
  [22:14:08.944]             `+` <- base::`+`
  [22:14:08.944]             `<<-` <- base::`<<-`
  [22:14:08.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.944]                   3L)]
  [22:14:08.944]             }
  [22:14:08.944]             function(cond) {
  [22:14:08.944]                 if (inherits(cond, "error")) {
  [22:14:08.944]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.944]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.944]                     signaled = 0L)
  [22:14:08.944]                   signalCondition(cond)
  [22:14:08.944]                 }
  [22:14:08.944]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.944]                 ))) {
  [22:14:08.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.944]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.944]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.944]                   if (inherits(cond, "message")) {
  [22:14:08.944]                     if (!signal) 
  [22:14:08.944]                       invokeRestart("muffleMessage")
  [22:14:08.944]                   }
  [22:14:08.944]                   else if (inherits(cond, "warning")) {
  [22:14:08.944]                     if (!signal) 
  [22:14:08.944]                       invokeRestart("muffleWarning")
  [22:14:08.944]                   }
  [22:14:08.944]                   else {
  [22:14:08.944]                     if (!signal) {
  [22:14:08.944]                       restarts <- computeRestarts(cond)
  [22:14:08.944]                       for (restart in restarts) {
  [22:14:08.944]                         name <- restart$name
  [22:14:08.944]                         if (is.null(name)) 
  [22:14:08.944]                           next
  [22:14:08.944]                         if (!grepl("^muffle", name)) 
  [22:14:08.944]                           next
  [22:14:08.944]                         invokeRestart(restart)
  [22:14:08.944]                         break
  [22:14:08.944]                       }
  [22:14:08.944]                     }
  [22:14:08.944]                   }
  [22:14:08.944]                 }
  [22:14:08.944]             }
  [22:14:08.944]         }))
  [22:14:08.944]     }, error = function(ex) {
  [22:14:08.944]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.944]             version = "1.8"), class = "FutureResult")
  [22:14:08.944]     }, finally = {
  [22:14:08.944]         {
  [22:14:08.944]             NULL
  [22:14:08.944]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.944]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.944]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:08.944]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:08.944]             {
  [22:14:08.944]                 if (substitute) 
  [22:14:08.944]                   expr <- substitute(expr)
  [22:14:08.944]                 if (is.function(workers)) 
  [22:14:08.944]                   workers <- workers()
  [22:14:08.944]                 workers <- as.integer(workers)
  [22:14:08.944]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:08.944]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:08.944]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:08.944]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:08.944]                     local = TRUE, label = label, ...))
  [22:14:08.944]                 }
  [22:14:08.944]                 oopts <- options(mc.cores = workers)
  [22:14:08.944]                 on.exit(options(oopts))
  [22:14:08.944]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:08.944]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.944]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:08.944]                   label = label, ...)
  [22:14:08.944]                 if (!future$lazy) 
  [22:14:08.944]                   future <- run(future)
  [22:14:08.944]                 invisible(future)
  [22:14:08.944]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.944]         }
  [22:14:08.944]         options(...future.oldOptions)
  [22:14:08.944]     })
  [22:14:08.944]     if (is.na(TRUE)) {
  [22:14:08.944]     }
  [22:14:08.944]     else {
  [22:14:08.944]         sink(type = "output", split = FALSE)
  [22:14:08.944]         if (TRUE) {
  [22:14:08.944]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.944]         }
  [22:14:08.944]         else {
  [22:14:08.944]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.944]         }
  [22:14:08.944]         close(...future.stdout)
  [22:14:08.944]         ...future.stdout <- NULL
  [22:14:08.944]     }
  [22:14:08.944]     ...future.result$conditions <- ...future.conditions
  [22:14:08.944]     ...future.result
  [22:14:08.944] }
  [22:14:08.948] plan(): Setting new future strategy stack:
  [22:14:08.948] List of future strategies:
  [22:14:08.948] 1. sequential:
  [22:14:08.948]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.948]    - tweaked: FALSE
  [22:14:08.948]    - call: NULL
  [22:14:08.949] plan(): nbrOfWorkers() = 1
  [22:14:08.950] plan(): Setting new future strategy stack:
  [22:14:08.950] List of future strategies:
  [22:14:08.950] 1. multicore:
  [22:14:08.950]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:08.950]    - tweaked: FALSE
  [22:14:08.950]    - call: plan(strategy)
  [22:14:08.952] plan(): nbrOfWorkers() = 1
  [22:14:08.956] SequentialFuture started (and completed)
  [22:14:08.956] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x29d9938>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:08.964] futureCall() ...
  [22:14:08.965] Globals to be used in the future:
  [22:14:08.965] List of 3
  [22:14:08.965]  $ a   : num 3
  [22:14:08.965]  $ FUN :function (x, y)  
  [22:14:08.965]  $ args:List of 2
  [22:14:08.965]   ..$ x: num 42
  [22:14:08.965]   ..$ y: num 12
  [22:14:08.965]  - attr(*, "where")=List of 3
  [22:14:08.965]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:08.965]   ..$ FUN :<environment: 0x11f5f40> 
  [22:14:08.965]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:08.965]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:08.965]  - attr(*, "resolved")= logi FALSE
  [22:14:08.965]  - attr(*, "total_size")= num NA
  [22:14:08.977] getGlobalsAndPackages() ...
  [22:14:08.978] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:08.978] Resolving globals: FALSE
  [22:14:08.979] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:08.980] - globals: [3] 'a', 'FUN', 'args'
  [22:14:08.980] 
  [22:14:08.980] getGlobalsAndPackages() ... DONE
  [22:14:08.982] Packages needed by the future expression (n = 0): <none>
  [22:14:08.982] Packages needed by future strategies (n = 0): <none>
  [22:14:08.987] {
  [22:14:08.987]     {
  [22:14:08.987]         ...future.startTime <- Sys.time()
  [22:14:08.987]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:08.987]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:08.987]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:08.987]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:08.987]             future.resolve.recursive = NULL, width = 80L)
  [22:14:08.987]         {
  [22:14:08.987]             {
  [22:14:08.987]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:08.987]                 version <- if (has_future) 
  [22:14:08.987]                   packageVersion("future")
  [22:14:08.987]                 else NULL
  [22:14:08.987]                 if (!has_future || version < "1.8.0") {
  [22:14:08.987]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:08.987]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:08.987]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:08.987]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:08.987]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:08.987]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:08.987]                   info <- paste(info, collapse = "; ")
  [22:14:08.987]                   if (!has_future) {
  [22:14:08.987]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:08.987]                       info)
  [22:14:08.987]                   }
  [22:14:08.987]                   else {
  [22:14:08.987]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:08.987]                       info, version)
  [22:14:08.987]                   }
  [22:14:08.987]                   stop(msg)
  [22:14:08.987]                 }
  [22:14:08.987]             }
  [22:14:08.987]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:08.987]         }
  [22:14:08.987]     }
  [22:14:08.987]     if (is.na(TRUE)) {
  [22:14:08.987]     }
  [22:14:08.987]     else {
  [22:14:08.987]         if (TRUE) {
  [22:14:08.987]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:08.987]         }
  [22:14:08.987]         else {
  [22:14:08.987]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:08.987]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:08.987]         }
  [22:14:08.987]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:08.987]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:08.987]             sink(type = "output", split = FALSE)
  [22:14:08.987]             close(...future.stdout)
  [22:14:08.987]         }, add = TRUE)
  [22:14:08.987]     }
  [22:14:08.987]     ...future.frame <- sys.nframe()
  [22:14:08.987]     ...future.conditions <- list()
  [22:14:08.987]     ...future.result <- tryCatch({
  [22:14:08.987]         withCallingHandlers({
  [22:14:08.987]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:08.987]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:08.987]                 version = "1.8")
  [22:14:08.987]         }, condition = local({
  [22:14:08.987]             inherits <- base::inherits
  [22:14:08.987]             invokeRestart <- base::invokeRestart
  [22:14:08.987]             length <- base::length
  [22:14:08.987]             seq.int <- base::seq.int
  [22:14:08.987]             sys.calls <- base::sys.calls
  [22:14:08.987]             `[[` <- base::`[[`
  [22:14:08.987]             `+` <- base::`+`
  [22:14:08.987]             `<<-` <- base::`<<-`
  [22:14:08.987]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:08.987]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:08.987]                   3L)]
  [22:14:08.987]             }
  [22:14:08.987]             function(cond) {
  [22:14:08.987]                 if (inherits(cond, "error")) {
  [22:14:08.987]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.987]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:08.987]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:08.987]                     signaled = 0L)
  [22:14:08.987]                   signalCondition(cond)
  [22:14:08.987]                 }
  [22:14:08.987]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:08.987]                 ))) {
  [22:14:08.987]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:08.987]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:08.987]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:08.987]                   if (inherits(cond, "message")) {
  [22:14:08.987]                     if (!signal) 
  [22:14:08.987]                       invokeRestart("muffleMessage")
  [22:14:08.987]                   }
  [22:14:08.987]                   else if (inherits(cond, "warning")) {
  [22:14:08.987]                     if (!signal) 
  [22:14:08.987]                       invokeRestart("muffleWarning")
  [22:14:08.987]                   }
  [22:14:08.987]                   else {
  [22:14:08.987]                     if (!signal) {
  [22:14:08.987]                       restarts <- computeRestarts(cond)
  [22:14:08.987]                       for (restart in restarts) {
  [22:14:08.987]                         name <- restart$name
  [22:14:08.987]                         if (is.null(name)) 
  [22:14:08.987]                           next
  [22:14:08.987]                         if (!grepl("^muffle", name)) 
  [22:14:08.987]                           next
  [22:14:08.987]                         invokeRestart(restart)
  [22:14:08.987]                         break
  [22:14:08.987]                       }
  [22:14:08.987]                     }
  [22:14:08.987]                   }
  [22:14:08.987]                 }
  [22:14:08.987]             }
  [22:14:08.987]         }))
  [22:14:08.987]     }, error = function(ex) {
  [22:14:08.987]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:08.987]             version = "1.8"), class = "FutureResult")
  [22:14:08.987]     }, finally = {
  [22:14:08.987]         {
  [22:14:08.987]             NULL
  [22:14:08.987]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:08.987]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:08.987]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:08.987]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:08.987]             {
  [22:14:08.987]                 if (substitute) 
  [22:14:08.987]                   expr <- substitute(expr)
  [22:14:08.987]                 if (is.function(workers)) 
  [22:14:08.987]                   workers <- workers()
  [22:14:08.987]                 workers <- as.integer(workers)
  [22:14:08.987]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:08.987]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:08.987]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:08.987]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:08.987]                     local = TRUE, label = label, ...))
  [22:14:08.987]                 }
  [22:14:08.987]                 oopts <- options(mc.cores = workers)
  [22:14:08.987]                 on.exit(options(oopts))
  [22:14:08.987]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:08.987]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:08.987]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:08.987]                   label = label, ...)
  [22:14:08.987]                 if (!future$lazy) 
  [22:14:08.987]                   future <- run(future)
  [22:14:08.987]                 invisible(future)
  [22:14:08.987]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:08.987]         }
  [22:14:08.987]         options(...future.oldOptions)
  [22:14:08.987]     })
  [22:14:08.987]     if (is.na(TRUE)) {
  [22:14:08.987]     }
  [22:14:08.987]     else {
  [22:14:08.987]         sink(type = "output", split = FALSE)
  [22:14:08.987]         if (TRUE) {
  [22:14:08.987]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:08.987]         }
  [22:14:08.987]         else {
  [22:14:08.987]             ...future.result["stdout"] <- list(NULL)
  [22:14:08.987]         }
  [22:14:08.987]         close(...future.stdout)
  [22:14:08.987]         ...future.stdout <- NULL
  [22:14:08.987]     }
  [22:14:08.987]     ...future.result$conditions <- ...future.conditions
  [22:14:08.987]     ...future.result
  [22:14:08.987] }
  [22:14:08.991] plan(): Setting new future strategy stack:
  [22:14:08.991] List of future strategies:
  [22:14:08.991] 1. sequential:
  [22:14:08.991]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:08.991]    - tweaked: FALSE
  [22:14:08.991]    - call: NULL
  [22:14:08.992] plan(): nbrOfWorkers() = 1
  [22:14:08.993] plan(): Setting new future strategy stack:
  [22:14:08.993] List of future strategies:
  [22:14:08.993] 1. multicore:
  [22:14:08.993]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:08.993]    - tweaked: FALSE
  [22:14:08.993]    - call: plan(strategy)
  [22:14:08.994] plan(): nbrOfWorkers() = 1
  [22:14:08.995] SequentialFuture started (and completed)
  [22:14:08.995] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0xb8f048>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:09.002] futureCall() ...
  [22:14:09.003] Finding globals ...
  [22:14:09.003] getGlobalsAndPackages() ...
  [22:14:09.003] Searching for globals...
  [22:14:09.008] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:09.008] Searching for globals ... DONE
  [22:14:09.009] Resolving globals: FALSE
  [22:14:09.010] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:09.011] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.011] 
  [22:14:09.011] getGlobalsAndPackages() ... DONE
  [22:14:09.011]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:09.012] 
  [22:14:09.012] Finding globals ... DONE
  [22:14:09.012] Globals to be used in the future:
  [22:14:09.013] List of 3
  [22:14:09.013]  $ FUN :function (x, y)  
  [22:14:09.013]  $ args:List of 2
  [22:14:09.013]   ..$ x: num 42
  [22:14:09.013]   ..$ y: num 12
  [22:14:09.013]  $ a   : num 3
  [22:14:09.013]  - attr(*, "where")=List of 3
  [22:14:09.013]   ..$ FUN :<environment: 0x2dc9c10> 
  [22:14:09.013]   ..$ args:<environment: 0x2bbc6a0> 
  [22:14:09.013]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.013]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.013]  - attr(*, "resolved")= logi FALSE
  [22:14:09.013]  - attr(*, "total_size")= num 2592
  [22:14:09.031] getGlobalsAndPackages() ...
  [22:14:09.031] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:09.032] Resolving globals: FALSE
  [22:14:09.033] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.033] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.034] 
  [22:14:09.034] getGlobalsAndPackages() ... DONE
  [22:14:09.035] Packages needed by the future expression (n = 0): <none>
  [22:14:09.036] Packages needed by future strategies (n = 0): <none>
  [22:14:09.040] {
  [22:14:09.040]     {
  [22:14:09.040]         ...future.startTime <- Sys.time()
  [22:14:09.040]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.040]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.040]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.040]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.040]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.040]         {
  [22:14:09.040]             {
  [22:14:09.040]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.040]                 version <- if (has_future) 
  [22:14:09.040]                   packageVersion("future")
  [22:14:09.040]                 else NULL
  [22:14:09.040]                 if (!has_future || version < "1.8.0") {
  [22:14:09.040]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.040]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.040]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.040]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.040]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.040]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.040]                   info <- paste(info, collapse = "; ")
  [22:14:09.040]                   if (!has_future) {
  [22:14:09.040]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.040]                       info)
  [22:14:09.040]                   }
  [22:14:09.040]                   else {
  [22:14:09.040]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.040]                       info, version)
  [22:14:09.040]                   }
  [22:14:09.040]                   stop(msg)
  [22:14:09.040]                 }
  [22:14:09.040]             }
  [22:14:09.040]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.040]         }
  [22:14:09.040]     }
  [22:14:09.040]     if (is.na(TRUE)) {
  [22:14:09.040]     }
  [22:14:09.040]     else {
  [22:14:09.040]         if (TRUE) {
  [22:14:09.040]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.040]         }
  [22:14:09.040]         else {
  [22:14:09.040]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.040]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.040]         }
  [22:14:09.040]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.040]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.040]             sink(type = "output", split = FALSE)
  [22:14:09.040]             close(...future.stdout)
  [22:14:09.040]         }, add = TRUE)
  [22:14:09.040]     }
  [22:14:09.040]     ...future.frame <- sys.nframe()
  [22:14:09.040]     ...future.conditions <- list()
  [22:14:09.040]     ...future.result <- tryCatch({
  [22:14:09.040]         withCallingHandlers({
  [22:14:09.040]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.040]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.040]                 version = "1.8")
  [22:14:09.040]         }, condition = local({
  [22:14:09.040]             inherits <- base::inherits
  [22:14:09.040]             invokeRestart <- base::invokeRestart
  [22:14:09.040]             length <- base::length
  [22:14:09.040]             seq.int <- base::seq.int
  [22:14:09.040]             sys.calls <- base::sys.calls
  [22:14:09.040]             `[[` <- base::`[[`
  [22:14:09.040]             `+` <- base::`+`
  [22:14:09.040]             `<<-` <- base::`<<-`
  [22:14:09.040]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.040]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.040]                   3L)]
  [22:14:09.040]             }
  [22:14:09.040]             function(cond) {
  [22:14:09.040]                 if (inherits(cond, "error")) {
  [22:14:09.040]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.040]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.040]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.040]                     signaled = 0L)
  [22:14:09.040]                   signalCondition(cond)
  [22:14:09.040]                 }
  [22:14:09.040]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.040]                 ))) {
  [22:14:09.040]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.040]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.040]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.040]                   if (inherits(cond, "message")) {
  [22:14:09.040]                     if (!signal) 
  [22:14:09.040]                       invokeRestart("muffleMessage")
  [22:14:09.040]                   }
  [22:14:09.040]                   else if (inherits(cond, "warning")) {
  [22:14:09.040]                     if (!signal) 
  [22:14:09.040]                       invokeRestart("muffleWarning")
  [22:14:09.040]                   }
  [22:14:09.040]                   else {
  [22:14:09.040]                     if (!signal) {
  [22:14:09.040]                       restarts <- computeRestarts(cond)
  [22:14:09.040]                       for (restart in restarts) {
  [22:14:09.040]                         name <- restart$name
  [22:14:09.040]                         if (is.null(name)) 
  [22:14:09.040]                           next
  [22:14:09.040]                         if (!grepl("^muffle", name)) 
  [22:14:09.040]                           next
  [22:14:09.040]                         invokeRestart(restart)
  [22:14:09.040]                         break
  [22:14:09.040]                       }
  [22:14:09.040]                     }
  [22:14:09.040]                   }
  [22:14:09.040]                 }
  [22:14:09.040]             }
  [22:14:09.040]         }))
  [22:14:09.040]     }, error = function(ex) {
  [22:14:09.040]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.040]             version = "1.8"), class = "FutureResult")
  [22:14:09.040]     }, finally = {
  [22:14:09.040]         {
  [22:14:09.040]             NULL
  [22:14:09.040]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.040]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.040]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.040]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.040]             {
  [22:14:09.040]                 if (substitute) 
  [22:14:09.040]                   expr <- substitute(expr)
  [22:14:09.040]                 if (is.function(workers)) 
  [22:14:09.040]                   workers <- workers()
  [22:14:09.040]                 workers <- as.integer(workers)
  [22:14:09.040]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.040]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.040]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.040]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.040]                     local = TRUE, label = label, ...))
  [22:14:09.040]                 }
  [22:14:09.040]                 oopts <- options(mc.cores = workers)
  [22:14:09.040]                 on.exit(options(oopts))
  [22:14:09.040]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.040]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.040]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.040]                   label = label, ...)
  [22:14:09.040]                 if (!future$lazy) 
  [22:14:09.040]                   future <- run(future)
  [22:14:09.040]                 invisible(future)
  [22:14:09.040]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.040]         }
  [22:14:09.040]         options(...future.oldOptions)
  [22:14:09.040]     })
  [22:14:09.040]     if (is.na(TRUE)) {
  [22:14:09.040]     }
  [22:14:09.040]     else {
  [22:14:09.040]         sink(type = "output", split = FALSE)
  [22:14:09.040]         if (TRUE) {
  [22:14:09.040]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.040]         }
  [22:14:09.040]         else {
  [22:14:09.040]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.040]         }
  [22:14:09.040]         close(...future.stdout)
  [22:14:09.040]         ...future.stdout <- NULL
  [22:14:09.040]     }
  [22:14:09.040]     ...future.result$conditions <- ...future.conditions
  [22:14:09.040]     ...future.result
  [22:14:09.040] }
  [22:14:09.043] plan(): Setting new future strategy stack:
  [22:14:09.043] List of future strategies:
  [22:14:09.043] 1. sequential:
  [22:14:09.043]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.043]    - tweaked: FALSE
  [22:14:09.043]    - call: NULL
  [22:14:09.044] plan(): nbrOfWorkers() = 1
  [22:14:09.045] plan(): Setting new future strategy stack:
  [22:14:09.046] List of future strategies:
  [22:14:09.046] 1. multicore:
  [22:14:09.046]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.046]    - tweaked: FALSE
  [22:14:09.046]    - call: plan(strategy)
  [22:14:09.047] plan(): nbrOfWorkers() = 1
  [22:14:09.048] SequentialFuture started (and completed)
  [22:14:09.048] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2bbc6a0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:09.056] futureCall() ...
  [22:14:09.057] Globals to be used in the future:
  [22:14:09.057] List of 3
  [22:14:09.057]  $ a   : num 3
  [22:14:09.057]  $ FUN :function (x, y)  
  [22:14:09.057]  $ args:List of 2
  [22:14:09.057]   ..$ x: num 42
  [22:14:09.057]   ..$ y: num 12
  [22:14:09.057]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.057]  - attr(*, "where")=List of 3
  [22:14:09.057]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.057]   ..$ FUN :<environment: 0x1f4cc98> 
  [22:14:09.057]   ..$ args:<environment: 0x18e9e68> 
  [22:14:09.057]  - attr(*, "resolved")= logi FALSE
  [22:14:09.057]  - attr(*, "total_size")= num NA
  [22:14:09.070] getGlobalsAndPackages() ...
  [22:14:09.070] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.071] Resolving globals: FALSE
  [22:14:09.072] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.072] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.073] 
  [22:14:09.073] getGlobalsAndPackages() ... DONE
  [22:14:09.074] Packages needed by the future expression (n = 0): <none>
  [22:14:09.075] Packages needed by future strategies (n = 0): <none>
  [22:14:09.079] {
  [22:14:09.079]     {
  [22:14:09.079]         ...future.startTime <- Sys.time()
  [22:14:09.079]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.079]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.079]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.079]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.079]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.079]         {
  [22:14:09.079]             {
  [22:14:09.079]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.079]                 version <- if (has_future) 
  [22:14:09.079]                   packageVersion("future")
  [22:14:09.079]                 else NULL
  [22:14:09.079]                 if (!has_future || version < "1.8.0") {
  [22:14:09.079]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.079]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.079]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.079]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.079]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.079]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.079]                   info <- paste(info, collapse = "; ")
  [22:14:09.079]                   if (!has_future) {
  [22:14:09.079]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.079]                       info)
  [22:14:09.079]                   }
  [22:14:09.079]                   else {
  [22:14:09.079]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.079]                       info, version)
  [22:14:09.079]                   }
  [22:14:09.079]                   stop(msg)
  [22:14:09.079]                 }
  [22:14:09.079]             }
  [22:14:09.079]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.079]         }
  [22:14:09.079]     }
  [22:14:09.079]     if (is.na(TRUE)) {
  [22:14:09.079]     }
  [22:14:09.079]     else {
  [22:14:09.079]         if (TRUE) {
  [22:14:09.079]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.079]         }
  [22:14:09.079]         else {
  [22:14:09.079]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.079]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.079]         }
  [22:14:09.079]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.079]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.079]             sink(type = "output", split = FALSE)
  [22:14:09.079]             close(...future.stdout)
  [22:14:09.079]         }, add = TRUE)
  [22:14:09.079]     }
  [22:14:09.079]     ...future.frame <- sys.nframe()
  [22:14:09.079]     ...future.conditions <- list()
  [22:14:09.079]     ...future.result <- tryCatch({
  [22:14:09.079]         withCallingHandlers({
  [22:14:09.079]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.079]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.079]                 version = "1.8")
  [22:14:09.079]         }, condition = local({
  [22:14:09.079]             inherits <- base::inherits
  [22:14:09.079]             invokeRestart <- base::invokeRestart
  [22:14:09.079]             length <- base::length
  [22:14:09.079]             seq.int <- base::seq.int
  [22:14:09.079]             sys.calls <- base::sys.calls
  [22:14:09.079]             `[[` <- base::`[[`
  [22:14:09.079]             `+` <- base::`+`
  [22:14:09.079]             `<<-` <- base::`<<-`
  [22:14:09.079]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.079]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.079]                   3L)]
  [22:14:09.079]             }
  [22:14:09.079]             function(cond) {
  [22:14:09.079]                 if (inherits(cond, "error")) {
  [22:14:09.079]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.079]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.079]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.079]                     signaled = 0L)
  [22:14:09.079]                   signalCondition(cond)
  [22:14:09.079]                 }
  [22:14:09.079]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.079]                 ))) {
  [22:14:09.079]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.079]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.079]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.079]                   if (inherits(cond, "message")) {
  [22:14:09.079]                     if (!signal) 
  [22:14:09.079]                       invokeRestart("muffleMessage")
  [22:14:09.079]                   }
  [22:14:09.079]                   else if (inherits(cond, "warning")) {
  [22:14:09.079]                     if (!signal) 
  [22:14:09.079]                       invokeRestart("muffleWarning")
  [22:14:09.079]                   }
  [22:14:09.079]                   else {
  [22:14:09.079]                     if (!signal) {
  [22:14:09.079]                       restarts <- computeRestarts(cond)
  [22:14:09.079]                       for (restart in restarts) {
  [22:14:09.079]                         name <- restart$name
  [22:14:09.079]                         if (is.null(name)) 
  [22:14:09.079]                           next
  [22:14:09.079]                         if (!grepl("^muffle", name)) 
  [22:14:09.079]                           next
  [22:14:09.079]                         invokeRestart(restart)
  [22:14:09.079]                         break
  [22:14:09.079]                       }
  [22:14:09.079]                     }
  [22:14:09.079]                   }
  [22:14:09.079]                 }
  [22:14:09.079]             }
  [22:14:09.079]         }))
  [22:14:09.079]     }, error = function(ex) {
  [22:14:09.079]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.079]             version = "1.8"), class = "FutureResult")
  [22:14:09.079]     }, finally = {
  [22:14:09.079]         {
  [22:14:09.079]             NULL
  [22:14:09.079]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.079]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.079]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.079]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.079]             {
  [22:14:09.079]                 if (substitute) 
  [22:14:09.079]                   expr <- substitute(expr)
  [22:14:09.079]                 if (is.function(workers)) 
  [22:14:09.079]                   workers <- workers()
  [22:14:09.079]                 workers <- as.integer(workers)
  [22:14:09.079]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.079]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.079]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.079]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.079]                     local = TRUE, label = label, ...))
  [22:14:09.079]                 }
  [22:14:09.079]                 oopts <- options(mc.cores = workers)
  [22:14:09.079]                 on.exit(options(oopts))
  [22:14:09.079]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.079]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.079]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.079]                   label = label, ...)
  [22:14:09.079]                 if (!future$lazy) 
  [22:14:09.079]                   future <- run(future)
  [22:14:09.079]                 invisible(future)
  [22:14:09.079]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.079]         }
  [22:14:09.079]         options(...future.oldOptions)
  [22:14:09.079]     })
  [22:14:09.079]     if (is.na(TRUE)) {
  [22:14:09.079]     }
  [22:14:09.079]     else {
  [22:14:09.079]         sink(type = "output", split = FALSE)
  [22:14:09.079]         if (TRUE) {
  [22:14:09.079]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.079]         }
  [22:14:09.079]         else {
  [22:14:09.079]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.079]         }
  [22:14:09.079]         close(...future.stdout)
  [22:14:09.079]         ...future.stdout <- NULL
  [22:14:09.079]     }
  [22:14:09.079]     ...future.result$conditions <- ...future.conditions
  [22:14:09.079]     ...future.result
  [22:14:09.079] }
  [22:14:09.082] plan(): Setting new future strategy stack:
  [22:14:09.082] List of future strategies:
  [22:14:09.082] 1. sequential:
  [22:14:09.082]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.082]    - tweaked: FALSE
  [22:14:09.082]    - call: NULL
  [22:14:09.083] plan(): nbrOfWorkers() = 1
  [22:14:09.084] plan(): Setting new future strategy stack:
  [22:14:09.085] List of future strategies:
  [22:14:09.085] 1. multicore:
  [22:14:09.085]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.085]    - tweaked: FALSE
  [22:14:09.085]    - call: plan(strategy)
  [22:14:09.086] plan(): nbrOfWorkers() = 1
  [22:14:09.087] SequentialFuture started (and completed)
  [22:14:09.087] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x18e9e68>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.094] futureCall() ...
  [22:14:09.095] Globals to be used in the future:
  [22:14:09.095] List of 3
  [22:14:09.095]  $ a   : num 3
  [22:14:09.095]  $ FUN :function (x, y)  
  [22:14:09.095]  $ args:List of 2
  [22:14:09.095]   ..$ x: num 42
  [22:14:09.095]   ..$ y: num 12
  [22:14:09.095]  - attr(*, "where")=List of 3
  [22:14:09.095]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.095]   ..$ FUN :<environment: 0x3217e10> 
  [22:14:09.095]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.095]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.095]  - attr(*, "resolved")= logi FALSE
  [22:14:09.095]  - attr(*, "total_size")= num NA
  [22:14:09.112] getGlobalsAndPackages() ...
  [22:14:09.113] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.113] Resolving globals: FALSE
  [22:14:09.114] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.114] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.115] 
  [22:14:09.115] getGlobalsAndPackages() ... DONE
  [22:14:09.117] Packages needed by the future expression (n = 0): <none>
  [22:14:09.117] Packages needed by future strategies (n = 0): <none>
  [22:14:09.121] {
  [22:14:09.121]     {
  [22:14:09.121]         ...future.startTime <- Sys.time()
  [22:14:09.121]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.121]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.121]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.121]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.121]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.121]         {
  [22:14:09.121]             {
  [22:14:09.121]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.121]                 version <- if (has_future) 
  [22:14:09.121]                   packageVersion("future")
  [22:14:09.121]                 else NULL
  [22:14:09.121]                 if (!has_future || version < "1.8.0") {
  [22:14:09.121]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.121]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.121]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.121]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.121]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.121]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.121]                   info <- paste(info, collapse = "; ")
  [22:14:09.121]                   if (!has_future) {
  [22:14:09.121]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.121]                       info)
  [22:14:09.121]                   }
  [22:14:09.121]                   else {
  [22:14:09.121]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.121]                       info, version)
  [22:14:09.121]                   }
  [22:14:09.121]                   stop(msg)
  [22:14:09.121]                 }
  [22:14:09.121]             }
  [22:14:09.121]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.121]         }
  [22:14:09.121]     }
  [22:14:09.121]     if (is.na(TRUE)) {
  [22:14:09.121]     }
  [22:14:09.121]     else {
  [22:14:09.121]         if (TRUE) {
  [22:14:09.121]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.121]         }
  [22:14:09.121]         else {
  [22:14:09.121]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.121]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.121]         }
  [22:14:09.121]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.121]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.121]             sink(type = "output", split = FALSE)
  [22:14:09.121]             close(...future.stdout)
  [22:14:09.121]         }, add = TRUE)
  [22:14:09.121]     }
  [22:14:09.121]     ...future.frame <- sys.nframe()
  [22:14:09.121]     ...future.conditions <- list()
  [22:14:09.121]     ...future.result <- tryCatch({
  [22:14:09.121]         withCallingHandlers({
  [22:14:09.121]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.121]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.121]                 version = "1.8")
  [22:14:09.121]         }, condition = local({
  [22:14:09.121]             inherits <- base::inherits
  [22:14:09.121]             invokeRestart <- base::invokeRestart
  [22:14:09.121]             length <- base::length
  [22:14:09.121]             seq.int <- base::seq.int
  [22:14:09.121]             sys.calls <- base::sys.calls
  [22:14:09.121]             `[[` <- base::`[[`
  [22:14:09.121]             `+` <- base::`+`
  [22:14:09.121]             `<<-` <- base::`<<-`
  [22:14:09.121]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.121]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.121]                   3L)]
  [22:14:09.121]             }
  [22:14:09.121]             function(cond) {
  [22:14:09.121]                 if (inherits(cond, "error")) {
  [22:14:09.121]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.121]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.121]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.121]                     signaled = 0L)
  [22:14:09.121]                   signalCondition(cond)
  [22:14:09.121]                 }
  [22:14:09.121]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.121]                 ))) {
  [22:14:09.121]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.121]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.121]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.121]                   if (inherits(cond, "message")) {
  [22:14:09.121]                     if (!signal) 
  [22:14:09.121]                       invokeRestart("muffleMessage")
  [22:14:09.121]                   }
  [22:14:09.121]                   else if (inherits(cond, "warning")) {
  [22:14:09.121]                     if (!signal) 
  [22:14:09.121]                       invokeRestart("muffleWarning")
  [22:14:09.121]                   }
  [22:14:09.121]                   else {
  [22:14:09.121]                     if (!signal) {
  [22:14:09.121]                       restarts <- computeRestarts(cond)
  [22:14:09.121]                       for (restart in restarts) {
  [22:14:09.121]                         name <- restart$name
  [22:14:09.121]                         if (is.null(name)) 
  [22:14:09.121]                           next
  [22:14:09.121]                         if (!grepl("^muffle", name)) 
  [22:14:09.121]                           next
  [22:14:09.121]                         invokeRestart(restart)
  [22:14:09.121]                         break
  [22:14:09.121]                       }
  [22:14:09.121]                     }
  [22:14:09.121]                   }
  [22:14:09.121]                 }
  [22:14:09.121]             }
  [22:14:09.121]         }))
  [22:14:09.121]     }, error = function(ex) {
  [22:14:09.121]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.121]             version = "1.8"), class = "FutureResult")
  [22:14:09.121]     }, finally = {
  [22:14:09.121]         {
  [22:14:09.121]             NULL
  [22:14:09.121]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.121]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.121]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.121]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.121]             {
  [22:14:09.121]                 if (substitute) 
  [22:14:09.121]                   expr <- substitute(expr)
  [22:14:09.121]                 if (is.function(workers)) 
  [22:14:09.121]                   workers <- workers()
  [22:14:09.121]                 workers <- as.integer(workers)
  [22:14:09.121]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.121]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.121]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.121]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.121]                     local = TRUE, label = label, ...))
  [22:14:09.121]                 }
  [22:14:09.121]                 oopts <- options(mc.cores = workers)
  [22:14:09.121]                 on.exit(options(oopts))
  [22:14:09.121]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.121]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.121]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.121]                   label = label, ...)
  [22:14:09.121]                 if (!future$lazy) 
  [22:14:09.121]                   future <- run(future)
  [22:14:09.121]                 invisible(future)
  [22:14:09.121]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.121]         }
  [22:14:09.121]         options(...future.oldOptions)
  [22:14:09.121]     })
  [22:14:09.121]     if (is.na(TRUE)) {
  [22:14:09.121]     }
  [22:14:09.121]     else {
  [22:14:09.121]         sink(type = "output", split = FALSE)
  [22:14:09.121]         if (TRUE) {
  [22:14:09.121]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.121]         }
  [22:14:09.121]         else {
  [22:14:09.121]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.121]         }
  [22:14:09.121]         close(...future.stdout)
  [22:14:09.121]         ...future.stdout <- NULL
  [22:14:09.121]     }
  [22:14:09.121]     ...future.result$conditions <- ...future.conditions
  [22:14:09.121]     ...future.result
  [22:14:09.121] }
  [22:14:09.125] plan(): Setting new future strategy stack:
  [22:14:09.125] List of future strategies:
  [22:14:09.125] 1. sequential:
  [22:14:09.125]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.125]    - tweaked: FALSE
  [22:14:09.125]    - call: NULL
  [22:14:09.126] plan(): nbrOfWorkers() = 1
  [22:14:09.127] plan(): Setting new future strategy stack:
  [22:14:09.127] List of future strategies:
  [22:14:09.127] 1. multicore:
  [22:14:09.127]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.127]    - tweaked: FALSE
  [22:14:09.127]    - call: plan(strategy)
  [22:14:09.129] plan(): nbrOfWorkers() = 1
  [22:14:09.129] SequentialFuture started (and completed)
  [22:14:09.130] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x31ffc50>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: 56 bytes of class 'numeric'
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:09.137] futureCall() ...
  [22:14:09.137] Globals to be used in the future:
  [22:14:09.138] List of 2
  [22:14:09.138]  $ FUN :function (x, y)  
  [22:14:09.138]  $ args:List of 2
  [22:14:09.138]   ..$ x: num 42
  [22:14:09.138]   ..$ y: num 12
  [22:14:09.138]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.138]  - attr(*, "where")=List of 2
  [22:14:09.138]   ..$ FUN :<environment: 0x28deb78> 
  [22:14:09.138]   ..$ args:<environment: 0x28deb78> 
  [22:14:09.138]  - attr(*, "resolved")= logi FALSE
  [22:14:09.138]  - attr(*, "total_size")= num NA
  [22:14:09.165] getGlobalsAndPackages() ...
  [22:14:09.165] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:09.165] Resolving globals: FALSE
  [22:14:09.166] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:09.167] - globals: [2] 'FUN', 'args'
  [22:14:09.167] 
  [22:14:09.167] getGlobalsAndPackages() ... DONE
  [22:14:09.168] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x28deb78>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.171] Packages needed by the future expression (n = 0): <none>
  [22:14:09.172] Packages needed by future strategies (n = 0): <none>
  [22:14:09.192] {
  [22:14:09.192]     {
  [22:14:09.192]         ...future.startTime <- Sys.time()
  [22:14:09.192]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.192]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.192]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.192]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.192]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.192]         {
  [22:14:09.192]             {
  [22:14:09.192]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.192]                 version <- if (has_future) 
  [22:14:09.192]                   packageVersion("future")
  [22:14:09.192]                 else NULL
  [22:14:09.192]                 if (!has_future || version < "1.8.0") {
  [22:14:09.192]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.192]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.192]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.192]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.192]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.192]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.192]                   info <- paste(info, collapse = "; ")
  [22:14:09.192]                   if (!has_future) {
  [22:14:09.192]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.192]                       info)
  [22:14:09.192]                   }
  [22:14:09.192]                   else {
  [22:14:09.192]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.192]                       info, version)
  [22:14:09.192]                   }
  [22:14:09.192]                   stop(msg)
  [22:14:09.192]                 }
  [22:14:09.192]             }
  [22:14:09.192]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.192]         }
  [22:14:09.192]     }
  [22:14:09.192]     if (is.na(TRUE)) {
  [22:14:09.192]     }
  [22:14:09.192]     else {
  [22:14:09.192]         if (TRUE) {
  [22:14:09.192]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.192]         }
  [22:14:09.192]         else {
  [22:14:09.192]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.192]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.192]         }
  [22:14:09.192]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.192]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.192]             sink(type = "output", split = FALSE)
  [22:14:09.192]             close(...future.stdout)
  [22:14:09.192]         }, add = TRUE)
  [22:14:09.192]     }
  [22:14:09.192]     ...future.frame <- sys.nframe()
  [22:14:09.192]     ...future.conditions <- list()
  [22:14:09.192]     ...future.result <- tryCatch({
  [22:14:09.192]         withCallingHandlers({
  [22:14:09.192]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.192]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.192]                 version = "1.8")
  [22:14:09.192]         }, condition = local({
  [22:14:09.192]             inherits <- base::inherits
  [22:14:09.192]             invokeRestart <- base::invokeRestart
  [22:14:09.192]             length <- base::length
  [22:14:09.192]             seq.int <- base::seq.int
  [22:14:09.192]             sys.calls <- base::sys.calls
  [22:14:09.192]             `[[` <- base::`[[`
  [22:14:09.192]             `+` <- base::`+`
  [22:14:09.192]             `<<-` <- base::`<<-`
  [22:14:09.192]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.192]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.192]                   3L)]
  [22:14:09.192]             }
  [22:14:09.192]             function(cond) {
  [22:14:09.192]                 if (inherits(cond, "error")) {
  [22:14:09.192]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.192]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.192]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.192]                     signaled = 0L)
  [22:14:09.192]                   signalCondition(cond)
  [22:14:09.192]                 }
  [22:14:09.192]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.192]                 ))) {
  [22:14:09.192]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.192]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.192]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.192]                   if (inherits(cond, "message")) {
  [22:14:09.192]                     if (!signal) 
  [22:14:09.192]                       invokeRestart("muffleMessage")
  [22:14:09.192]                   }
  [22:14:09.192]                   else if (inherits(cond, "warning")) {
  [22:14:09.192]                     if (!signal) 
  [22:14:09.192]                       invokeRestart("muffleWarning")
  [22:14:09.192]                   }
  [22:14:09.192]                   else {
  [22:14:09.192]                     if (!signal) {
  [22:14:09.192]                       restarts <- computeRestarts(cond)
  [22:14:09.192]                       for (restart in restarts) {
  [22:14:09.192]                         name <- restart$name
  [22:14:09.192]                         if (is.null(name)) 
  [22:14:09.192]                           next
  [22:14:09.192]                         if (!grepl("^muffle", name)) 
  [22:14:09.192]                           next
  [22:14:09.192]                         invokeRestart(restart)
  [22:14:09.192]                         break
  [22:14:09.192]                       }
  [22:14:09.192]                     }
  [22:14:09.192]                   }
  [22:14:09.192]                 }
  [22:14:09.192]             }
  [22:14:09.192]         }))
  [22:14:09.192]     }, error = function(ex) {
  [22:14:09.192]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.192]             version = "1.8"), class = "FutureResult")
  [22:14:09.192]     }, finally = {
  [22:14:09.192]         {
  [22:14:09.192]             NULL
  [22:14:09.192]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.192]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.192]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.192]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.192]             {
  [22:14:09.192]                 if (substitute) 
  [22:14:09.192]                   expr <- substitute(expr)
  [22:14:09.192]                 if (is.function(workers)) 
  [22:14:09.192]                   workers <- workers()
  [22:14:09.192]                 workers <- as.integer(workers)
  [22:14:09.192]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.192]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.192]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.192]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.192]                     local = TRUE, label = label, ...))
  [22:14:09.192]                 }
  [22:14:09.192]                 oopts <- options(mc.cores = workers)
  [22:14:09.192]                 on.exit(options(oopts))
  [22:14:09.192]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.192]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.192]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.192]                   label = label, ...)
  [22:14:09.192]                 if (!future$lazy) 
  [22:14:09.192]                   future <- run(future)
  [22:14:09.192]                 invisible(future)
  [22:14:09.192]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.192]         }
  [22:14:09.192]         options(...future.oldOptions)
  [22:14:09.192]     })
  [22:14:09.192]     if (is.na(TRUE)) {
  [22:14:09.192]     }
  [22:14:09.192]     else {
  [22:14:09.192]         sink(type = "output", split = FALSE)
  [22:14:09.192]         if (TRUE) {
  [22:14:09.192]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.192]         }
  [22:14:09.192]         else {
  [22:14:09.192]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.192]         }
  [22:14:09.192]         close(...future.stdout)
  [22:14:09.192]         ...future.stdout <- NULL
  [22:14:09.192]     }
  [22:14:09.192]     ...future.result$conditions <- ...future.conditions
  [22:14:09.192]     ...future.result
  [22:14:09.192] }
  [22:14:09.196] plan(): Setting new future strategy stack:
  [22:14:09.196] List of future strategies:
  [22:14:09.196] 1. sequential:
  [22:14:09.196]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.196]    - tweaked: FALSE
  [22:14:09.196]    - call: NULL
  [22:14:09.197] plan(): nbrOfWorkers() = 1
  [22:14:09.198] plan(): Setting new future strategy stack:
  [22:14:09.199] List of future strategies:
  [22:14:09.199] 1. multicore:
  [22:14:09.199]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.199]    - tweaked: FALSE
  [22:14:09.199]    - call: plan(strategy)
  [22:14:09.200] plan(): nbrOfWorkers() = 1
  [22:14:09.201] SequentialFuture started (and completed)
  [22:14:09.201] signalConditions() ...
  [22:14:09.201]  - include = 'immediateCondition'
  [22:14:09.201]  - exclude = 
  [22:14:09.202]  - resignal = FALSE
  [22:14:09.202]  - Number of conditions: 1
  [22:14:09.202] signalConditions() ... done
  [22:14:09.203] signalConditions() ...
  [22:14:09.203]  - include = 'immediateCondition'
  [22:14:09.203]  - exclude = 
  [22:14:09.224]  - resignal = FALSE
  [22:14:09.224]  - Number of conditions: 1
  [22:14:09.224] signalConditions() ... done
  [22:14:09.225] Future state: 'finished'
  [22:14:09.225] signalConditions() ...
  [22:14:09.225]  - include = 'condition'
  [22:14:09.226]  - exclude = 'immediateCondition'
  [22:14:09.226]  - resignal = TRUE
  [22:14:09.226]  - Number of conditions: 1
  [22:14:09.227]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:09.227] signalConditions() ... done
  [22:14:09.227] futureCall() ...
  [22:14:09.228] Globals to be used in the future:
  [22:14:09.228] List of 3
  [22:14:09.228]  $ a   : num 3
  [22:14:09.228]  $ FUN :function (x, y)  
  [22:14:09.228]  $ args:List of 2
  [22:14:09.228]   ..$ x: num 42
  [22:14:09.228]   ..$ y: num 12
  [22:14:09.228]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.228]  - attr(*, "where")=List of 3
  [22:14:09.228]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.228]   ..$ FUN :<environment: 0x18683f0> 
  [22:14:09.228]   ..$ args:<environment: 0x18a4670> 
  [22:14:09.228]  - attr(*, "resolved")= logi FALSE
  [22:14:09.228]  - attr(*, "total_size")= num NA
  [22:14:09.257] getGlobalsAndPackages() ...
  [22:14:09.257] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.258] Resolving globals: FALSE
  [22:14:09.259] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.259] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.260] 
  [22:14:09.260] getGlobalsAndPackages() ... DONE
  [22:14:09.260] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x18a4670>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.264] Packages needed by the future expression (n = 0): <none>
  [22:14:09.264] Packages needed by future strategies (n = 0): <none>
  [22:14:09.268] {
  [22:14:09.268]     {
  [22:14:09.268]         ...future.startTime <- Sys.time()
  [22:14:09.268]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.268]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.268]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.268]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.268]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.268]         {
  [22:14:09.268]             {
  [22:14:09.268]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.268]                 version <- if (has_future) 
  [22:14:09.268]                   packageVersion("future")
  [22:14:09.268]                 else NULL
  [22:14:09.268]                 if (!has_future || version < "1.8.0") {
  [22:14:09.268]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.268]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.268]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.268]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.268]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.268]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.268]                   info <- paste(info, collapse = "; ")
  [22:14:09.268]                   if (!has_future) {
  [22:14:09.268]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.268]                       info)
  [22:14:09.268]                   }
  [22:14:09.268]                   else {
  [22:14:09.268]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.268]                       info, version)
  [22:14:09.268]                   }
  [22:14:09.268]                   stop(msg)
  [22:14:09.268]                 }
  [22:14:09.268]             }
  [22:14:09.268]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.268]         }
  [22:14:09.268]     }
  [22:14:09.268]     if (is.na(TRUE)) {
  [22:14:09.268]     }
  [22:14:09.268]     else {
  [22:14:09.268]         if (TRUE) {
  [22:14:09.268]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.268]         }
  [22:14:09.268]         else {
  [22:14:09.268]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.268]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.268]         }
  [22:14:09.268]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.268]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.268]             sink(type = "output", split = FALSE)
  [22:14:09.268]             close(...future.stdout)
  [22:14:09.268]         }, add = TRUE)
  [22:14:09.268]     }
  [22:14:09.268]     ...future.frame <- sys.nframe()
  [22:14:09.268]     ...future.conditions <- list()
  [22:14:09.268]     ...future.result <- tryCatch({
  [22:14:09.268]         withCallingHandlers({
  [22:14:09.268]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.268]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.268]                 version = "1.8")
  [22:14:09.268]         }, condition = local({
  [22:14:09.268]             inherits <- base::inherits
  [22:14:09.268]             invokeRestart <- base::invokeRestart
  [22:14:09.268]             length <- base::length
  [22:14:09.268]             seq.int <- base::seq.int
  [22:14:09.268]             sys.calls <- base::sys.calls
  [22:14:09.268]             `[[` <- base::`[[`
  [22:14:09.268]             `+` <- base::`+`
  [22:14:09.268]             `<<-` <- base::`<<-`
  [22:14:09.268]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.268]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.268]                   3L)]
  [22:14:09.268]             }
  [22:14:09.268]             function(cond) {
  [22:14:09.268]                 if (inherits(cond, "error")) {
  [22:14:09.268]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.268]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.268]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.268]                     signaled = 0L)
  [22:14:09.268]                   signalCondition(cond)
  [22:14:09.268]                 }
  [22:14:09.268]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.268]                 ))) {
  [22:14:09.268]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.268]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.268]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.268]                   if (inherits(cond, "message")) {
  [22:14:09.268]                     if (!signal) 
  [22:14:09.268]                       invokeRestart("muffleMessage")
  [22:14:09.268]                   }
  [22:14:09.268]                   else if (inherits(cond, "warning")) {
  [22:14:09.268]                     if (!signal) 
  [22:14:09.268]                       invokeRestart("muffleWarning")
  [22:14:09.268]                   }
  [22:14:09.268]                   else {
  [22:14:09.268]                     if (!signal) {
  [22:14:09.268]                       restarts <- computeRestarts(cond)
  [22:14:09.268]                       for (restart in restarts) {
  [22:14:09.268]                         name <- restart$name
  [22:14:09.268]                         if (is.null(name)) 
  [22:14:09.268]                           next
  [22:14:09.268]                         if (!grepl("^muffle", name)) 
  [22:14:09.268]                           next
  [22:14:09.268]                         invokeRestart(restart)
  [22:14:09.268]                         break
  [22:14:09.268]                       }
  [22:14:09.268]                     }
  [22:14:09.268]                   }
  [22:14:09.268]                 }
  [22:14:09.268]             }
  [22:14:09.268]         }))
  [22:14:09.268]     }, error = function(ex) {
  [22:14:09.268]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.268]             version = "1.8"), class = "FutureResult")
  [22:14:09.268]     }, finally = {
  [22:14:09.268]         {
  [22:14:09.268]             NULL
  [22:14:09.268]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.268]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.268]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.268]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.268]             {
  [22:14:09.268]                 if (substitute) 
  [22:14:09.268]                   expr <- substitute(expr)
  [22:14:09.268]                 if (is.function(workers)) 
  [22:14:09.268]                   workers <- workers()
  [22:14:09.268]                 workers <- as.integer(workers)
  [22:14:09.268]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.268]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.268]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.268]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.268]                     local = TRUE, label = label, ...))
  [22:14:09.268]                 }
  [22:14:09.268]                 oopts <- options(mc.cores = workers)
  [22:14:09.268]                 on.exit(options(oopts))
  [22:14:09.268]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.268]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.268]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.268]                   label = label, ...)
  [22:14:09.268]                 if (!future$lazy) 
  [22:14:09.268]                   future <- run(future)
  [22:14:09.268]                 invisible(future)
  [22:14:09.268]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.268]         }
  [22:14:09.268]         options(...future.oldOptions)
  [22:14:09.268]     })
  [22:14:09.268]     if (is.na(TRUE)) {
  [22:14:09.268]     }
  [22:14:09.268]     else {
  [22:14:09.268]         sink(type = "output", split = FALSE)
  [22:14:09.268]         if (TRUE) {
  [22:14:09.268]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.268]         }
  [22:14:09.268]         else {
  [22:14:09.268]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.268]         }
  [22:14:09.268]         close(...future.stdout)
  [22:14:09.268]         ...future.stdout <- NULL
  [22:14:09.268]     }
  [22:14:09.268]     ...future.result$conditions <- ...future.conditions
  [22:14:09.268]     ...future.result
  [22:14:09.268] }
  [22:14:09.288] plan(): Setting new future strategy stack:
  [22:14:09.288] List of future strategies:
  [22:14:09.288] 1. sequential:
  [22:14:09.288]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.288]    - tweaked: FALSE
  [22:14:09.288]    - call: NULL
  [22:14:09.289] plan(): nbrOfWorkers() = 1
  [22:14:09.290] plan(): Setting new future strategy stack:
  [22:14:09.290] List of future strategies:
  [22:14:09.290] 1. multicore:
  [22:14:09.290]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.290]    - tweaked: FALSE
  [22:14:09.290]    - call: plan(strategy)
  [22:14:09.292] plan(): nbrOfWorkers() = 1
  [22:14:09.292] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.298] futureCall() ...
  [22:14:09.298] Globals to be used in the future:
  [22:14:09.299] List of 3
  [22:14:09.299]  $ a   : num 3
  [22:14:09.299]  $ FUN :function (x, y)  
  [22:14:09.299]  $ args:List of 2
  [22:14:09.299]   ..$ x: num 42
  [22:14:09.299]   ..$ y: num 12
  [22:14:09.299]  - attr(*, "where")=List of 3
  [22:14:09.299]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.299]   ..$ FUN :<environment: 0x2acd488> 
  [22:14:09.299]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.299]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.299]  - attr(*, "resolved")= logi FALSE
  [22:14:09.299]  - attr(*, "total_size")= num NA
  [22:14:09.318] getGlobalsAndPackages() ...
  [22:14:09.319] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.319] Resolving globals: FALSE
  [22:14:09.320] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.321] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.321] 
  [22:14:09.321] getGlobalsAndPackages() ... DONE
  [22:14:09.322] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2a98380>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.325] Packages needed by the future expression (n = 0): <none>
  [22:14:09.325] Packages needed by future strategies (n = 0): <none>
  [22:14:09.333] {
  [22:14:09.333]     {
  [22:14:09.333]         ...future.startTime <- Sys.time()
  [22:14:09.333]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.333]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.333]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.333]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.333]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.333]         {
  [22:14:09.333]             {
  [22:14:09.333]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.333]                 version <- if (has_future) 
  [22:14:09.333]                   packageVersion("future")
  [22:14:09.333]                 else NULL
  [22:14:09.333]                 if (!has_future || version < "1.8.0") {
  [22:14:09.333]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.333]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.333]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.333]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.333]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.333]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.333]                   info <- paste(info, collapse = "; ")
  [22:14:09.333]                   if (!has_future) {
  [22:14:09.333]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.333]                       info)
  [22:14:09.333]                   }
  [22:14:09.333]                   else {
  [22:14:09.333]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.333]                       info, version)
  [22:14:09.333]                   }
  [22:14:09.333]                   stop(msg)
  [22:14:09.333]                 }
  [22:14:09.333]             }
  [22:14:09.333]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.333]         }
  [22:14:09.333]     }
  [22:14:09.333]     if (is.na(TRUE)) {
  [22:14:09.333]     }
  [22:14:09.333]     else {
  [22:14:09.333]         if (TRUE) {
  [22:14:09.333]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.333]         }
  [22:14:09.333]         else {
  [22:14:09.333]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.333]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.333]         }
  [22:14:09.333]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.333]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.333]             sink(type = "output", split = FALSE)
  [22:14:09.333]             close(...future.stdout)
  [22:14:09.333]         }, add = TRUE)
  [22:14:09.333]     }
  [22:14:09.333]     ...future.frame <- sys.nframe()
  [22:14:09.333]     ...future.conditions <- list()
  [22:14:09.333]     ...future.result <- tryCatch({
  [22:14:09.333]         withCallingHandlers({
  [22:14:09.333]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.333]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.333]                 version = "1.8")
  [22:14:09.333]         }, condition = local({
  [22:14:09.333]             inherits <- base::inherits
  [22:14:09.333]             invokeRestart <- base::invokeRestart
  [22:14:09.333]             length <- base::length
  [22:14:09.333]             seq.int <- base::seq.int
  [22:14:09.333]             sys.calls <- base::sys.calls
  [22:14:09.333]             `[[` <- base::`[[`
  [22:14:09.333]             `+` <- base::`+`
  [22:14:09.333]             `<<-` <- base::`<<-`
  [22:14:09.333]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.333]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.333]                   3L)]
  [22:14:09.333]             }
  [22:14:09.333]             function(cond) {
  [22:14:09.333]                 if (inherits(cond, "error")) {
  [22:14:09.333]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.333]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.333]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.333]                     signaled = 0L)
  [22:14:09.333]                   signalCondition(cond)
  [22:14:09.333]                 }
  [22:14:09.333]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.333]                 ))) {
  [22:14:09.333]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.333]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.333]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.333]                   if (inherits(cond, "message")) {
  [22:14:09.333]                     if (!signal) 
  [22:14:09.333]                       invokeRestart("muffleMessage")
  [22:14:09.333]                   }
  [22:14:09.333]                   else if (inherits(cond, "warning")) {
  [22:14:09.333]                     if (!signal) 
  [22:14:09.333]                       invokeRestart("muffleWarning")
  [22:14:09.333]                   }
  [22:14:09.333]                   else {
  [22:14:09.333]                     if (!signal) {
  [22:14:09.333]                       restarts <- computeRestarts(cond)
  [22:14:09.333]                       for (restart in restarts) {
  [22:14:09.333]                         name <- restart$name
  [22:14:09.333]                         if (is.null(name)) 
  [22:14:09.333]                           next
  [22:14:09.333]                         if (!grepl("^muffle", name)) 
  [22:14:09.333]                           next
  [22:14:09.333]                         invokeRestart(restart)
  [22:14:09.333]                         break
  [22:14:09.333]                       }
  [22:14:09.333]                     }
  [22:14:09.333]                   }
  [22:14:09.333]                 }
  [22:14:09.333]             }
  [22:14:09.333]         }))
  [22:14:09.333]     }, error = function(ex) {
  [22:14:09.333]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.333]             version = "1.8"), class = "FutureResult")
  [22:14:09.333]     }, finally = {
  [22:14:09.333]         {
  [22:14:09.333]             NULL
  [22:14:09.333]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.333]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.333]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.333]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.333]             {
  [22:14:09.333]                 if (substitute) 
  [22:14:09.333]                   expr <- substitute(expr)
  [22:14:09.333]                 if (is.function(workers)) 
  [22:14:09.333]                   workers <- workers()
  [22:14:09.333]                 workers <- as.integer(workers)
  [22:14:09.333]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.333]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.333]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.333]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.333]                     local = TRUE, label = label, ...))
  [22:14:09.333]                 }
  [22:14:09.333]                 oopts <- options(mc.cores = workers)
  [22:14:09.333]                 on.exit(options(oopts))
  [22:14:09.333]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.333]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.333]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.333]                   label = label, ...)
  [22:14:09.333]                 if (!future$lazy) 
  [22:14:09.333]                   future <- run(future)
  [22:14:09.333]                 invisible(future)
  [22:14:09.333]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.333]         }
  [22:14:09.333]         options(...future.oldOptions)
  [22:14:09.333]     })
  [22:14:09.333]     if (is.na(TRUE)) {
  [22:14:09.333]     }
  [22:14:09.333]     else {
  [22:14:09.333]         sink(type = "output", split = FALSE)
  [22:14:09.333]         if (TRUE) {
  [22:14:09.333]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.333]         }
  [22:14:09.333]         else {
  [22:14:09.333]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.333]         }
  [22:14:09.333]         close(...future.stdout)
  [22:14:09.333]         ...future.stdout <- NULL
  [22:14:09.333]     }
  [22:14:09.333]     ...future.result$conditions <- ...future.conditions
  [22:14:09.333]     ...future.result
  [22:14:09.333] }
  [22:14:09.337] plan(): Setting new future strategy stack:
  [22:14:09.337] List of future strategies:
  [22:14:09.337] 1. sequential:
  [22:14:09.337]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.337]    - tweaked: FALSE
  [22:14:09.337]    - call: NULL
  [22:14:09.338] plan(): nbrOfWorkers() = 1
  [22:14:09.339] plan(): Setting new future strategy stack:
  [22:14:09.339] List of future strategies:
  [22:14:09.339] 1. multicore:
  [22:14:09.339]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.339]    - tweaked: FALSE
  [22:14:09.339]    - call: plan(strategy)
  [22:14:09.341] plan(): nbrOfWorkers() = 1
  [22:14:09.341] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:09.347] futureCall() ...
  [22:14:09.347] Finding globals ...
  [22:14:09.347] getGlobalsAndPackages() ...
  [22:14:09.347] Searching for globals...
  [22:14:09.352] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:09.353] Searching for globals ... DONE
  [22:14:09.353] Resolving globals: FALSE
  [22:14:09.354] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:09.355] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.355] 
  [22:14:09.355] getGlobalsAndPackages() ... DONE
  [22:14:09.356]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:09.356] 
  [22:14:09.356] Finding globals ... DONE
  [22:14:09.357] Globals to be used in the future:
  [22:14:09.357] List of 3
  [22:14:09.357]  $ FUN :function (x, y)  
  [22:14:09.357]  $ args:List of 2
  [22:14:09.357]   ..$ x: num 42
  [22:14:09.357]   ..$ y: num 12
  [22:14:09.357]  $ a   : num 3
  [22:14:09.357]  - attr(*, "where")=List of 3
  [22:14:09.357]   ..$ FUN :<environment: 0x1bcf138> 
  [22:14:09.357]   ..$ args:<environment: 0x1d839b8> 
  [22:14:09.357]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.357]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.357]  - attr(*, "resolved")= logi FALSE
  [22:14:09.357]  - attr(*, "total_size")= num 2592
  [22:14:09.370] getGlobalsAndPackages() ...
  [22:14:09.370] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:09.370] Resolving globals: FALSE
  [22:14:09.371] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.372] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.372] 
  [22:14:09.372] getGlobalsAndPackages() ... DONE
  [22:14:09.373] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1d839b8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.376] Packages needed by the future expression (n = 0): <none>
  [22:14:09.377] Packages needed by future strategies (n = 0): <none>
  [22:14:09.381] {
  [22:14:09.381]     {
  [22:14:09.381]         ...future.startTime <- Sys.time()
  [22:14:09.381]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.381]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.381]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.381]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.381]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.381]         {
  [22:14:09.381]             {
  [22:14:09.381]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.381]                 version <- if (has_future) 
  [22:14:09.381]                   packageVersion("future")
  [22:14:09.381]                 else NULL
  [22:14:09.381]                 if (!has_future || version < "1.8.0") {
  [22:14:09.381]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.381]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.381]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.381]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.381]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.381]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.381]                   info <- paste(info, collapse = "; ")
  [22:14:09.381]                   if (!has_future) {
  [22:14:09.381]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.381]                       info)
  [22:14:09.381]                   }
  [22:14:09.381]                   else {
  [22:14:09.381]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.381]                       info, version)
  [22:14:09.381]                   }
  [22:14:09.381]                   stop(msg)
  [22:14:09.381]                 }
  [22:14:09.381]             }
  [22:14:09.381]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.381]         }
  [22:14:09.381]     }
  [22:14:09.381]     if (is.na(TRUE)) {
  [22:14:09.381]     }
  [22:14:09.381]     else {
  [22:14:09.381]         if (TRUE) {
  [22:14:09.381]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.381]         }
  [22:14:09.381]         else {
  [22:14:09.381]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.381]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.381]         }
  [22:14:09.381]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.381]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.381]             sink(type = "output", split = FALSE)
  [22:14:09.381]             close(...future.stdout)
  [22:14:09.381]         }, add = TRUE)
  [22:14:09.381]     }
  [22:14:09.381]     ...future.frame <- sys.nframe()
  [22:14:09.381]     ...future.conditions <- list()
  [22:14:09.381]     ...future.result <- tryCatch({
  [22:14:09.381]         withCallingHandlers({
  [22:14:09.381]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.381]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.381]                 version = "1.8")
  [22:14:09.381]         }, condition = local({
  [22:14:09.381]             inherits <- base::inherits
  [22:14:09.381]             invokeRestart <- base::invokeRestart
  [22:14:09.381]             length <- base::length
  [22:14:09.381]             seq.int <- base::seq.int
  [22:14:09.381]             sys.calls <- base::sys.calls
  [22:14:09.381]             `[[` <- base::`[[`
  [22:14:09.381]             `+` <- base::`+`
  [22:14:09.381]             `<<-` <- base::`<<-`
  [22:14:09.381]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.381]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.381]                   3L)]
  [22:14:09.381]             }
  [22:14:09.381]             function(cond) {
  [22:14:09.381]                 if (inherits(cond, "error")) {
  [22:14:09.381]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.381]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.381]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.381]                     signaled = 0L)
  [22:14:09.381]                   signalCondition(cond)
  [22:14:09.381]                 }
  [22:14:09.381]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.381]                 ))) {
  [22:14:09.381]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.381]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.381]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.381]                   if (inherits(cond, "message")) {
  [22:14:09.381]                     if (!signal) 
  [22:14:09.381]                       invokeRestart("muffleMessage")
  [22:14:09.381]                   }
  [22:14:09.381]                   else if (inherits(cond, "warning")) {
  [22:14:09.381]                     if (!signal) 
  [22:14:09.381]                       invokeRestart("muffleWarning")
  [22:14:09.381]                   }
  [22:14:09.381]                   else {
  [22:14:09.381]                     if (!signal) {
  [22:14:09.381]                       restarts <- computeRestarts(cond)
  [22:14:09.381]                       for (restart in restarts) {
  [22:14:09.381]                         name <- restart$name
  [22:14:09.381]                         if (is.null(name)) 
  [22:14:09.381]                           next
  [22:14:09.381]                         if (!grepl("^muffle", name)) 
  [22:14:09.381]                           next
  [22:14:09.381]                         invokeRestart(restart)
  [22:14:09.381]                         break
  [22:14:09.381]                       }
  [22:14:09.381]                     }
  [22:14:09.381]                   }
  [22:14:09.381]                 }
  [22:14:09.381]             }
  [22:14:09.381]         }))
  [22:14:09.381]     }, error = function(ex) {
  [22:14:09.381]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.381]             version = "1.8"), class = "FutureResult")
  [22:14:09.381]     }, finally = {
  [22:14:09.381]         {
  [22:14:09.381]             NULL
  [22:14:09.381]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.381]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.381]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.381]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.381]             {
  [22:14:09.381]                 if (substitute) 
  [22:14:09.381]                   expr <- substitute(expr)
  [22:14:09.381]                 if (is.function(workers)) 
  [22:14:09.381]                   workers <- workers()
  [22:14:09.381]                 workers <- as.integer(workers)
  [22:14:09.381]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.381]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.381]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.381]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.381]                     local = TRUE, label = label, ...))
  [22:14:09.381]                 }
  [22:14:09.381]                 oopts <- options(mc.cores = workers)
  [22:14:09.381]                 on.exit(options(oopts))
  [22:14:09.381]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.381]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.381]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.381]                   label = label, ...)
  [22:14:09.381]                 if (!future$lazy) 
  [22:14:09.381]                   future <- run(future)
  [22:14:09.381]                 invisible(future)
  [22:14:09.381]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.381]         }
  [22:14:09.381]         options(...future.oldOptions)
  [22:14:09.381]     })
  [22:14:09.381]     if (is.na(TRUE)) {
  [22:14:09.381]     }
  [22:14:09.381]     else {
  [22:14:09.381]         sink(type = "output", split = FALSE)
  [22:14:09.381]         if (TRUE) {
  [22:14:09.381]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.381]         }
  [22:14:09.381]         else {
  [22:14:09.381]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.381]         }
  [22:14:09.381]         close(...future.stdout)
  [22:14:09.381]         ...future.stdout <- NULL
  [22:14:09.381]     }
  [22:14:09.381]     ...future.result$conditions <- ...future.conditions
  [22:14:09.381]     ...future.result
  [22:14:09.381] }
  [22:14:09.385] plan(): Setting new future strategy stack:
  [22:14:09.385] List of future strategies:
  [22:14:09.385] 1. sequential:
  [22:14:09.385]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.385]    - tweaked: FALSE
  [22:14:09.385]    - call: NULL
  [22:14:09.386] plan(): nbrOfWorkers() = 1
  [22:14:09.387] plan(): Setting new future strategy stack:
  [22:14:09.387] List of future strategies:
  [22:14:09.387] 1. multicore:
  [22:14:09.387]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.387]    - tweaked: FALSE
  [22:14:09.387]    - call: plan(strategy)
  [22:14:09.389] plan(): nbrOfWorkers() = 1
  [22:14:09.389] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:09.394] futureCall() ...
  [22:14:09.395] Globals to be used in the future:
  [22:14:09.395] List of 3
  [22:14:09.395]  $ a   : num 3
  [22:14:09.395]  $ FUN :function (x, y)  
  [22:14:09.395]  $ args:List of 2
  [22:14:09.395]   ..$ x: num 42
  [22:14:09.395]   ..$ y: num 12
  [22:14:09.395]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.395]  - attr(*, "where")=List of 3
  [22:14:09.395]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.395]   ..$ FUN :<environment: 0x2f12938> 
  [22:14:09.395]   ..$ args:<environment: 0x2ef1ca0> 
  [22:14:09.395]  - attr(*, "resolved")= logi FALSE
  [22:14:09.395]  - attr(*, "total_size")= num NA
  [22:14:09.412] getGlobalsAndPackages() ...
  [22:14:09.412] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.413] Resolving globals: FALSE
  [22:14:09.414] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.414] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.414] 
  [22:14:09.415] getGlobalsAndPackages() ... DONE
  [22:14:09.415] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2ef1ca0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.418] Packages needed by the future expression (n = 0): <none>
  [22:14:09.419] Packages needed by future strategies (n = 0): <none>
  [22:14:09.423] {
  [22:14:09.423]     {
  [22:14:09.423]         ...future.startTime <- Sys.time()
  [22:14:09.423]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.423]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.423]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.423]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.423]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.423]         {
  [22:14:09.423]             {
  [22:14:09.423]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.423]                 version <- if (has_future) 
  [22:14:09.423]                   packageVersion("future")
  [22:14:09.423]                 else NULL
  [22:14:09.423]                 if (!has_future || version < "1.8.0") {
  [22:14:09.423]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.423]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.423]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.423]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.423]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.423]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.423]                   info <- paste(info, collapse = "; ")
  [22:14:09.423]                   if (!has_future) {
  [22:14:09.423]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.423]                       info)
  [22:14:09.423]                   }
  [22:14:09.423]                   else {
  [22:14:09.423]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.423]                       info, version)
  [22:14:09.423]                   }
  [22:14:09.423]                   stop(msg)
  [22:14:09.423]                 }
  [22:14:09.423]             }
  [22:14:09.423]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.423]         }
  [22:14:09.423]     }
  [22:14:09.423]     if (is.na(TRUE)) {
  [22:14:09.423]     }
  [22:14:09.423]     else {
  [22:14:09.423]         if (TRUE) {
  [22:14:09.423]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.423]         }
  [22:14:09.423]         else {
  [22:14:09.423]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.423]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.423]         }
  [22:14:09.423]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.423]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.423]             sink(type = "output", split = FALSE)
  [22:14:09.423]             close(...future.stdout)
  [22:14:09.423]         }, add = TRUE)
  [22:14:09.423]     }
  [22:14:09.423]     ...future.frame <- sys.nframe()
  [22:14:09.423]     ...future.conditions <- list()
  [22:14:09.423]     ...future.result <- tryCatch({
  [22:14:09.423]         withCallingHandlers({
  [22:14:09.423]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.423]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.423]                 version = "1.8")
  [22:14:09.423]         }, condition = local({
  [22:14:09.423]             inherits <- base::inherits
  [22:14:09.423]             invokeRestart <- base::invokeRestart
  [22:14:09.423]             length <- base::length
  [22:14:09.423]             seq.int <- base::seq.int
  [22:14:09.423]             sys.calls <- base::sys.calls
  [22:14:09.423]             `[[` <- base::`[[`
  [22:14:09.423]             `+` <- base::`+`
  [22:14:09.423]             `<<-` <- base::`<<-`
  [22:14:09.423]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.423]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.423]                   3L)]
  [22:14:09.423]             }
  [22:14:09.423]             function(cond) {
  [22:14:09.423]                 if (inherits(cond, "error")) {
  [22:14:09.423]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.423]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.423]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.423]                     signaled = 0L)
  [22:14:09.423]                   signalCondition(cond)
  [22:14:09.423]                 }
  [22:14:09.423]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.423]                 ))) {
  [22:14:09.423]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.423]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.423]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.423]                   if (inherits(cond, "message")) {
  [22:14:09.423]                     if (!signal) 
  [22:14:09.423]                       invokeRestart("muffleMessage")
  [22:14:09.423]                   }
  [22:14:09.423]                   else if (inherits(cond, "warning")) {
  [22:14:09.423]                     if (!signal) 
  [22:14:09.423]                       invokeRestart("muffleWarning")
  [22:14:09.423]                   }
  [22:14:09.423]                   else {
  [22:14:09.423]                     if (!signal) {
  [22:14:09.423]                       restarts <- computeRestarts(cond)
  [22:14:09.423]                       for (restart in restarts) {
  [22:14:09.423]                         name <- restart$name
  [22:14:09.423]                         if (is.null(name)) 
  [22:14:09.423]                           next
  [22:14:09.423]                         if (!grepl("^muffle", name)) 
  [22:14:09.423]                           next
  [22:14:09.423]                         invokeRestart(restart)
  [22:14:09.423]                         break
  [22:14:09.423]                       }
  [22:14:09.423]                     }
  [22:14:09.423]                   }
  [22:14:09.423]                 }
  [22:14:09.423]             }
  [22:14:09.423]         }))
  [22:14:09.423]     }, error = function(ex) {
  [22:14:09.423]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.423]             version = "1.8"), class = "FutureResult")
  [22:14:09.423]     }, finally = {
  [22:14:09.423]         {
  [22:14:09.423]             NULL
  [22:14:09.423]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.423]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.423]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.423]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.423]             {
  [22:14:09.423]                 if (substitute) 
  [22:14:09.423]                   expr <- substitute(expr)
  [22:14:09.423]                 if (is.function(workers)) 
  [22:14:09.423]                   workers <- workers()
  [22:14:09.423]                 workers <- as.integer(workers)
  [22:14:09.423]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.423]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.423]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.423]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.423]                     local = TRUE, label = label, ...))
  [22:14:09.423]                 }
  [22:14:09.423]                 oopts <- options(mc.cores = workers)
  [22:14:09.423]                 on.exit(options(oopts))
  [22:14:09.423]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.423]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.423]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.423]                   label = label, ...)
  [22:14:09.423]                 if (!future$lazy) 
  [22:14:09.423]                   future <- run(future)
  [22:14:09.423]                 invisible(future)
  [22:14:09.423]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.423]         }
  [22:14:09.423]         options(...future.oldOptions)
  [22:14:09.423]     })
  [22:14:09.423]     if (is.na(TRUE)) {
  [22:14:09.423]     }
  [22:14:09.423]     else {
  [22:14:09.423]         sink(type = "output", split = FALSE)
  [22:14:09.423]         if (TRUE) {
  [22:14:09.423]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.423]         }
  [22:14:09.423]         else {
  [22:14:09.423]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.423]         }
  [22:14:09.423]         close(...future.stdout)
  [22:14:09.423]         ...future.stdout <- NULL
  [22:14:09.423]     }
  [22:14:09.423]     ...future.result$conditions <- ...future.conditions
  [22:14:09.423]     ...future.result
  [22:14:09.423] }
  [22:14:09.427] plan(): Setting new future strategy stack:
  [22:14:09.427] List of future strategies:
  [22:14:09.427] 1. sequential:
  [22:14:09.427]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.427]    - tweaked: FALSE
  [22:14:09.427]    - call: NULL
  [22:14:09.428] plan(): nbrOfWorkers() = 1
  [22:14:09.429] plan(): Setting new future strategy stack:
  [22:14:09.429] List of future strategies:
  [22:14:09.429] 1. multicore:
  [22:14:09.429]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.429]    - tweaked: FALSE
  [22:14:09.429]    - call: plan(strategy)
  [22:14:09.430] plan(): nbrOfWorkers() = 1
  [22:14:09.431] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.436] futureCall() ...
  [22:14:09.436] Globals to be used in the future:
  [22:14:09.437] List of 3
  [22:14:09.437]  $ a   : num 3
  [22:14:09.437]  $ FUN :function (x, y)  
  [22:14:09.437]  $ args:List of 2
  [22:14:09.437]   ..$ x: num 42
  [22:14:09.437]   ..$ y: num 12
  [22:14:09.437]  - attr(*, "where")=List of 3
  [22:14:09.437]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.437]   ..$ FUN :<environment: 0x277fe28> 
  [22:14:09.437]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.437]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.437]  - attr(*, "resolved")= logi FALSE
  [22:14:09.437]  - attr(*, "total_size")= num NA
  [22:14:09.451] getGlobalsAndPackages() ...
  [22:14:09.451] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.452] Resolving globals: FALSE
  [22:14:09.453] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.453] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.454] 
  [22:14:09.454] getGlobalsAndPackages() ... DONE
  [22:14:09.454] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x272abc8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.458] Packages needed by the future expression (n = 0): <none>
  [22:14:09.458] Packages needed by future strategies (n = 0): <none>
  [22:14:09.463] {
  [22:14:09.463]     {
  [22:14:09.463]         ...future.startTime <- Sys.time()
  [22:14:09.463]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.463]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.463]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.463]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.463]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.463]         {
  [22:14:09.463]             {
  [22:14:09.463]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.463]                 version <- if (has_future) 
  [22:14:09.463]                   packageVersion("future")
  [22:14:09.463]                 else NULL
  [22:14:09.463]                 if (!has_future || version < "1.8.0") {
  [22:14:09.463]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.463]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.463]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.463]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.463]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.463]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.463]                   info <- paste(info, collapse = "; ")
  [22:14:09.463]                   if (!has_future) {
  [22:14:09.463]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.463]                       info)
  [22:14:09.463]                   }
  [22:14:09.463]                   else {
  [22:14:09.463]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.463]                       info, version)
  [22:14:09.463]                   }
  [22:14:09.463]                   stop(msg)
  [22:14:09.463]                 }
  [22:14:09.463]             }
  [22:14:09.463]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.463]         }
  [22:14:09.463]     }
  [22:14:09.463]     if (is.na(TRUE)) {
  [22:14:09.463]     }
  [22:14:09.463]     else {
  [22:14:09.463]         if (TRUE) {
  [22:14:09.463]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.463]         }
  [22:14:09.463]         else {
  [22:14:09.463]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.463]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.463]         }
  [22:14:09.463]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.463]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.463]             sink(type = "output", split = FALSE)
  [22:14:09.463]             close(...future.stdout)
  [22:14:09.463]         }, add = TRUE)
  [22:14:09.463]     }
  [22:14:09.463]     ...future.frame <- sys.nframe()
  [22:14:09.463]     ...future.conditions <- list()
  [22:14:09.463]     ...future.result <- tryCatch({
  [22:14:09.463]         withCallingHandlers({
  [22:14:09.463]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.463]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.463]                 version = "1.8")
  [22:14:09.463]         }, condition = local({
  [22:14:09.463]             inherits <- base::inherits
  [22:14:09.463]             invokeRestart <- base::invokeRestart
  [22:14:09.463]             length <- base::length
  [22:14:09.463]             seq.int <- base::seq.int
  [22:14:09.463]             sys.calls <- base::sys.calls
  [22:14:09.463]             `[[` <- base::`[[`
  [22:14:09.463]             `+` <- base::`+`
  [22:14:09.463]             `<<-` <- base::`<<-`
  [22:14:09.463]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.463]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.463]                   3L)]
  [22:14:09.463]             }
  [22:14:09.463]             function(cond) {
  [22:14:09.463]                 if (inherits(cond, "error")) {
  [22:14:09.463]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.463]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.463]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.463]                     signaled = 0L)
  [22:14:09.463]                   signalCondition(cond)
  [22:14:09.463]                 }
  [22:14:09.463]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.463]                 ))) {
  [22:14:09.463]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.463]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.463]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.463]                   if (inherits(cond, "message")) {
  [22:14:09.463]                     if (!signal) 
  [22:14:09.463]                       invokeRestart("muffleMessage")
  [22:14:09.463]                   }
  [22:14:09.463]                   else if (inherits(cond, "warning")) {
  [22:14:09.463]                     if (!signal) 
  [22:14:09.463]                       invokeRestart("muffleWarning")
  [22:14:09.463]                   }
  [22:14:09.463]                   else {
  [22:14:09.463]                     if (!signal) {
  [22:14:09.463]                       restarts <- computeRestarts(cond)
  [22:14:09.463]                       for (restart in restarts) {
  [22:14:09.463]                         name <- restart$name
  [22:14:09.463]                         if (is.null(name)) 
  [22:14:09.463]                           next
  [22:14:09.463]                         if (!grepl("^muffle", name)) 
  [22:14:09.463]                           next
  [22:14:09.463]                         invokeRestart(restart)
  [22:14:09.463]                         break
  [22:14:09.463]                       }
  [22:14:09.463]                     }
  [22:14:09.463]                   }
  [22:14:09.463]                 }
  [22:14:09.463]             }
  [22:14:09.463]         }))
  [22:14:09.463]     }, error = function(ex) {
  [22:14:09.463]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.463]             version = "1.8"), class = "FutureResult")
  [22:14:09.463]     }, finally = {
  [22:14:09.463]         {
  [22:14:09.463]             NULL
  [22:14:09.463]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.463]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.463]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:09.463]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:09.463]             {
  [22:14:09.463]                 if (substitute) 
  [22:14:09.463]                   expr <- substitute(expr)
  [22:14:09.463]                 if (is.function(workers)) 
  [22:14:09.463]                   workers <- workers()
  [22:14:09.463]                 workers <- as.integer(workers)
  [22:14:09.463]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:09.463]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:09.463]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.463]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:09.463]                     local = TRUE, label = label, ...))
  [22:14:09.463]                 }
  [22:14:09.463]                 oopts <- options(mc.cores = workers)
  [22:14:09.463]                 on.exit(options(oopts))
  [22:14:09.463]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:09.463]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.463]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:09.463]                   label = label, ...)
  [22:14:09.463]                 if (!future$lazy) 
  [22:14:09.463]                   future <- run(future)
  [22:14:09.463]                 invisible(future)
  [22:14:09.463]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.463]         }
  [22:14:09.463]         options(...future.oldOptions)
  [22:14:09.463]     })
  [22:14:09.463]     if (is.na(TRUE)) {
  [22:14:09.463]     }
  [22:14:09.463]     else {
  [22:14:09.463]         sink(type = "output", split = FALSE)
  [22:14:09.463]         if (TRUE) {
  [22:14:09.463]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.463]         }
  [22:14:09.463]         else {
  [22:14:09.463]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.463]         }
  [22:14:09.463]         close(...future.stdout)
  [22:14:09.463]         ...future.stdout <- NULL
  [22:14:09.463]     }
  [22:14:09.463]     ...future.result$conditions <- ...future.conditions
  [22:14:09.463]     ...future.result
  [22:14:09.463] }
  [22:14:09.466] plan(): Setting new future strategy stack:
  [22:14:09.466] List of future strategies:
  [22:14:09.466] 1. sequential:
  [22:14:09.466]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.466]    - tweaked: FALSE
  [22:14:09.466]    - call: NULL
  [22:14:09.467] plan(): nbrOfWorkers() = 1
  [22:14:09.468] plan(): Setting new future strategy stack:
  [22:14:09.469] List of future strategies:
  [22:14:09.469] 1. multicore:
  [22:14:09.469]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:09.469]    - tweaked: FALSE
  [22:14:09.469]    - call: plan(strategy)
  [22:14:09.470] plan(): nbrOfWorkers() = 1
  [22:14:09.471] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  - plan('multisession') ...
  [22:14:09.481] plan(): Setting new future strategy stack:
  [22:14:09.481] List of future strategies:
  [22:14:09.481] 1. multisession:
  [22:14:09.481]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.481]    - tweaked: FALSE
  [22:14:09.481]    - call: plan(strategy)
  [22:14:09.482] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [22:14:09.482] multisession:
  [22:14:09.482] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.482] - tweaked: FALSE
  [22:14:09.482] - call: plan(strategy)
  [22:14:09.484] getGlobalsAndPackages() ...
  [22:14:09.484] Not searching for globals
  [22:14:09.485] - globals: [0] <none>
  [22:14:09.485] getGlobalsAndPackages() ... DONE
  [22:14:09.487] Packages needed by the future expression (n = 0): <none>
  [22:14:09.487] Packages needed by future strategies (n = 0): <none>
  [22:14:09.492] {
  [22:14:09.492]     {
  [22:14:09.492]         ...future.startTime <- Sys.time()
  [22:14:09.492]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.492]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.492]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.492]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.492]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.492]         {
  [22:14:09.492]             {
  [22:14:09.492]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.492]                 version <- if (has_future) 
  [22:14:09.492]                   packageVersion("future")
  [22:14:09.492]                 else NULL
  [22:14:09.492]                 if (!has_future || version < "1.8.0") {
  [22:14:09.492]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.492]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.492]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.492]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.492]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.492]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.492]                   info <- paste(info, collapse = "; ")
  [22:14:09.492]                   if (!has_future) {
  [22:14:09.492]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.492]                       info)
  [22:14:09.492]                   }
  [22:14:09.492]                   else {
  [22:14:09.492]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.492]                       info, version)
  [22:14:09.492]                   }
  [22:14:09.492]                   stop(msg)
  [22:14:09.492]                 }
  [22:14:09.492]             }
  [22:14:09.492]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.492]         }
  [22:14:09.492]     }
  [22:14:09.492]     if (is.na(TRUE)) {
  [22:14:09.492]     }
  [22:14:09.492]     else {
  [22:14:09.492]         if (TRUE) {
  [22:14:09.492]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.492]         }
  [22:14:09.492]         else {
  [22:14:09.492]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.492]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.492]         }
  [22:14:09.492]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.492]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.492]             sink(type = "output", split = FALSE)
  [22:14:09.492]             close(...future.stdout)
  [22:14:09.492]         }, add = TRUE)
  [22:14:09.492]     }
  [22:14:09.492]     ...future.frame <- sys.nframe()
  [22:14:09.492]     ...future.conditions <- list()
  [22:14:09.492]     ...future.result <- tryCatch({
  [22:14:09.492]         withCallingHandlers({
  [22:14:09.492]             ...future.value <- local(NA)
  [22:14:09.492]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.492]                 version = "1.8")
  [22:14:09.492]         }, condition = local({
  [22:14:09.492]             inherits <- base::inherits
  [22:14:09.492]             invokeRestart <- base::invokeRestart
  [22:14:09.492]             length <- base::length
  [22:14:09.492]             seq.int <- base::seq.int
  [22:14:09.492]             sys.calls <- base::sys.calls
  [22:14:09.492]             `[[` <- base::`[[`
  [22:14:09.492]             `+` <- base::`+`
  [22:14:09.492]             `<<-` <- base::`<<-`
  [22:14:09.492]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.492]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.492]                   3L)]
  [22:14:09.492]             }
  [22:14:09.492]             function(cond) {
  [22:14:09.492]                 if (inherits(cond, "error")) {
  [22:14:09.492]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.492]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.492]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.492]                     signaled = 0L)
  [22:14:09.492]                   signalCondition(cond)
  [22:14:09.492]                 }
  [22:14:09.492]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.492]                 ))) {
  [22:14:09.492]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.492]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.492]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.492]                   if (inherits(cond, "message")) {
  [22:14:09.492]                     if (!signal) 
  [22:14:09.492]                       invokeRestart("muffleMessage")
  [22:14:09.492]                   }
  [22:14:09.492]                   else if (inherits(cond, "warning")) {
  [22:14:09.492]                     if (!signal) 
  [22:14:09.492]                       invokeRestart("muffleWarning")
  [22:14:09.492]                   }
  [22:14:09.492]                   else {
  [22:14:09.492]                     if (!signal) {
  [22:14:09.492]                       restarts <- computeRestarts(cond)
  [22:14:09.492]                       for (restart in restarts) {
  [22:14:09.492]                         name <- restart$name
  [22:14:09.492]                         if (is.null(name)) 
  [22:14:09.492]                           next
  [22:14:09.492]                         if (!grepl("^muffle", name)) 
  [22:14:09.492]                           next
  [22:14:09.492]                         invokeRestart(restart)
  [22:14:09.492]                         break
  [22:14:09.492]                       }
  [22:14:09.492]                     }
  [22:14:09.492]                   }
  [22:14:09.492]                 }
  [22:14:09.492]             }
  [22:14:09.492]         }))
  [22:14:09.492]     }, error = function(ex) {
  [22:14:09.492]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.492]             version = "1.8"), class = "FutureResult")
  [22:14:09.492]     }, finally = {
  [22:14:09.492]         {
  [22:14:09.492]             NULL
  [22:14:09.492]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.492]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.492]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.492]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.492]                 ...) 
  [22:14:09.492]             {
  [22:14:09.492]                 if (substitute) 
  [22:14:09.492]                   expr <- substitute(expr)
  [22:14:09.492]                 if (is.function(workers)) 
  [22:14:09.492]                   workers <- workers()
  [22:14:09.492]                 workers <- as.integer(workers)
  [22:14:09.492]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.492]                   workers >= 1)
  [22:14:09.492]                 if (workers == 1L) {
  [22:14:09.492]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.492]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.492]                     local = TRUE, label = label, ...))
  [22:14:09.492]                 }
  [22:14:09.492]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.492]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.492]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.492]                   globals = globals, persistent = persistent, 
  [22:14:09.492]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.492]                   label = label, ...)
  [22:14:09.492]                 if (!future$lazy) 
  [22:14:09.492]                   future <- run(future)
  [22:14:09.492]                 invisible(future)
  [22:14:09.492]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.492]         }
  [22:14:09.492]         options(...future.oldOptions)
  [22:14:09.492]     })
  [22:14:09.492]     if (is.na(TRUE)) {
  [22:14:09.492]     }
  [22:14:09.492]     else {
  [22:14:09.492]         sink(type = "output", split = FALSE)
  [22:14:09.492]         if (TRUE) {
  [22:14:09.492]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.492]         }
  [22:14:09.492]         else {
  [22:14:09.492]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.492]         }
  [22:14:09.492]         close(...future.stdout)
  [22:14:09.492]         ...future.stdout <- NULL
  [22:14:09.492]     }
  [22:14:09.492]     ...future.result$conditions <- ...future.conditions
  [22:14:09.492]     ...future.result
  [22:14:09.492] }
  [22:14:09.495] plan(): Setting new future strategy stack:
  [22:14:09.496] List of future strategies:
  [22:14:09.496] 1. sequential:
  [22:14:09.496]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.496]    - tweaked: FALSE
  [22:14:09.496]    - call: NULL
  [22:14:09.497] plan(): nbrOfWorkers() = 1
  [22:14:09.498] plan(): Setting new future strategy stack:
  [22:14:09.498] List of future strategies:
  [22:14:09.498] 1. multisession:
  [22:14:09.498]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.498]    - tweaked: FALSE
  [22:14:09.498]    - call: plan(strategy)
  [22:14:09.500] plan(): nbrOfWorkers() = 1
  [22:14:09.500] SequentialFuture started (and completed)
  [22:14:09.501] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [22:14:09.501] plan(): nbrOfWorkers() = 1
  [22:14:09.502] futureCall() ...
  [22:14:09.502] Globals to be used in the future:
  [22:14:09.503] List of 2
  [22:14:09.503]  $ FUN :function (x, y)  
  [22:14:09.503]  $ args:List of 2
  [22:14:09.503]   ..$ x: num 42
  [22:14:09.503]   ..$ y: num 12
  [22:14:09.503]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.503]  - attr(*, "where")=List of 2
  [22:14:09.503]   ..$ FUN :<environment: 0x1ba1dd8> 
  [22:14:09.503]   ..$ args:<environment: 0x1ba1dd8> 
  [22:14:09.503]  - attr(*, "resolved")= logi FALSE
  [22:14:09.503]  - attr(*, "total_size")= num NA
  [22:14:09.513] getGlobalsAndPackages() ...
  [22:14:09.514] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:09.514] Resolving globals: FALSE
  [22:14:09.515] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:09.516] - globals: [2] 'FUN', 'args'
  [22:14:09.516] 
  [22:14:09.516] getGlobalsAndPackages() ... DONE
  [22:14:09.517] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1ba1dd8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.520] Packages needed by the future expression (n = 0): <none>
  [22:14:09.520] Packages needed by future strategies (n = 0): <none>
  [22:14:09.525] {
  [22:14:09.525]     {
  [22:14:09.525]         ...future.startTime <- Sys.time()
  [22:14:09.525]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.525]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.525]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.525]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.525]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.525]         {
  [22:14:09.525]             {
  [22:14:09.525]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.525]                 version <- if (has_future) 
  [22:14:09.525]                   packageVersion("future")
  [22:14:09.525]                 else NULL
  [22:14:09.525]                 if (!has_future || version < "1.8.0") {
  [22:14:09.525]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.525]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.525]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.525]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.525]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.525]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.525]                   info <- paste(info, collapse = "; ")
  [22:14:09.525]                   if (!has_future) {
  [22:14:09.525]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.525]                       info)
  [22:14:09.525]                   }
  [22:14:09.525]                   else {
  [22:14:09.525]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.525]                       info, version)
  [22:14:09.525]                   }
  [22:14:09.525]                   stop(msg)
  [22:14:09.525]                 }
  [22:14:09.525]             }
  [22:14:09.525]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.525]         }
  [22:14:09.525]     }
  [22:14:09.525]     if (is.na(TRUE)) {
  [22:14:09.525]     }
  [22:14:09.525]     else {
  [22:14:09.525]         if (TRUE) {
  [22:14:09.525]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.525]         }
  [22:14:09.525]         else {
  [22:14:09.525]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.525]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.525]         }
  [22:14:09.525]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.525]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.525]             sink(type = "output", split = FALSE)
  [22:14:09.525]             close(...future.stdout)
  [22:14:09.525]         }, add = TRUE)
  [22:14:09.525]     }
  [22:14:09.525]     ...future.frame <- sys.nframe()
  [22:14:09.525]     ...future.conditions <- list()
  [22:14:09.525]     ...future.result <- tryCatch({
  [22:14:09.525]         withCallingHandlers({
  [22:14:09.525]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.525]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.525]                 version = "1.8")
  [22:14:09.525]         }, condition = local({
  [22:14:09.525]             inherits <- base::inherits
  [22:14:09.525]             invokeRestart <- base::invokeRestart
  [22:14:09.525]             length <- base::length
  [22:14:09.525]             seq.int <- base::seq.int
  [22:14:09.525]             sys.calls <- base::sys.calls
  [22:14:09.525]             `[[` <- base::`[[`
  [22:14:09.525]             `+` <- base::`+`
  [22:14:09.525]             `<<-` <- base::`<<-`
  [22:14:09.525]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.525]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.525]                   3L)]
  [22:14:09.525]             }
  [22:14:09.525]             function(cond) {
  [22:14:09.525]                 if (inherits(cond, "error")) {
  [22:14:09.525]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.525]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.525]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.525]                     signaled = 0L)
  [22:14:09.525]                   signalCondition(cond)
  [22:14:09.525]                 }
  [22:14:09.525]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.525]                 ))) {
  [22:14:09.525]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.525]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.525]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.525]                   if (inherits(cond, "message")) {
  [22:14:09.525]                     if (!signal) 
  [22:14:09.525]                       invokeRestart("muffleMessage")
  [22:14:09.525]                   }
  [22:14:09.525]                   else if (inherits(cond, "warning")) {
  [22:14:09.525]                     if (!signal) 
  [22:14:09.525]                       invokeRestart("muffleWarning")
  [22:14:09.525]                   }
  [22:14:09.525]                   else {
  [22:14:09.525]                     if (!signal) {
  [22:14:09.525]                       restarts <- computeRestarts(cond)
  [22:14:09.525]                       for (restart in restarts) {
  [22:14:09.525]                         name <- restart$name
  [22:14:09.525]                         if (is.null(name)) 
  [22:14:09.525]                           next
  [22:14:09.525]                         if (!grepl("^muffle", name)) 
  [22:14:09.525]                           next
  [22:14:09.525]                         invokeRestart(restart)
  [22:14:09.525]                         break
  [22:14:09.525]                       }
  [22:14:09.525]                     }
  [22:14:09.525]                   }
  [22:14:09.525]                 }
  [22:14:09.525]             }
  [22:14:09.525]         }))
  [22:14:09.525]     }, error = function(ex) {
  [22:14:09.525]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.525]             version = "1.8"), class = "FutureResult")
  [22:14:09.525]     }, finally = {
  [22:14:09.525]         {
  [22:14:09.525]             NULL
  [22:14:09.525]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.525]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.525]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.525]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.525]                 ...) 
  [22:14:09.525]             {
  [22:14:09.525]                 if (substitute) 
  [22:14:09.525]                   expr <- substitute(expr)
  [22:14:09.525]                 if (is.function(workers)) 
  [22:14:09.525]                   workers <- workers()
  [22:14:09.525]                 workers <- as.integer(workers)
  [22:14:09.525]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.525]                   workers >= 1)
  [22:14:09.525]                 if (workers == 1L) {
  [22:14:09.525]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.525]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.525]                     local = TRUE, label = label, ...))
  [22:14:09.525]                 }
  [22:14:09.525]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.525]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.525]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.525]                   globals = globals, persistent = persistent, 
  [22:14:09.525]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.525]                   label = label, ...)
  [22:14:09.525]                 if (!future$lazy) 
  [22:14:09.525]                   future <- run(future)
  [22:14:09.525]                 invisible(future)
  [22:14:09.525]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.525]         }
  [22:14:09.525]         options(...future.oldOptions)
  [22:14:09.525]     })
  [22:14:09.525]     if (is.na(TRUE)) {
  [22:14:09.525]     }
  [22:14:09.525]     else {
  [22:14:09.525]         sink(type = "output", split = FALSE)
  [22:14:09.525]         if (TRUE) {
  [22:14:09.525]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.525]         }
  [22:14:09.525]         else {
  [22:14:09.525]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.525]         }
  [22:14:09.525]         close(...future.stdout)
  [22:14:09.525]         ...future.stdout <- NULL
  [22:14:09.525]     }
  [22:14:09.525]     ...future.result$conditions <- ...future.conditions
  [22:14:09.525]     ...future.result
  [22:14:09.525] }
  [22:14:09.529] plan(): Setting new future strategy stack:
  [22:14:09.529] List of future strategies:
  [22:14:09.529] 1. sequential:
  [22:14:09.529]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.529]    - tweaked: FALSE
  [22:14:09.529]    - call: NULL
  [22:14:09.530] plan(): nbrOfWorkers() = 1
  [22:14:09.531] plan(): Setting new future strategy stack:
  [22:14:09.532] List of future strategies:
  [22:14:09.532] 1. multisession:
  [22:14:09.532]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.532]    - tweaked: FALSE
  [22:14:09.532]    - call: plan(strategy)
  [22:14:09.533] plan(): nbrOfWorkers() = 1
  [22:14:09.534] SequentialFuture started (and completed)
  [22:14:09.534] signalConditions() ...
  [22:14:09.534]  - include = 'immediateCondition'
  [22:14:09.535]  - exclude = 
  [22:14:09.535]  - resignal = FALSE
  [22:14:09.535]  - Number of conditions: 1
  [22:14:09.535] signalConditions() ... done
  [22:14:09.536] signalConditions() ...
  [22:14:09.536]  - include = 'immediateCondition'
  [22:14:09.536]  - exclude = 
  [22:14:09.537]  - resignal = FALSE
  [22:14:09.537]  - Number of conditions: 1
  [22:14:09.537] signalConditions() ... done
  [22:14:09.538] Future state: 'finished'
  [22:14:09.538] signalConditions() ...
  [22:14:09.538]  - include = 'condition'
  [22:14:09.538]  - exclude = 'immediateCondition'
  [22:14:09.539]  - resignal = TRUE
  [22:14:09.539]  - Number of conditions: 1
  [22:14:09.539]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:09.540] signalConditions() ... done
  [22:14:09.540] futureCall() ...
  [22:14:09.541] Globals to be used in the future:
  [22:14:09.541] List of 3
  [22:14:09.541]  $ a   : num 3
  [22:14:09.541]  $ FUN :function (x, y)  
  [22:14:09.541]  $ args:List of 2
  [22:14:09.541]   ..$ x: num 42
  [22:14:09.541]   ..$ y: num 12
  [22:14:09.541]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.541]  - attr(*, "where")=List of 3
  [22:14:09.541]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.541]   ..$ FUN :<environment: 0x2e971c0> 
  [22:14:09.541]   ..$ args:<environment: 0x2e72960> 
  [22:14:09.541]  - attr(*, "resolved")= logi FALSE
  [22:14:09.541]  - attr(*, "total_size")= num NA
  [22:14:09.558] getGlobalsAndPackages() ...
  [22:14:09.559] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.559] Resolving globals: FALSE
  [22:14:09.560] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.560] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.561] 
  [22:14:09.561] getGlobalsAndPackages() ... DONE
  [22:14:09.562] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2e72960>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.565] Packages needed by the future expression (n = 0): <none>
  [22:14:09.565] Packages needed by future strategies (n = 0): <none>
  [22:14:09.570] {
  [22:14:09.570]     {
  [22:14:09.570]         ...future.startTime <- Sys.time()
  [22:14:09.570]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.570]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.570]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.570]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.570]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.570]         {
  [22:14:09.570]             {
  [22:14:09.570]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.570]                 version <- if (has_future) 
  [22:14:09.570]                   packageVersion("future")
  [22:14:09.570]                 else NULL
  [22:14:09.570]                 if (!has_future || version < "1.8.0") {
  [22:14:09.570]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.570]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.570]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.570]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.570]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.570]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.570]                   info <- paste(info, collapse = "; ")
  [22:14:09.570]                   if (!has_future) {
  [22:14:09.570]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.570]                       info)
  [22:14:09.570]                   }
  [22:14:09.570]                   else {
  [22:14:09.570]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.570]                       info, version)
  [22:14:09.570]                   }
  [22:14:09.570]                   stop(msg)
  [22:14:09.570]                 }
  [22:14:09.570]             }
  [22:14:09.570]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.570]         }
  [22:14:09.570]     }
  [22:14:09.570]     if (is.na(TRUE)) {
  [22:14:09.570]     }
  [22:14:09.570]     else {
  [22:14:09.570]         if (TRUE) {
  [22:14:09.570]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.570]         }
  [22:14:09.570]         else {
  [22:14:09.570]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.570]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.570]         }
  [22:14:09.570]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.570]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.570]             sink(type = "output", split = FALSE)
  [22:14:09.570]             close(...future.stdout)
  [22:14:09.570]         }, add = TRUE)
  [22:14:09.570]     }
  [22:14:09.570]     ...future.frame <- sys.nframe()
  [22:14:09.570]     ...future.conditions <- list()
  [22:14:09.570]     ...future.result <- tryCatch({
  [22:14:09.570]         withCallingHandlers({
  [22:14:09.570]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.570]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.570]                 version = "1.8")
  [22:14:09.570]         }, condition = local({
  [22:14:09.570]             inherits <- base::inherits
  [22:14:09.570]             invokeRestart <- base::invokeRestart
  [22:14:09.570]             length <- base::length
  [22:14:09.570]             seq.int <- base::seq.int
  [22:14:09.570]             sys.calls <- base::sys.calls
  [22:14:09.570]             `[[` <- base::`[[`
  [22:14:09.570]             `+` <- base::`+`
  [22:14:09.570]             `<<-` <- base::`<<-`
  [22:14:09.570]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.570]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.570]                   3L)]
  [22:14:09.570]             }
  [22:14:09.570]             function(cond) {
  [22:14:09.570]                 if (inherits(cond, "error")) {
  [22:14:09.570]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.570]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.570]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.570]                     signaled = 0L)
  [22:14:09.570]                   signalCondition(cond)
  [22:14:09.570]                 }
  [22:14:09.570]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.570]                 ))) {
  [22:14:09.570]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.570]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.570]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.570]                   if (inherits(cond, "message")) {
  [22:14:09.570]                     if (!signal) 
  [22:14:09.570]                       invokeRestart("muffleMessage")
  [22:14:09.570]                   }
  [22:14:09.570]                   else if (inherits(cond, "warning")) {
  [22:14:09.570]                     if (!signal) 
  [22:14:09.570]                       invokeRestart("muffleWarning")
  [22:14:09.570]                   }
  [22:14:09.570]                   else {
  [22:14:09.570]                     if (!signal) {
  [22:14:09.570]                       restarts <- computeRestarts(cond)
  [22:14:09.570]                       for (restart in restarts) {
  [22:14:09.570]                         name <- restart$name
  [22:14:09.570]                         if (is.null(name)) 
  [22:14:09.570]                           next
  [22:14:09.570]                         if (!grepl("^muffle", name)) 
  [22:14:09.570]                           next
  [22:14:09.570]                         invokeRestart(restart)
  [22:14:09.570]                         break
  [22:14:09.570]                       }
  [22:14:09.570]                     }
  [22:14:09.570]                   }
  [22:14:09.570]                 }
  [22:14:09.570]             }
  [22:14:09.570]         }))
  [22:14:09.570]     }, error = function(ex) {
  [22:14:09.570]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.570]             version = "1.8"), class = "FutureResult")
  [22:14:09.570]     }, finally = {
  [22:14:09.570]         {
  [22:14:09.570]             NULL
  [22:14:09.570]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.570]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.570]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.570]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.570]                 ...) 
  [22:14:09.570]             {
  [22:14:09.570]                 if (substitute) 
  [22:14:09.570]                   expr <- substitute(expr)
  [22:14:09.570]                 if (is.function(workers)) 
  [22:14:09.570]                   workers <- workers()
  [22:14:09.570]                 workers <- as.integer(workers)
  [22:14:09.570]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.570]                   workers >= 1)
  [22:14:09.570]                 if (workers == 1L) {
  [22:14:09.570]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.570]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.570]                     local = TRUE, label = label, ...))
  [22:14:09.570]                 }
  [22:14:09.570]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.570]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.570]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.570]                   globals = globals, persistent = persistent, 
  [22:14:09.570]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.570]                   label = label, ...)
  [22:14:09.570]                 if (!future$lazy) 
  [22:14:09.570]                   future <- run(future)
  [22:14:09.570]                 invisible(future)
  [22:14:09.570]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.570]         }
  [22:14:09.570]         options(...future.oldOptions)
  [22:14:09.570]     })
  [22:14:09.570]     if (is.na(TRUE)) {
  [22:14:09.570]     }
  [22:14:09.570]     else {
  [22:14:09.570]         sink(type = "output", split = FALSE)
  [22:14:09.570]         if (TRUE) {
  [22:14:09.570]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.570]         }
  [22:14:09.570]         else {
  [22:14:09.570]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.570]         }
  [22:14:09.570]         close(...future.stdout)
  [22:14:09.570]         ...future.stdout <- NULL
  [22:14:09.570]     }
  [22:14:09.570]     ...future.result$conditions <- ...future.conditions
  [22:14:09.570]     ...future.result
  [22:14:09.570] }
  [22:14:09.573] plan(): Setting new future strategy stack:
  [22:14:09.574] List of future strategies:
  [22:14:09.574] 1. sequential:
  [22:14:09.574]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.574]    - tweaked: FALSE
  [22:14:09.574]    - call: NULL
  [22:14:09.575] plan(): nbrOfWorkers() = 1
  [22:14:09.576] plan(): Setting new future strategy stack:
  [22:14:09.576] List of future strategies:
  [22:14:09.576] 1. multisession:
  [22:14:09.576]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.576]    - tweaked: FALSE
  [22:14:09.576]    - call: plan(strategy)
  [22:14:09.577] plan(): nbrOfWorkers() = 1
  [22:14:09.578] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.582] futureCall() ...
  [22:14:09.583] Globals to be used in the future:
  [22:14:09.583] List of 3
  [22:14:09.583]  $ a   : num 3
  [22:14:09.583]  $ FUN :function (x, y)  
  [22:14:09.583]  $ args:List of 2
  [22:14:09.583]   ..$ x: num 42
  [22:14:09.583]   ..$ y: num 12
  [22:14:09.583]  - attr(*, "where")=List of 3
  [22:14:09.583]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.583]   ..$ FUN :<environment: 0x2782fa8> 
  [22:14:09.583]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.583]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.583]  - attr(*, "resolved")= logi FALSE
  [22:14:09.583]  - attr(*, "total_size")= num NA
  [22:14:09.596] getGlobalsAndPackages() ...
  [22:14:09.596] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.597] Resolving globals: FALSE
  [22:14:09.598] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.598] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.599] 
  [22:14:09.599] getGlobalsAndPackages() ... DONE
  [22:14:09.599] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x272ff78>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.605] Packages needed by the future expression (n = 0): <none>
  [22:14:09.606] Packages needed by future strategies (n = 0): <none>
  [22:14:09.611] {
  [22:14:09.611]     {
  [22:14:09.611]         ...future.startTime <- Sys.time()
  [22:14:09.611]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.611]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.611]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.611]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.611]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.611]         {
  [22:14:09.611]             {
  [22:14:09.611]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.611]                 version <- if (has_future) 
  [22:14:09.611]                   packageVersion("future")
  [22:14:09.611]                 else NULL
  [22:14:09.611]                 if (!has_future || version < "1.8.0") {
  [22:14:09.611]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.611]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.611]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.611]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.611]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.611]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.611]                   info <- paste(info, collapse = "; ")
  [22:14:09.611]                   if (!has_future) {
  [22:14:09.611]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.611]                       info)
  [22:14:09.611]                   }
  [22:14:09.611]                   else {
  [22:14:09.611]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.611]                       info, version)
  [22:14:09.611]                   }
  [22:14:09.611]                   stop(msg)
  [22:14:09.611]                 }
  [22:14:09.611]             }
  [22:14:09.611]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.611]         }
  [22:14:09.611]     }
  [22:14:09.611]     if (is.na(TRUE)) {
  [22:14:09.611]     }
  [22:14:09.611]     else {
  [22:14:09.611]         if (TRUE) {
  [22:14:09.611]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.611]         }
  [22:14:09.611]         else {
  [22:14:09.611]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.611]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.611]         }
  [22:14:09.611]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.611]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.611]             sink(type = "output", split = FALSE)
  [22:14:09.611]             close(...future.stdout)
  [22:14:09.611]         }, add = TRUE)
  [22:14:09.611]     }
  [22:14:09.611]     ...future.frame <- sys.nframe()
  [22:14:09.611]     ...future.conditions <- list()
  [22:14:09.611]     ...future.result <- tryCatch({
  [22:14:09.611]         withCallingHandlers({
  [22:14:09.611]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.611]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.611]                 version = "1.8")
  [22:14:09.611]         }, condition = local({
  [22:14:09.611]             inherits <- base::inherits
  [22:14:09.611]             invokeRestart <- base::invokeRestart
  [22:14:09.611]             length <- base::length
  [22:14:09.611]             seq.int <- base::seq.int
  [22:14:09.611]             sys.calls <- base::sys.calls
  [22:14:09.611]             `[[` <- base::`[[`
  [22:14:09.611]             `+` <- base::`+`
  [22:14:09.611]             `<<-` <- base::`<<-`
  [22:14:09.611]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.611]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.611]                   3L)]
  [22:14:09.611]             }
  [22:14:09.611]             function(cond) {
  [22:14:09.611]                 if (inherits(cond, "error")) {
  [22:14:09.611]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.611]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.611]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.611]                     signaled = 0L)
  [22:14:09.611]                   signalCondition(cond)
  [22:14:09.611]                 }
  [22:14:09.611]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.611]                 ))) {
  [22:14:09.611]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.611]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.611]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.611]                   if (inherits(cond, "message")) {
  [22:14:09.611]                     if (!signal) 
  [22:14:09.611]                       invokeRestart("muffleMessage")
  [22:14:09.611]                   }
  [22:14:09.611]                   else if (inherits(cond, "warning")) {
  [22:14:09.611]                     if (!signal) 
  [22:14:09.611]                       invokeRestart("muffleWarning")
  [22:14:09.611]                   }
  [22:14:09.611]                   else {
  [22:14:09.611]                     if (!signal) {
  [22:14:09.611]                       restarts <- computeRestarts(cond)
  [22:14:09.611]                       for (restart in restarts) {
  [22:14:09.611]                         name <- restart$name
  [22:14:09.611]                         if (is.null(name)) 
  [22:14:09.611]                           next
  [22:14:09.611]                         if (!grepl("^muffle", name)) 
  [22:14:09.611]                           next
  [22:14:09.611]                         invokeRestart(restart)
  [22:14:09.611]                         break
  [22:14:09.611]                       }
  [22:14:09.611]                     }
  [22:14:09.611]                   }
  [22:14:09.611]                 }
  [22:14:09.611]             }
  [22:14:09.611]         }))
  [22:14:09.611]     }, error = function(ex) {
  [22:14:09.611]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.611]             version = "1.8"), class = "FutureResult")
  [22:14:09.611]     }, finally = {
  [22:14:09.611]         {
  [22:14:09.611]             NULL
  [22:14:09.611]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.611]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.611]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.611]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.611]                 ...) 
  [22:14:09.611]             {
  [22:14:09.611]                 if (substitute) 
  [22:14:09.611]                   expr <- substitute(expr)
  [22:14:09.611]                 if (is.function(workers)) 
  [22:14:09.611]                   workers <- workers()
  [22:14:09.611]                 workers <- as.integer(workers)
  [22:14:09.611]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.611]                   workers >= 1)
  [22:14:09.611]                 if (workers == 1L) {
  [22:14:09.611]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.611]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.611]                     local = TRUE, label = label, ...))
  [22:14:09.611]                 }
  [22:14:09.611]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.611]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.611]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.611]                   globals = globals, persistent = persistent, 
  [22:14:09.611]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.611]                   label = label, ...)
  [22:14:09.611]                 if (!future$lazy) 
  [22:14:09.611]                   future <- run(future)
  [22:14:09.611]                 invisible(future)
  [22:14:09.611]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.611]         }
  [22:14:09.611]         options(...future.oldOptions)
  [22:14:09.611]     })
  [22:14:09.611]     if (is.na(TRUE)) {
  [22:14:09.611]     }
  [22:14:09.611]     else {
  [22:14:09.611]         sink(type = "output", split = FALSE)
  [22:14:09.611]         if (TRUE) {
  [22:14:09.611]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.611]         }
  [22:14:09.611]         else {
  [22:14:09.611]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.611]         }
  [22:14:09.611]         close(...future.stdout)
  [22:14:09.611]         ...future.stdout <- NULL
  [22:14:09.611]     }
  [22:14:09.611]     ...future.result$conditions <- ...future.conditions
  [22:14:09.611]     ...future.result
  [22:14:09.611] }
  [22:14:09.614] plan(): Setting new future strategy stack:
  [22:14:09.615] List of future strategies:
  [22:14:09.615] 1. sequential:
  [22:14:09.615]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.615]    - tweaked: FALSE
  [22:14:09.615]    - call: NULL
  [22:14:09.616] plan(): nbrOfWorkers() = 1
  [22:14:09.617] plan(): Setting new future strategy stack:
  [22:14:09.617] List of future strategies:
  [22:14:09.617] 1. multisession:
  [22:14:09.617]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.617]    - tweaked: FALSE
  [22:14:09.617]    - call: plan(strategy)
  [22:14:09.619] plan(): nbrOfWorkers() = 1
  [22:14:09.619] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:09.630] futureCall() ...
  [22:14:09.630] Finding globals ...
  [22:14:09.630] getGlobalsAndPackages() ...
  [22:14:09.631] Searching for globals...
  [22:14:09.635] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:09.636] Searching for globals ... DONE
  [22:14:09.636] Resolving globals: FALSE
  [22:14:09.638] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:09.638] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.638] 
  [22:14:09.639] getGlobalsAndPackages() ... DONE
  [22:14:09.639]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:09.639] 
  [22:14:09.640] Finding globals ... DONE
  [22:14:09.640] Globals to be used in the future:
  [22:14:09.640] List of 3
  [22:14:09.640]  $ FUN :function (x, y)  
  [22:14:09.640]  $ args:List of 2
  [22:14:09.640]   ..$ x: num 42
  [22:14:09.640]   ..$ y: num 12
  [22:14:09.640]  $ a   : num 3
  [22:14:09.640]  - attr(*, "where")=List of 3
  [22:14:09.640]   ..$ FUN :<environment: 0x1e58660> 
  [22:14:09.640]   ..$ args:<environment: 0x16eb790> 
  [22:14:09.640]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.640]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.640]  - attr(*, "resolved")= logi FALSE
  [22:14:09.640]  - attr(*, "total_size")= num 2592
  [22:14:09.653] getGlobalsAndPackages() ...
  [22:14:09.653] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:09.654] Resolving globals: FALSE
  [22:14:09.655] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.655] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.656] 
  [22:14:09.656] getGlobalsAndPackages() ... DONE
  [22:14:09.656] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x16eb790>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.660] Packages needed by the future expression (n = 0): <none>
  [22:14:09.660] Packages needed by future strategies (n = 0): <none>
  [22:14:09.665] {
  [22:14:09.665]     {
  [22:14:09.665]         ...future.startTime <- Sys.time()
  [22:14:09.665]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.665]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.665]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.665]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.665]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.665]         {
  [22:14:09.665]             {
  [22:14:09.665]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.665]                 version <- if (has_future) 
  [22:14:09.665]                   packageVersion("future")
  [22:14:09.665]                 else NULL
  [22:14:09.665]                 if (!has_future || version < "1.8.0") {
  [22:14:09.665]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.665]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.665]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.665]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.665]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.665]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.665]                   info <- paste(info, collapse = "; ")
  [22:14:09.665]                   if (!has_future) {
  [22:14:09.665]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.665]                       info)
  [22:14:09.665]                   }
  [22:14:09.665]                   else {
  [22:14:09.665]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.665]                       info, version)
  [22:14:09.665]                   }
  [22:14:09.665]                   stop(msg)
  [22:14:09.665]                 }
  [22:14:09.665]             }
  [22:14:09.665]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.665]         }
  [22:14:09.665]     }
  [22:14:09.665]     if (is.na(TRUE)) {
  [22:14:09.665]     }
  [22:14:09.665]     else {
  [22:14:09.665]         if (TRUE) {
  [22:14:09.665]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.665]         }
  [22:14:09.665]         else {
  [22:14:09.665]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.665]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.665]         }
  [22:14:09.665]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.665]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.665]             sink(type = "output", split = FALSE)
  [22:14:09.665]             close(...future.stdout)
  [22:14:09.665]         }, add = TRUE)
  [22:14:09.665]     }
  [22:14:09.665]     ...future.frame <- sys.nframe()
  [22:14:09.665]     ...future.conditions <- list()
  [22:14:09.665]     ...future.result <- tryCatch({
  [22:14:09.665]         withCallingHandlers({
  [22:14:09.665]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.665]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.665]                 version = "1.8")
  [22:14:09.665]         }, condition = local({
  [22:14:09.665]             inherits <- base::inherits
  [22:14:09.665]             invokeRestart <- base::invokeRestart
  [22:14:09.665]             length <- base::length
  [22:14:09.665]             seq.int <- base::seq.int
  [22:14:09.665]             sys.calls <- base::sys.calls
  [22:14:09.665]             `[[` <- base::`[[`
  [22:14:09.665]             `+` <- base::`+`
  [22:14:09.665]             `<<-` <- base::`<<-`
  [22:14:09.665]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.665]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.665]                   3L)]
  [22:14:09.665]             }
  [22:14:09.665]             function(cond) {
  [22:14:09.665]                 if (inherits(cond, "error")) {
  [22:14:09.665]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.665]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.665]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.665]                     signaled = 0L)
  [22:14:09.665]                   signalCondition(cond)
  [22:14:09.665]                 }
  [22:14:09.665]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.665]                 ))) {
  [22:14:09.665]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.665]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.665]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.665]                   if (inherits(cond, "message")) {
  [22:14:09.665]                     if (!signal) 
  [22:14:09.665]                       invokeRestart("muffleMessage")
  [22:14:09.665]                   }
  [22:14:09.665]                   else if (inherits(cond, "warning")) {
  [22:14:09.665]                     if (!signal) 
  [22:14:09.665]                       invokeRestart("muffleWarning")
  [22:14:09.665]                   }
  [22:14:09.665]                   else {
  [22:14:09.665]                     if (!signal) {
  [22:14:09.665]                       restarts <- computeRestarts(cond)
  [22:14:09.665]                       for (restart in restarts) {
  [22:14:09.665]                         name <- restart$name
  [22:14:09.665]                         if (is.null(name)) 
  [22:14:09.665]                           next
  [22:14:09.665]                         if (!grepl("^muffle", name)) 
  [22:14:09.665]                           next
  [22:14:09.665]                         invokeRestart(restart)
  [22:14:09.665]                         break
  [22:14:09.665]                       }
  [22:14:09.665]                     }
  [22:14:09.665]                   }
  [22:14:09.665]                 }
  [22:14:09.665]             }
  [22:14:09.665]         }))
  [22:14:09.665]     }, error = function(ex) {
  [22:14:09.665]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.665]             version = "1.8"), class = "FutureResult")
  [22:14:09.665]     }, finally = {
  [22:14:09.665]         {
  [22:14:09.665]             NULL
  [22:14:09.665]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.665]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.665]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.665]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.665]                 ...) 
  [22:14:09.665]             {
  [22:14:09.665]                 if (substitute) 
  [22:14:09.665]                   expr <- substitute(expr)
  [22:14:09.665]                 if (is.function(workers)) 
  [22:14:09.665]                   workers <- workers()
  [22:14:09.665]                 workers <- as.integer(workers)
  [22:14:09.665]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.665]                   workers >= 1)
  [22:14:09.665]                 if (workers == 1L) {
  [22:14:09.665]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.665]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.665]                     local = TRUE, label = label, ...))
  [22:14:09.665]                 }
  [22:14:09.665]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.665]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.665]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.665]                   globals = globals, persistent = persistent, 
  [22:14:09.665]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.665]                   label = label, ...)
  [22:14:09.665]                 if (!future$lazy) 
  [22:14:09.665]                   future <- run(future)
  [22:14:09.665]                 invisible(future)
  [22:14:09.665]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.665]         }
  [22:14:09.665]         options(...future.oldOptions)
  [22:14:09.665]     })
  [22:14:09.665]     if (is.na(TRUE)) {
  [22:14:09.665]     }
  [22:14:09.665]     else {
  [22:14:09.665]         sink(type = "output", split = FALSE)
  [22:14:09.665]         if (TRUE) {
  [22:14:09.665]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.665]         }
  [22:14:09.665]         else {
  [22:14:09.665]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.665]         }
  [22:14:09.665]         close(...future.stdout)
  [22:14:09.665]         ...future.stdout <- NULL
  [22:14:09.665]     }
  [22:14:09.665]     ...future.result$conditions <- ...future.conditions
  [22:14:09.665]     ...future.result
  [22:14:09.665] }
  [22:14:09.668] plan(): Setting new future strategy stack:
  [22:14:09.669] List of future strategies:
  [22:14:09.669] 1. sequential:
  [22:14:09.669]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.669]    - tweaked: FALSE
  [22:14:09.669]    - call: NULL
  [22:14:09.670] plan(): nbrOfWorkers() = 1
  [22:14:09.670] plan(): Setting new future strategy stack:
  [22:14:09.671] List of future strategies:
  [22:14:09.671] 1. multisession:
  [22:14:09.671]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.671]    - tweaked: FALSE
  [22:14:09.671]    - call: plan(strategy)
  [22:14:09.672] plan(): nbrOfWorkers() = 1
  [22:14:09.673] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:09.678] futureCall() ...
  [22:14:09.679] Globals to be used in the future:
  [22:14:09.679] List of 3
  [22:14:09.679]  $ a   : num 3
  [22:14:09.679]  $ FUN :function (x, y)  
  [22:14:09.679]  $ args:List of 2
  [22:14:09.679]   ..$ x: num 42
  [22:14:09.679]   ..$ y: num 12
  [22:14:09.679]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.679]  - attr(*, "where")=List of 3
  [22:14:09.679]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.679]   ..$ FUN :<environment: 0x2d7a5a0> 
  [22:14:09.679]   ..$ args:<environment: 0x2cfd6c8> 
  [22:14:09.679]  - attr(*, "resolved")= logi FALSE
  [22:14:09.679]  - attr(*, "total_size")= num NA
  [22:14:09.742] getGlobalsAndPackages() ...
  [22:14:09.743] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.743] Resolving globals: FALSE
  [22:14:09.744] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.745] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.745] 
  [22:14:09.745] getGlobalsAndPackages() ... DONE
  [22:14:09.746] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2cfd6c8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.749] Packages needed by the future expression (n = 0): <none>
  [22:14:09.750] Packages needed by future strategies (n = 0): <none>
  [22:14:09.754] {
  [22:14:09.754]     {
  [22:14:09.754]         ...future.startTime <- Sys.time()
  [22:14:09.754]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.754]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.754]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.754]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.754]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.754]         {
  [22:14:09.754]             {
  [22:14:09.754]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.754]                 version <- if (has_future) 
  [22:14:09.754]                   packageVersion("future")
  [22:14:09.754]                 else NULL
  [22:14:09.754]                 if (!has_future || version < "1.8.0") {
  [22:14:09.754]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.754]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.754]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.754]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.754]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.754]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.754]                   info <- paste(info, collapse = "; ")
  [22:14:09.754]                   if (!has_future) {
  [22:14:09.754]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.754]                       info)
  [22:14:09.754]                   }
  [22:14:09.754]                   else {
  [22:14:09.754]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.754]                       info, version)
  [22:14:09.754]                   }
  [22:14:09.754]                   stop(msg)
  [22:14:09.754]                 }
  [22:14:09.754]             }
  [22:14:09.754]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.754]         }
  [22:14:09.754]     }
  [22:14:09.754]     if (is.na(TRUE)) {
  [22:14:09.754]     }
  [22:14:09.754]     else {
  [22:14:09.754]         if (TRUE) {
  [22:14:09.754]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.754]         }
  [22:14:09.754]         else {
  [22:14:09.754]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.754]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.754]         }
  [22:14:09.754]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.754]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.754]             sink(type = "output", split = FALSE)
  [22:14:09.754]             close(...future.stdout)
  [22:14:09.754]         }, add = TRUE)
  [22:14:09.754]     }
  [22:14:09.754]     ...future.frame <- sys.nframe()
  [22:14:09.754]     ...future.conditions <- list()
  [22:14:09.754]     ...future.result <- tryCatch({
  [22:14:09.754]         withCallingHandlers({
  [22:14:09.754]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.754]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.754]                 version = "1.8")
  [22:14:09.754]         }, condition = local({
  [22:14:09.754]             inherits <- base::inherits
  [22:14:09.754]             invokeRestart <- base::invokeRestart
  [22:14:09.754]             length <- base::length
  [22:14:09.754]             seq.int <- base::seq.int
  [22:14:09.754]             sys.calls <- base::sys.calls
  [22:14:09.754]             `[[` <- base::`[[`
  [22:14:09.754]             `+` <- base::`+`
  [22:14:09.754]             `<<-` <- base::`<<-`
  [22:14:09.754]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.754]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.754]                   3L)]
  [22:14:09.754]             }
  [22:14:09.754]             function(cond) {
  [22:14:09.754]                 if (inherits(cond, "error")) {
  [22:14:09.754]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.754]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.754]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.754]                     signaled = 0L)
  [22:14:09.754]                   signalCondition(cond)
  [22:14:09.754]                 }
  [22:14:09.754]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.754]                 ))) {
  [22:14:09.754]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.754]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.754]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.754]                   if (inherits(cond, "message")) {
  [22:14:09.754]                     if (!signal) 
  [22:14:09.754]                       invokeRestart("muffleMessage")
  [22:14:09.754]                   }
  [22:14:09.754]                   else if (inherits(cond, "warning")) {
  [22:14:09.754]                     if (!signal) 
  [22:14:09.754]                       invokeRestart("muffleWarning")
  [22:14:09.754]                   }
  [22:14:09.754]                   else {
  [22:14:09.754]                     if (!signal) {
  [22:14:09.754]                       restarts <- computeRestarts(cond)
  [22:14:09.754]                       for (restart in restarts) {
  [22:14:09.754]                         name <- restart$name
  [22:14:09.754]                         if (is.null(name)) 
  [22:14:09.754]                           next
  [22:14:09.754]                         if (!grepl("^muffle", name)) 
  [22:14:09.754]                           next
  [22:14:09.754]                         invokeRestart(restart)
  [22:14:09.754]                         break
  [22:14:09.754]                       }
  [22:14:09.754]                     }
  [22:14:09.754]                   }
  [22:14:09.754]                 }
  [22:14:09.754]             }
  [22:14:09.754]         }))
  [22:14:09.754]     }, error = function(ex) {
  [22:14:09.754]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.754]             version = "1.8"), class = "FutureResult")
  [22:14:09.754]     }, finally = {
  [22:14:09.754]         {
  [22:14:09.754]             NULL
  [22:14:09.754]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.754]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.754]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.754]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.754]                 ...) 
  [22:14:09.754]             {
  [22:14:09.754]                 if (substitute) 
  [22:14:09.754]                   expr <- substitute(expr)
  [22:14:09.754]                 if (is.function(workers)) 
  [22:14:09.754]                   workers <- workers()
  [22:14:09.754]                 workers <- as.integer(workers)
  [22:14:09.754]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.754]                   workers >= 1)
  [22:14:09.754]                 if (workers == 1L) {
  [22:14:09.754]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.754]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.754]                     local = TRUE, label = label, ...))
  [22:14:09.754]                 }
  [22:14:09.754]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.754]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.754]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.754]                   globals = globals, persistent = persistent, 
  [22:14:09.754]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.754]                   label = label, ...)
  [22:14:09.754]                 if (!future$lazy) 
  [22:14:09.754]                   future <- run(future)
  [22:14:09.754]                 invisible(future)
  [22:14:09.754]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.754]         }
  [22:14:09.754]         options(...future.oldOptions)
  [22:14:09.754]     })
  [22:14:09.754]     if (is.na(TRUE)) {
  [22:14:09.754]     }
  [22:14:09.754]     else {
  [22:14:09.754]         sink(type = "output", split = FALSE)
  [22:14:09.754]         if (TRUE) {
  [22:14:09.754]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.754]         }
  [22:14:09.754]         else {
  [22:14:09.754]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.754]         }
  [22:14:09.754]         close(...future.stdout)
  [22:14:09.754]         ...future.stdout <- NULL
  [22:14:09.754]     }
  [22:14:09.754]     ...future.result$conditions <- ...future.conditions
  [22:14:09.754]     ...future.result
  [22:14:09.754] }
  [22:14:09.758] plan(): Setting new future strategy stack:
  [22:14:09.758] List of future strategies:
  [22:14:09.758] 1. sequential:
  [22:14:09.758]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.758]    - tweaked: FALSE
  [22:14:09.758]    - call: NULL
  [22:14:09.759] plan(): nbrOfWorkers() = 1
  [22:14:09.760] plan(): Setting new future strategy stack:
  [22:14:09.760] List of future strategies:
  [22:14:09.760] 1. multisession:
  [22:14:09.760]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.760]    - tweaked: FALSE
  [22:14:09.760]    - call: plan(strategy)
  [22:14:09.762] plan(): nbrOfWorkers() = 1
  [22:14:09.762] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.768] futureCall() ...
  [22:14:09.768] Globals to be used in the future:
  [22:14:09.769] List of 3
  [22:14:09.769]  $ a   : num 3
  [22:14:09.769]  $ FUN :function (x, y)  
  [22:14:09.769]  $ args:List of 2
  [22:14:09.769]   ..$ x: num 42
  [22:14:09.769]   ..$ y: num 12
  [22:14:09.769]  - attr(*, "where")=List of 3
  [22:14:09.769]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.769]   ..$ FUN :<environment: 0x1dbce90> 
  [22:14:09.769]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.769]  - attr(*, "resolved")= logi FALSE
  [22:14:09.769]  - attr(*, "total_size")= num NA
  [22:14:09.781] getGlobalsAndPackages() ...
  [22:14:09.782] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.782] Resolving globals: FALSE
  [22:14:09.783] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.783] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.784] 
  [22:14:09.784] getGlobalsAndPackages() ... DONE
  [22:14:09.784] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0xbda6f8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.788] Packages needed by the future expression (n = 0): <none>
  [22:14:09.790] Packages needed by future strategies (n = 0): <none>
  [22:14:09.794] {
  [22:14:09.794]     {
  [22:14:09.794]         ...future.startTime <- Sys.time()
  [22:14:09.794]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.794]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.794]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.794]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.794]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.794]         {
  [22:14:09.794]             {
  [22:14:09.794]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.794]                 version <- if (has_future) 
  [22:14:09.794]                   packageVersion("future")
  [22:14:09.794]                 else NULL
  [22:14:09.794]                 if (!has_future || version < "1.8.0") {
  [22:14:09.794]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.794]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.794]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.794]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.794]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.794]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.794]                   info <- paste(info, collapse = "; ")
  [22:14:09.794]                   if (!has_future) {
  [22:14:09.794]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.794]                       info)
  [22:14:09.794]                   }
  [22:14:09.794]                   else {
  [22:14:09.794]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.794]                       info, version)
  [22:14:09.794]                   }
  [22:14:09.794]                   stop(msg)
  [22:14:09.794]                 }
  [22:14:09.794]             }
  [22:14:09.794]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.794]         }
  [22:14:09.794]     }
  [22:14:09.794]     if (is.na(TRUE)) {
  [22:14:09.794]     }
  [22:14:09.794]     else {
  [22:14:09.794]         if (TRUE) {
  [22:14:09.794]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.794]         }
  [22:14:09.794]         else {
  [22:14:09.794]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.794]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.794]         }
  [22:14:09.794]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.794]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.794]             sink(type = "output", split = FALSE)
  [22:14:09.794]             close(...future.stdout)
  [22:14:09.794]         }, add = TRUE)
  [22:14:09.794]     }
  [22:14:09.794]     ...future.frame <- sys.nframe()
  [22:14:09.794]     ...future.conditions <- list()
  [22:14:09.794]     ...future.result <- tryCatch({
  [22:14:09.794]         withCallingHandlers({
  [22:14:09.794]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.794]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.794]                 version = "1.8")
  [22:14:09.794]         }, condition = local({
  [22:14:09.794]             inherits <- base::inherits
  [22:14:09.794]             invokeRestart <- base::invokeRestart
  [22:14:09.794]             length <- base::length
  [22:14:09.794]             seq.int <- base::seq.int
  [22:14:09.794]             sys.calls <- base::sys.calls
  [22:14:09.794]             `[[` <- base::`[[`
  [22:14:09.794]             `+` <- base::`+`
  [22:14:09.794]             `<<-` <- base::`<<-`
  [22:14:09.794]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.794]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.794]                   3L)]
  [22:14:09.794]             }
  [22:14:09.794]             function(cond) {
  [22:14:09.794]                 if (inherits(cond, "error")) {
  [22:14:09.794]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.794]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.794]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.794]                     signaled = 0L)
  [22:14:09.794]                   signalCondition(cond)
  [22:14:09.794]                 }
  [22:14:09.794]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.794]                 ))) {
  [22:14:09.794]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.794]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.794]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.794]                   if (inherits(cond, "message")) {
  [22:14:09.794]                     if (!signal) 
  [22:14:09.794]                       invokeRestart("muffleMessage")
  [22:14:09.794]                   }
  [22:14:09.794]                   else if (inherits(cond, "warning")) {
  [22:14:09.794]                     if (!signal) 
  [22:14:09.794]                       invokeRestart("muffleWarning")
  [22:14:09.794]                   }
  [22:14:09.794]                   else {
  [22:14:09.794]                     if (!signal) {
  [22:14:09.794]                       restarts <- computeRestarts(cond)
  [22:14:09.794]                       for (restart in restarts) {
  [22:14:09.794]                         name <- restart$name
  [22:14:09.794]                         if (is.null(name)) 
  [22:14:09.794]                           next
  [22:14:09.794]                         if (!grepl("^muffle", name)) 
  [22:14:09.794]                           next
  [22:14:09.794]                         invokeRestart(restart)
  [22:14:09.794]                         break
  [22:14:09.794]                       }
  [22:14:09.794]                     }
  [22:14:09.794]                   }
  [22:14:09.794]                 }
  [22:14:09.794]             }
  [22:14:09.794]         }))
  [22:14:09.794]     }, error = function(ex) {
  [22:14:09.794]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.794]             version = "1.8"), class = "FutureResult")
  [22:14:09.794]     }, finally = {
  [22:14:09.794]         {
  [22:14:09.794]             NULL
  [22:14:09.794]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.794]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.794]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.794]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.794]                 ...) 
  [22:14:09.794]             {
  [22:14:09.794]                 if (substitute) 
  [22:14:09.794]                   expr <- substitute(expr)
  [22:14:09.794]                 if (is.function(workers)) 
  [22:14:09.794]                   workers <- workers()
  [22:14:09.794]                 workers <- as.integer(workers)
  [22:14:09.794]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.794]                   workers >= 1)
  [22:14:09.794]                 if (workers == 1L) {
  [22:14:09.794]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.794]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.794]                     local = TRUE, label = label, ...))
  [22:14:09.794]                 }
  [22:14:09.794]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.794]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.794]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.794]                   globals = globals, persistent = persistent, 
  [22:14:09.794]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.794]                   label = label, ...)
  [22:14:09.794]                 if (!future$lazy) 
  [22:14:09.794]                   future <- run(future)
  [22:14:09.794]                 invisible(future)
  [22:14:09.794]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.794]         }
  [22:14:09.794]         options(...future.oldOptions)
  [22:14:09.794]     })
  [22:14:09.794]     if (is.na(TRUE)) {
  [22:14:09.794]     }
  [22:14:09.794]     else {
  [22:14:09.794]         sink(type = "output", split = FALSE)
  [22:14:09.794]         if (TRUE) {
  [22:14:09.794]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.794]         }
  [22:14:09.794]         else {
  [22:14:09.794]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.794]         }
  [22:14:09.794]         close(...future.stdout)
  [22:14:09.794]         ...future.stdout <- NULL
  [22:14:09.794]     }
  [22:14:09.794]     ...future.result$conditions <- ...future.conditions
  [22:14:09.794]     ...future.result
  [22:14:09.794] }
  [22:14:09.798] plan(): Setting new future strategy stack:
  [22:14:09.798] List of future strategies:
  [22:14:09.798] 1. sequential:
  [22:14:09.798]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.798]    - tweaked: FALSE
  [22:14:09.798]    - call: NULL
  [22:14:09.799] plan(): nbrOfWorkers() = 1
  [22:14:09.800] plan(): Setting new future strategy stack:
  [22:14:09.801] List of future strategies:
  [22:14:09.801] 1. multisession:
  [22:14:09.801]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.801]    - tweaked: FALSE
  [22:14:09.801]    - call: plan(strategy)
  [22:14:09.802] plan(): nbrOfWorkers() = 1
  [22:14:09.804] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:09.810] futureCall() ...
  [22:14:09.810] Globals to be used in the future:
  [22:14:09.811] List of 2
  [22:14:09.811]  $ FUN :function (x, y)  
  [22:14:09.811]  $ args:List of 2
  [22:14:09.811]   ..$ x: num 42
  [22:14:09.811]   ..$ y: num 12
  [22:14:09.811]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.811]  - attr(*, "where")=List of 2
  [22:14:09.811]   ..$ FUN :<environment: 0x2ea4dd0> 
  [22:14:09.811]   ..$ args:<environment: 0x2ea4dd0> 
  [22:14:09.811]  - attr(*, "resolved")= logi FALSE
  [22:14:09.811]  - attr(*, "total_size")= num NA
  [22:14:09.826] getGlobalsAndPackages() ...
  [22:14:09.827] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:09.827] Resolving globals: FALSE
  [22:14:09.828] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:09.829] - globals: [2] 'FUN', 'args'
  [22:14:09.829] 
  [22:14:09.829] getGlobalsAndPackages() ... DONE
  [22:14:09.830] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2ea4dd0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.833] Packages needed by the future expression (n = 0): <none>
  [22:14:09.834] Packages needed by future strategies (n = 0): <none>
  [22:14:09.838] {
  [22:14:09.838]     {
  [22:14:09.838]         ...future.startTime <- Sys.time()
  [22:14:09.838]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.838]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.838]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.838]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.838]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.838]         {
  [22:14:09.838]             {
  [22:14:09.838]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.838]                 version <- if (has_future) 
  [22:14:09.838]                   packageVersion("future")
  [22:14:09.838]                 else NULL
  [22:14:09.838]                 if (!has_future || version < "1.8.0") {
  [22:14:09.838]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.838]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.838]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.838]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.838]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.838]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.838]                   info <- paste(info, collapse = "; ")
  [22:14:09.838]                   if (!has_future) {
  [22:14:09.838]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.838]                       info)
  [22:14:09.838]                   }
  [22:14:09.838]                   else {
  [22:14:09.838]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.838]                       info, version)
  [22:14:09.838]                   }
  [22:14:09.838]                   stop(msg)
  [22:14:09.838]                 }
  [22:14:09.838]             }
  [22:14:09.838]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.838]         }
  [22:14:09.838]     }
  [22:14:09.838]     if (is.na(TRUE)) {
  [22:14:09.838]     }
  [22:14:09.838]     else {
  [22:14:09.838]         if (TRUE) {
  [22:14:09.838]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.838]         }
  [22:14:09.838]         else {
  [22:14:09.838]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.838]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.838]         }
  [22:14:09.838]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.838]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.838]             sink(type = "output", split = FALSE)
  [22:14:09.838]             close(...future.stdout)
  [22:14:09.838]         }, add = TRUE)
  [22:14:09.838]     }
  [22:14:09.838]     ...future.frame <- sys.nframe()
  [22:14:09.838]     ...future.conditions <- list()
  [22:14:09.838]     ...future.result <- tryCatch({
  [22:14:09.838]         withCallingHandlers({
  [22:14:09.838]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.838]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.838]                 version = "1.8")
  [22:14:09.838]         }, condition = local({
  [22:14:09.838]             inherits <- base::inherits
  [22:14:09.838]             invokeRestart <- base::invokeRestart
  [22:14:09.838]             length <- base::length
  [22:14:09.838]             seq.int <- base::seq.int
  [22:14:09.838]             sys.calls <- base::sys.calls
  [22:14:09.838]             `[[` <- base::`[[`
  [22:14:09.838]             `+` <- base::`+`
  [22:14:09.838]             `<<-` <- base::`<<-`
  [22:14:09.838]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.838]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.838]                   3L)]
  [22:14:09.838]             }
  [22:14:09.838]             function(cond) {
  [22:14:09.838]                 if (inherits(cond, "error")) {
  [22:14:09.838]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.838]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.838]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.838]                     signaled = 0L)
  [22:14:09.838]                   signalCondition(cond)
  [22:14:09.838]                 }
  [22:14:09.838]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.838]                 ))) {
  [22:14:09.838]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.838]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.838]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.838]                   if (inherits(cond, "message")) {
  [22:14:09.838]                     if (!signal) 
  [22:14:09.838]                       invokeRestart("muffleMessage")
  [22:14:09.838]                   }
  [22:14:09.838]                   else if (inherits(cond, "warning")) {
  [22:14:09.838]                     if (!signal) 
  [22:14:09.838]                       invokeRestart("muffleWarning")
  [22:14:09.838]                   }
  [22:14:09.838]                   else {
  [22:14:09.838]                     if (!signal) {
  [22:14:09.838]                       restarts <- computeRestarts(cond)
  [22:14:09.838]                       for (restart in restarts) {
  [22:14:09.838]                         name <- restart$name
  [22:14:09.838]                         if (is.null(name)) 
  [22:14:09.838]                           next
  [22:14:09.838]                         if (!grepl("^muffle", name)) 
  [22:14:09.838]                           next
  [22:14:09.838]                         invokeRestart(restart)
  [22:14:09.838]                         break
  [22:14:09.838]                       }
  [22:14:09.838]                     }
  [22:14:09.838]                   }
  [22:14:09.838]                 }
  [22:14:09.838]             }
  [22:14:09.838]         }))
  [22:14:09.838]     }, error = function(ex) {
  [22:14:09.838]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.838]             version = "1.8"), class = "FutureResult")
  [22:14:09.838]     }, finally = {
  [22:14:09.838]         {
  [22:14:09.838]             NULL
  [22:14:09.838]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.838]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.838]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.838]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.838]                 ...) 
  [22:14:09.838]             {
  [22:14:09.838]                 if (substitute) 
  [22:14:09.838]                   expr <- substitute(expr)
  [22:14:09.838]                 if (is.function(workers)) 
  [22:14:09.838]                   workers <- workers()
  [22:14:09.838]                 workers <- as.integer(workers)
  [22:14:09.838]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.838]                   workers >= 1)
  [22:14:09.838]                 if (workers == 1L) {
  [22:14:09.838]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.838]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.838]                     local = TRUE, label = label, ...))
  [22:14:09.838]                 }
  [22:14:09.838]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.838]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.838]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.838]                   globals = globals, persistent = persistent, 
  [22:14:09.838]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.838]                   label = label, ...)
  [22:14:09.838]                 if (!future$lazy) 
  [22:14:09.838]                   future <- run(future)
  [22:14:09.838]                 invisible(future)
  [22:14:09.838]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.838]         }
  [22:14:09.838]         options(...future.oldOptions)
  [22:14:09.838]     })
  [22:14:09.838]     if (is.na(TRUE)) {
  [22:14:09.838]     }
  [22:14:09.838]     else {
  [22:14:09.838]         sink(type = "output", split = FALSE)
  [22:14:09.838]         if (TRUE) {
  [22:14:09.838]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.838]         }
  [22:14:09.838]         else {
  [22:14:09.838]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.838]         }
  [22:14:09.838]         close(...future.stdout)
  [22:14:09.838]         ...future.stdout <- NULL
  [22:14:09.838]     }
  [22:14:09.838]     ...future.result$conditions <- ...future.conditions
  [22:14:09.838]     ...future.result
  [22:14:09.838] }
  [22:14:09.842] plan(): Setting new future strategy stack:
  [22:14:09.843] List of future strategies:
  [22:14:09.843] 1. sequential:
  [22:14:09.843]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.843]    - tweaked: FALSE
  [22:14:09.843]    - call: NULL
  [22:14:09.843] plan(): nbrOfWorkers() = 1
  [22:14:09.845] plan(): Setting new future strategy stack:
  [22:14:09.845] List of future strategies:
  [22:14:09.845] 1. multisession:
  [22:14:09.845]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.845]    - tweaked: FALSE
  [22:14:09.845]    - call: plan(strategy)
  [22:14:09.846] plan(): nbrOfWorkers() = 1
  [22:14:09.847] SequentialFuture started (and completed)
  [22:14:09.847] signalConditions() ...
  [22:14:09.847]  - include = 'immediateCondition'
  [22:14:09.848]  - exclude = 
  [22:14:09.848]  - resignal = FALSE
  [22:14:09.848]  - Number of conditions: 1
  [22:14:09.849] signalConditions() ... done
  [22:14:09.849] signalConditions() ...
  [22:14:09.849]  - include = 'immediateCondition'
  [22:14:09.850]  - exclude = 
  [22:14:09.850]  - resignal = FALSE
  [22:14:09.850]  - Number of conditions: 1
  [22:14:09.850] signalConditions() ... done
  [22:14:09.851] Future state: 'finished'
  [22:14:09.851] signalConditions() ...
  [22:14:09.851]  - include = 'condition'
  [22:14:09.852]  - exclude = 'immediateCondition'
  [22:14:09.852]  - resignal = TRUE
  [22:14:09.852]  - Number of conditions: 1
  [22:14:09.852]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:09.853] signalConditions() ... done
  [22:14:09.853] futureCall() ...
  [22:14:09.854] Globals to be used in the future:
  [22:14:09.854] List of 3
  [22:14:09.854]  $ a   : num 3
  [22:14:09.854]  $ FUN :function (x, y)  
  [22:14:09.854]  $ args:List of 2
  [22:14:09.854]   ..$ x: num 42
  [22:14:09.854]   ..$ y: num 12
  [22:14:09.854]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.854]  - attr(*, "where")=List of 3
  [22:14:09.854]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.854]   ..$ FUN :<environment: 0x1bcb4b8> 
  [22:14:09.854]   ..$ args:<environment: 0x1e31460> 
  [22:14:09.854]  - attr(*, "resolved")= logi FALSE
  [22:14:09.854]  - attr(*, "total_size")= num NA
  [22:14:09.867] getGlobalsAndPackages() ...
  [22:14:09.867] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.868] Resolving globals: FALSE
  [22:14:09.869] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.869] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.870] 
  [22:14:09.870] getGlobalsAndPackages() ... DONE
  [22:14:09.870] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1e31460>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.874] Packages needed by the future expression (n = 0): <none>
  [22:14:09.874] Packages needed by future strategies (n = 0): <none>
  [22:14:09.879] {
  [22:14:09.879]     {
  [22:14:09.879]         ...future.startTime <- Sys.time()
  [22:14:09.879]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.879]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.879]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.879]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.879]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.879]         {
  [22:14:09.879]             {
  [22:14:09.879]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.879]                 version <- if (has_future) 
  [22:14:09.879]                   packageVersion("future")
  [22:14:09.879]                 else NULL
  [22:14:09.879]                 if (!has_future || version < "1.8.0") {
  [22:14:09.879]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.879]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.879]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.879]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.879]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.879]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.879]                   info <- paste(info, collapse = "; ")
  [22:14:09.879]                   if (!has_future) {
  [22:14:09.879]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.879]                       info)
  [22:14:09.879]                   }
  [22:14:09.879]                   else {
  [22:14:09.879]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.879]                       info, version)
  [22:14:09.879]                   }
  [22:14:09.879]                   stop(msg)
  [22:14:09.879]                 }
  [22:14:09.879]             }
  [22:14:09.879]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.879]         }
  [22:14:09.879]     }
  [22:14:09.879]     if (is.na(TRUE)) {
  [22:14:09.879]     }
  [22:14:09.879]     else {
  [22:14:09.879]         if (TRUE) {
  [22:14:09.879]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.879]         }
  [22:14:09.879]         else {
  [22:14:09.879]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.879]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.879]         }
  [22:14:09.879]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.879]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.879]             sink(type = "output", split = FALSE)
  [22:14:09.879]             close(...future.stdout)
  [22:14:09.879]         }, add = TRUE)
  [22:14:09.879]     }
  [22:14:09.879]     ...future.frame <- sys.nframe()
  [22:14:09.879]     ...future.conditions <- list()
  [22:14:09.879]     ...future.result <- tryCatch({
  [22:14:09.879]         withCallingHandlers({
  [22:14:09.879]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.879]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.879]                 version = "1.8")
  [22:14:09.879]         }, condition = local({
  [22:14:09.879]             inherits <- base::inherits
  [22:14:09.879]             invokeRestart <- base::invokeRestart
  [22:14:09.879]             length <- base::length
  [22:14:09.879]             seq.int <- base::seq.int
  [22:14:09.879]             sys.calls <- base::sys.calls
  [22:14:09.879]             `[[` <- base::`[[`
  [22:14:09.879]             `+` <- base::`+`
  [22:14:09.879]             `<<-` <- base::`<<-`
  [22:14:09.879]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.879]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.879]                   3L)]
  [22:14:09.879]             }
  [22:14:09.879]             function(cond) {
  [22:14:09.879]                 if (inherits(cond, "error")) {
  [22:14:09.879]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.879]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.879]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.879]                     signaled = 0L)
  [22:14:09.879]                   signalCondition(cond)
  [22:14:09.879]                 }
  [22:14:09.879]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.879]                 ))) {
  [22:14:09.879]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.879]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.879]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.879]                   if (inherits(cond, "message")) {
  [22:14:09.879]                     if (!signal) 
  [22:14:09.879]                       invokeRestart("muffleMessage")
  [22:14:09.879]                   }
  [22:14:09.879]                   else if (inherits(cond, "warning")) {
  [22:14:09.879]                     if (!signal) 
  [22:14:09.879]                       invokeRestart("muffleWarning")
  [22:14:09.879]                   }
  [22:14:09.879]                   else {
  [22:14:09.879]                     if (!signal) {
  [22:14:09.879]                       restarts <- computeRestarts(cond)
  [22:14:09.879]                       for (restart in restarts) {
  [22:14:09.879]                         name <- restart$name
  [22:14:09.879]                         if (is.null(name)) 
  [22:14:09.879]                           next
  [22:14:09.879]                         if (!grepl("^muffle", name)) 
  [22:14:09.879]                           next
  [22:14:09.879]                         invokeRestart(restart)
  [22:14:09.879]                         break
  [22:14:09.879]                       }
  [22:14:09.879]                     }
  [22:14:09.879]                   }
  [22:14:09.879]                 }
  [22:14:09.879]             }
  [22:14:09.879]         }))
  [22:14:09.879]     }, error = function(ex) {
  [22:14:09.879]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.879]             version = "1.8"), class = "FutureResult")
  [22:14:09.879]     }, finally = {
  [22:14:09.879]         {
  [22:14:09.879]             NULL
  [22:14:09.879]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.879]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.879]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.879]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.879]                 ...) 
  [22:14:09.879]             {
  [22:14:09.879]                 if (substitute) 
  [22:14:09.879]                   expr <- substitute(expr)
  [22:14:09.879]                 if (is.function(workers)) 
  [22:14:09.879]                   workers <- workers()
  [22:14:09.879]                 workers <- as.integer(workers)
  [22:14:09.879]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.879]                   workers >= 1)
  [22:14:09.879]                 if (workers == 1L) {
  [22:14:09.879]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.879]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.879]                     local = TRUE, label = label, ...))
  [22:14:09.879]                 }
  [22:14:09.879]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.879]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.879]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.879]                   globals = globals, persistent = persistent, 
  [22:14:09.879]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.879]                   label = label, ...)
  [22:14:09.879]                 if (!future$lazy) 
  [22:14:09.879]                   future <- run(future)
  [22:14:09.879]                 invisible(future)
  [22:14:09.879]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.879]         }
  [22:14:09.879]         options(...future.oldOptions)
  [22:14:09.879]     })
  [22:14:09.879]     if (is.na(TRUE)) {
  [22:14:09.879]     }
  [22:14:09.879]     else {
  [22:14:09.879]         sink(type = "output", split = FALSE)
  [22:14:09.879]         if (TRUE) {
  [22:14:09.879]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.879]         }
  [22:14:09.879]         else {
  [22:14:09.879]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.879]         }
  [22:14:09.879]         close(...future.stdout)
  [22:14:09.879]         ...future.stdout <- NULL
  [22:14:09.879]     }
  [22:14:09.879]     ...future.result$conditions <- ...future.conditions
  [22:14:09.879]     ...future.result
  [22:14:09.879] }
  [22:14:09.882] plan(): Setting new future strategy stack:
  [22:14:09.883] List of future strategies:
  [22:14:09.883] 1. sequential:
  [22:14:09.883]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.883]    - tweaked: FALSE
  [22:14:09.883]    - call: NULL
  [22:14:09.884] plan(): nbrOfWorkers() = 1
  [22:14:09.885] plan(): Setting new future strategy stack:
  [22:14:09.886] List of future strategies:
  [22:14:09.886] 1. multisession:
  [22:14:09.886]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.886]    - tweaked: FALSE
  [22:14:09.886]    - call: plan(strategy)
  [22:14:09.887] plan(): nbrOfWorkers() = 1
  [22:14:09.887] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:09.892] futureCall() ...
  [22:14:09.893] Globals to be used in the future:
  [22:14:09.893] List of 3
  [22:14:09.893]  $ a   : num 3
  [22:14:09.893]  $ FUN :function (x, y)  
  [22:14:09.893]  $ args:List of 2
  [22:14:09.893]   ..$ x: num 42
  [22:14:09.893]   ..$ y: num 12
  [22:14:09.893]  - attr(*, "where")=List of 3
  [22:14:09.893]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:09.893]   ..$ FUN :<environment: 0x2f1b2a0> 
  [22:14:09.893]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:09.893]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.893]  - attr(*, "resolved")= logi FALSE
  [22:14:09.893]  - attr(*, "total_size")= num NA
  [22:14:09.910] getGlobalsAndPackages() ...
  [22:14:09.911] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:09.911] Resolving globals: FALSE
  [22:14:09.912] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.913] - globals: [3] 'a', 'FUN', 'args'
  [22:14:09.913] 
  [22:14:09.913] getGlobalsAndPackages() ... DONE
  [22:14:09.914] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2effe88>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.917] Packages needed by the future expression (n = 0): <none>
  [22:14:09.918] Packages needed by future strategies (n = 0): <none>
  [22:14:09.922] {
  [22:14:09.922]     {
  [22:14:09.922]         ...future.startTime <- Sys.time()
  [22:14:09.922]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.922]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.922]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.922]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.922]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.922]         {
  [22:14:09.922]             {
  [22:14:09.922]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.922]                 version <- if (has_future) 
  [22:14:09.922]                   packageVersion("future")
  [22:14:09.922]                 else NULL
  [22:14:09.922]                 if (!has_future || version < "1.8.0") {
  [22:14:09.922]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.922]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.922]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.922]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.922]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.922]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.922]                   info <- paste(info, collapse = "; ")
  [22:14:09.922]                   if (!has_future) {
  [22:14:09.922]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.922]                       info)
  [22:14:09.922]                   }
  [22:14:09.922]                   else {
  [22:14:09.922]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.922]                       info, version)
  [22:14:09.922]                   }
  [22:14:09.922]                   stop(msg)
  [22:14:09.922]                 }
  [22:14:09.922]             }
  [22:14:09.922]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.922]         }
  [22:14:09.922]     }
  [22:14:09.922]     if (is.na(TRUE)) {
  [22:14:09.922]     }
  [22:14:09.922]     else {
  [22:14:09.922]         if (TRUE) {
  [22:14:09.922]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.922]         }
  [22:14:09.922]         else {
  [22:14:09.922]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.922]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.922]         }
  [22:14:09.922]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.922]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.922]             sink(type = "output", split = FALSE)
  [22:14:09.922]             close(...future.stdout)
  [22:14:09.922]         }, add = TRUE)
  [22:14:09.922]     }
  [22:14:09.922]     ...future.frame <- sys.nframe()
  [22:14:09.922]     ...future.conditions <- list()
  [22:14:09.922]     ...future.result <- tryCatch({
  [22:14:09.922]         withCallingHandlers({
  [22:14:09.922]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.922]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.922]                 version = "1.8")
  [22:14:09.922]         }, condition = local({
  [22:14:09.922]             inherits <- base::inherits
  [22:14:09.922]             invokeRestart <- base::invokeRestart
  [22:14:09.922]             length <- base::length
  [22:14:09.922]             seq.int <- base::seq.int
  [22:14:09.922]             sys.calls <- base::sys.calls
  [22:14:09.922]             `[[` <- base::`[[`
  [22:14:09.922]             `+` <- base::`+`
  [22:14:09.922]             `<<-` <- base::`<<-`
  [22:14:09.922]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.922]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.922]                   3L)]
  [22:14:09.922]             }
  [22:14:09.922]             function(cond) {
  [22:14:09.922]                 if (inherits(cond, "error")) {
  [22:14:09.922]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.922]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.922]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.922]                     signaled = 0L)
  [22:14:09.922]                   signalCondition(cond)
  [22:14:09.922]                 }
  [22:14:09.922]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.922]                 ))) {
  [22:14:09.922]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.922]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.922]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.922]                   if (inherits(cond, "message")) {
  [22:14:09.922]                     if (!signal) 
  [22:14:09.922]                       invokeRestart("muffleMessage")
  [22:14:09.922]                   }
  [22:14:09.922]                   else if (inherits(cond, "warning")) {
  [22:14:09.922]                     if (!signal) 
  [22:14:09.922]                       invokeRestart("muffleWarning")
  [22:14:09.922]                   }
  [22:14:09.922]                   else {
  [22:14:09.922]                     if (!signal) {
  [22:14:09.922]                       restarts <- computeRestarts(cond)
  [22:14:09.922]                       for (restart in restarts) {
  [22:14:09.922]                         name <- restart$name
  [22:14:09.922]                         if (is.null(name)) 
  [22:14:09.922]                           next
  [22:14:09.922]                         if (!grepl("^muffle", name)) 
  [22:14:09.922]                           next
  [22:14:09.922]                         invokeRestart(restart)
  [22:14:09.922]                         break
  [22:14:09.922]                       }
  [22:14:09.922]                     }
  [22:14:09.922]                   }
  [22:14:09.922]                 }
  [22:14:09.922]             }
  [22:14:09.922]         }))
  [22:14:09.922]     }, error = function(ex) {
  [22:14:09.922]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.922]             version = "1.8"), class = "FutureResult")
  [22:14:09.922]     }, finally = {
  [22:14:09.922]         {
  [22:14:09.922]             NULL
  [22:14:09.922]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.922]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.922]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.922]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.922]                 ...) 
  [22:14:09.922]             {
  [22:14:09.922]                 if (substitute) 
  [22:14:09.922]                   expr <- substitute(expr)
  [22:14:09.922]                 if (is.function(workers)) 
  [22:14:09.922]                   workers <- workers()
  [22:14:09.922]                 workers <- as.integer(workers)
  [22:14:09.922]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.922]                   workers >= 1)
  [22:14:09.922]                 if (workers == 1L) {
  [22:14:09.922]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.922]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.922]                     local = TRUE, label = label, ...))
  [22:14:09.922]                 }
  [22:14:09.922]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.922]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.922]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.922]                   globals = globals, persistent = persistent, 
  [22:14:09.922]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.922]                   label = label, ...)
  [22:14:09.922]                 if (!future$lazy) 
  [22:14:09.922]                   future <- run(future)
  [22:14:09.922]                 invisible(future)
  [22:14:09.922]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.922]         }
  [22:14:09.922]         options(...future.oldOptions)
  [22:14:09.922]     })
  [22:14:09.922]     if (is.na(TRUE)) {
  [22:14:09.922]     }
  [22:14:09.922]     else {
  [22:14:09.922]         sink(type = "output", split = FALSE)
  [22:14:09.922]         if (TRUE) {
  [22:14:09.922]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.922]         }
  [22:14:09.922]         else {
  [22:14:09.922]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.922]         }
  [22:14:09.922]         close(...future.stdout)
  [22:14:09.922]         ...future.stdout <- NULL
  [22:14:09.922]     }
  [22:14:09.922]     ...future.result$conditions <- ...future.conditions
  [22:14:09.922]     ...future.result
  [22:14:09.922] }
  [22:14:09.926] plan(): Setting new future strategy stack:
  [22:14:09.926] List of future strategies:
  [22:14:09.926] 1. sequential:
  [22:14:09.926]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.926]    - tweaked: FALSE
  [22:14:09.926]    - call: NULL
  [22:14:09.927] plan(): nbrOfWorkers() = 1
  [22:14:09.928] plan(): Setting new future strategy stack:
  [22:14:09.929] List of future strategies:
  [22:14:09.929] 1. multisession:
  [22:14:09.929]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.929]    - tweaked: FALSE
  [22:14:09.929]    - call: plan(strategy)
  [22:14:09.930] plan(): nbrOfWorkers() = 1
  [22:14:09.931] SequentialFuture started (and completed)
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:09.936] futureCall() ...
  [22:14:09.937] Finding globals ...
  [22:14:09.937] getGlobalsAndPackages() ...
  [22:14:09.937] Searching for globals...
  [22:14:09.942] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:09.942] Searching for globals ... DONE
  [22:14:09.943] Resolving globals: FALSE
  [22:14:09.944] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:09.945] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.945] 
  [22:14:09.945] getGlobalsAndPackages() ... DONE
  [22:14:09.946]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:09.946] 
  [22:14:09.946] Finding globals ... DONE
  [22:14:09.947] Globals to be used in the future:
  [22:14:09.947] List of 3
  [22:14:09.947]  $ FUN :function (x, y)  
  [22:14:09.947]  $ args:List of 2
  [22:14:09.947]   ..$ x: num 42
  [22:14:09.947]   ..$ y: num 12
  [22:14:09.947]  $ a   : num 3
  [22:14:09.947]  - attr(*, "where")=List of 3
  [22:14:09.947]   ..$ FUN :<environment: 0x2961a88> 
  [22:14:09.947]   ..$ args:<environment: 0x1c6bdb8> 
  [22:14:09.947]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.947]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.947]  - attr(*, "resolved")= logi FALSE
  [22:14:09.947]  - attr(*, "total_size")= num 2592
  [22:14:09.960] getGlobalsAndPackages() ...
  [22:14:09.961] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:09.961] Resolving globals: FALSE
  [22:14:09.962] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:09.963] - globals: [3] 'FUN', 'args', 'a'
  [22:14:09.963] 
  [22:14:09.963] getGlobalsAndPackages() ... DONE
  [22:14:09.964] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1c6bdb8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:09.967] Packages needed by the future expression (n = 0): <none>
  [22:14:09.968] Packages needed by future strategies (n = 0): <none>
  [22:14:09.972] {
  [22:14:09.972]     {
  [22:14:09.972]         ...future.startTime <- Sys.time()
  [22:14:09.972]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:09.972]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:09.972]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:09.972]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:09.972]             future.resolve.recursive = NULL, width = 80L)
  [22:14:09.972]         {
  [22:14:09.972]             {
  [22:14:09.972]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:09.972]                 version <- if (has_future) 
  [22:14:09.972]                   packageVersion("future")
  [22:14:09.972]                 else NULL
  [22:14:09.972]                 if (!has_future || version < "1.8.0") {
  [22:14:09.972]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:09.972]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:09.972]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:09.972]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:09.972]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:09.972]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:09.972]                   info <- paste(info, collapse = "; ")
  [22:14:09.972]                   if (!has_future) {
  [22:14:09.972]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:09.972]                       info)
  [22:14:09.972]                   }
  [22:14:09.972]                   else {
  [22:14:09.972]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:09.972]                       info, version)
  [22:14:09.972]                   }
  [22:14:09.972]                   stop(msg)
  [22:14:09.972]                 }
  [22:14:09.972]             }
  [22:14:09.972]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:09.972]         }
  [22:14:09.972]     }
  [22:14:09.972]     if (is.na(TRUE)) {
  [22:14:09.972]     }
  [22:14:09.972]     else {
  [22:14:09.972]         if (TRUE) {
  [22:14:09.972]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:09.972]         }
  [22:14:09.972]         else {
  [22:14:09.972]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:09.972]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:09.972]         }
  [22:14:09.972]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:09.972]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:09.972]             sink(type = "output", split = FALSE)
  [22:14:09.972]             close(...future.stdout)
  [22:14:09.972]         }, add = TRUE)
  [22:14:09.972]     }
  [22:14:09.972]     ...future.frame <- sys.nframe()
  [22:14:09.972]     ...future.conditions <- list()
  [22:14:09.972]     ...future.result <- tryCatch({
  [22:14:09.972]         withCallingHandlers({
  [22:14:09.972]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:09.972]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:09.972]                 version = "1.8")
  [22:14:09.972]         }, condition = local({
  [22:14:09.972]             inherits <- base::inherits
  [22:14:09.972]             invokeRestart <- base::invokeRestart
  [22:14:09.972]             length <- base::length
  [22:14:09.972]             seq.int <- base::seq.int
  [22:14:09.972]             sys.calls <- base::sys.calls
  [22:14:09.972]             `[[` <- base::`[[`
  [22:14:09.972]             `+` <- base::`+`
  [22:14:09.972]             `<<-` <- base::`<<-`
  [22:14:09.972]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:09.972]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:09.972]                   3L)]
  [22:14:09.972]             }
  [22:14:09.972]             function(cond) {
  [22:14:09.972]                 if (inherits(cond, "error")) {
  [22:14:09.972]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.972]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:09.972]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:09.972]                     signaled = 0L)
  [22:14:09.972]                   signalCondition(cond)
  [22:14:09.972]                 }
  [22:14:09.972]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:09.972]                 ))) {
  [22:14:09.972]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:09.972]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:09.972]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:09.972]                   if (inherits(cond, "message")) {
  [22:14:09.972]                     if (!signal) 
  [22:14:09.972]                       invokeRestart("muffleMessage")
  [22:14:09.972]                   }
  [22:14:09.972]                   else if (inherits(cond, "warning")) {
  [22:14:09.972]                     if (!signal) 
  [22:14:09.972]                       invokeRestart("muffleWarning")
  [22:14:09.972]                   }
  [22:14:09.972]                   else {
  [22:14:09.972]                     if (!signal) {
  [22:14:09.972]                       restarts <- computeRestarts(cond)
  [22:14:09.972]                       for (restart in restarts) {
  [22:14:09.972]                         name <- restart$name
  [22:14:09.972]                         if (is.null(name)) 
  [22:14:09.972]                           next
  [22:14:09.972]                         if (!grepl("^muffle", name)) 
  [22:14:09.972]                           next
  [22:14:09.972]                         invokeRestart(restart)
  [22:14:09.972]                         break
  [22:14:09.972]                       }
  [22:14:09.972]                     }
  [22:14:09.972]                   }
  [22:14:09.972]                 }
  [22:14:09.972]             }
  [22:14:09.972]         }))
  [22:14:09.972]     }, error = function(ex) {
  [22:14:09.972]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:09.972]             version = "1.8"), class = "FutureResult")
  [22:14:09.972]     }, finally = {
  [22:14:09.972]         {
  [22:14:09.972]             NULL
  [22:14:09.972]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:09.972]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:09.972]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:09.972]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:09.972]                 ...) 
  [22:14:09.972]             {
  [22:14:09.972]                 if (substitute) 
  [22:14:09.972]                   expr <- substitute(expr)
  [22:14:09.972]                 if (is.function(workers)) 
  [22:14:09.972]                   workers <- workers()
  [22:14:09.972]                 workers <- as.integer(workers)
  [22:14:09.972]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:09.972]                   workers >= 1)
  [22:14:09.972]                 if (workers == 1L) {
  [22:14:09.972]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:09.972]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:09.972]                     local = TRUE, label = label, ...))
  [22:14:09.972]                 }
  [22:14:09.972]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:09.972]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:09.972]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:09.972]                   globals = globals, persistent = persistent, 
  [22:14:09.972]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:09.972]                   label = label, ...)
  [22:14:09.972]                 if (!future$lazy) 
  [22:14:09.972]                   future <- run(future)
  [22:14:09.972]                 invisible(future)
  [22:14:09.972]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:09.972]         }
  [22:14:09.972]         options(...future.oldOptions)
  [22:14:09.972]     })
  [22:14:09.972]     if (is.na(TRUE)) {
  [22:14:09.972]     }
  [22:14:09.972]     else {
  [22:14:09.972]         sink(type = "output", split = FALSE)
  [22:14:09.972]         if (TRUE) {
  [22:14:09.972]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:09.972]         }
  [22:14:09.972]         else {
  [22:14:09.972]             ...future.result["stdout"] <- list(NULL)
  [22:14:09.972]         }
  [22:14:09.972]         close(...future.stdout)
  [22:14:09.972]         ...future.stdout <- NULL
  [22:14:09.972]     }
  [22:14:09.972]     ...future.result$conditions <- ...future.conditions
  [22:14:09.972]     ...future.result
  [22:14:09.972] }
  [22:14:09.976] plan(): Setting new future strategy stack:
  [22:14:09.976] List of future strategies:
  [22:14:09.976] 1. sequential:
  [22:14:09.976]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.976]    - tweaked: FALSE
  [22:14:09.976]    - call: NULL
  [22:14:09.977] plan(): nbrOfWorkers() = 1
  [22:14:09.978] plan(): Setting new future strategy stack:
  [22:14:09.979] List of future strategies:
  [22:14:09.979] 1. multisession:
  [22:14:09.979]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:09.979]    - tweaked: FALSE
  [22:14:09.979]    - call: plan(strategy)
  [22:14:09.984] plan(): nbrOfWorkers() = 1
  [22:14:09.984] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:09.990] futureCall() ...
  [22:14:09.991] Globals to be used in the future:
  [22:14:09.991] List of 3
  [22:14:09.991]  $ a   : num 3
  [22:14:09.991]  $ FUN :function (x, y)  
  [22:14:09.991]  $ args:List of 2
  [22:14:09.991]   ..$ x: num 42
  [22:14:09.991]   ..$ y: num 12
  [22:14:09.991]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:09.991]  - attr(*, "where")=List of 3
  [22:14:09.991]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:09.991]   ..$ FUN :<environment: 0x1a6ec38> 
  [22:14:09.991]   ..$ args:<environment: 0x1c5c5a8> 
  [22:14:09.991]  - attr(*, "resolved")= logi FALSE
  [22:14:09.991]  - attr(*, "total_size")= num NA
  [22:14:10.004] getGlobalsAndPackages() ...
  [22:14:10.004] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.005] Resolving globals: FALSE
  [22:14:10.006] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.006] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.007] 
  [22:14:10.007] getGlobalsAndPackages() ... DONE
  [22:14:10.007] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x1c5c5a8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:10.011] Packages needed by the future expression (n = 0): <none>
  [22:14:10.011] Packages needed by future strategies (n = 0): <none>
  [22:14:10.016] {
  [22:14:10.016]     {
  [22:14:10.016]         ...future.startTime <- Sys.time()
  [22:14:10.016]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.016]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.016]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.016]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.016]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.016]         {
  [22:14:10.016]             {
  [22:14:10.016]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.016]                 version <- if (has_future) 
  [22:14:10.016]                   packageVersion("future")
  [22:14:10.016]                 else NULL
  [22:14:10.016]                 if (!has_future || version < "1.8.0") {
  [22:14:10.016]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:10.016]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.016]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.016]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.016]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.016]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:10.016]                   info <- paste(info, collapse = "; ")
  [22:14:10.016]                   if (!has_future) {
  [22:14:10.016]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.016]                       info)
  [22:14:10.016]                   }
  [22:14:10.016]                   else {
  [22:14:10.016]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.016]                       info, version)
  [22:14:10.016]                   }
  [22:14:10.016]                   stop(msg)
  [22:14:10.016]                 }
  [22:14:10.016]             }
  [22:14:10.016]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.016]         }
  [22:14:10.016]     }
  [22:14:10.016]     if (is.na(TRUE)) {
  [22:14:10.016]     }
  [22:14:10.016]     else {
  [22:14:10.016]         if (TRUE) {
  [22:14:10.016]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.016]         }
  [22:14:10.016]         else {
  [22:14:10.016]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.016]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.016]         }
  [22:14:10.016]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.016]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.016]             sink(type = "output", split = FALSE)
  [22:14:10.016]             close(...future.stdout)
  [22:14:10.016]         }, add = TRUE)
  [22:14:10.016]     }
  [22:14:10.016]     ...future.frame <- sys.nframe()
  [22:14:10.016]     ...future.conditions <- list()
  [22:14:10.016]     ...future.result <- tryCatch({
  [22:14:10.016]         withCallingHandlers({
  [22:14:10.016]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.016]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.016]                 version = "1.8")
  [22:14:10.016]         }, condition = local({
  [22:14:10.016]             inherits <- base::inherits
  [22:14:10.016]             invokeRestart <- base::invokeRestart
  [22:14:10.016]             length <- base::length
  [22:14:10.016]             seq.int <- base::seq.int
  [22:14:10.016]             sys.calls <- base::sys.calls
  [22:14:10.016]             `[[` <- base::`[[`
  [22:14:10.016]             `+` <- base::`+`
  [22:14:10.016]             `<<-` <- base::`<<-`
  [22:14:10.016]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.016]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.016]                   3L)]
  [22:14:10.016]             }
  [22:14:10.016]             function(cond) {
  [22:14:10.016]                 if (inherits(cond, "error")) {
  [22:14:10.016]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.016]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.016]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.016]                     signaled = 0L)
  [22:14:10.016]                   signalCondition(cond)
  [22:14:10.016]                 }
  [22:14:10.016]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:10.016]                 ))) {
  [22:14:10.016]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:10.016]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.016]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.016]                   if (inherits(cond, "message")) {
  [22:14:10.016]                     if (!signal) 
  [22:14:10.016]                       invokeRestart("muffleMessage")
  [22:14:10.016]                   }
  [22:14:10.016]                   else if (inherits(cond, "warning")) {
  [22:14:10.016]                     if (!signal) 
  [22:14:10.016]                       invokeRestart("muffleWarning")
  [22:14:10.016]                   }
  [22:14:10.016]                   else {
  [22:14:10.016]                     if (!signal) {
  [22:14:10.016]                       restarts <- computeRestarts(cond)
  [22:14:10.016]                       for (restart in restarts) {
  [22:14:10.016]                         name <- restart$name
  [22:14:10.016]                         if (is.null(name)) 
  [22:14:10.016]                           next
  [22:14:10.016]                         if (!grepl("^muffle", name)) 
  [22:14:10.016]                           next
  [22:14:10.016]                         invokeRestart(restart)
  [22:14:10.016]                         break
  [22:14:10.016]                       }
  [22:14:10.016]                     }
  [22:14:10.016]                   }
  [22:14:10.016]                 }
  [22:14:10.016]             }
  [22:14:10.016]         }))
  [22:14:10.016]     }, error = function(ex) {
  [22:14:10.016]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.016]             version = "1.8"), class = "FutureResult")
  [22:14:10.016]     }, finally = {
  [22:14:10.016]         {
  [22:14:10.016]             NULL
  [22:14:10.016]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.016]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.016]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:10.016]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:10.016]                 ...) 
  [22:14:10.016]             {
  [22:14:10.016]                 if (substitute) 
  [22:14:10.016]                   expr <- substitute(expr)
  [22:14:10.016]                 if (is.function(workers)) 
  [22:14:10.016]                   workers <- workers()
  [22:14:10.016]                 workers <- as.integer(workers)
  [22:14:10.016]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:10.016]                   workers >= 1)
  [22:14:10.016]                 if (workers == 1L) {
  [22:14:10.016]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.016]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:10.016]                     local = TRUE, label = label, ...))
  [22:14:10.016]                 }
  [22:14:10.016]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:10.016]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:10.016]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.016]                   globals = globals, persistent = persistent, 
  [22:14:10.016]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:10.016]                   label = label, ...)
  [22:14:10.016]                 if (!future$lazy) 
  [22:14:10.016]                   future <- run(future)
  [22:14:10.016]                 invisible(future)
  [22:14:10.016]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.016]         }
  [22:14:10.016]         options(...future.oldOptions)
  [22:14:10.016]     })
  [22:14:10.016]     if (is.na(TRUE)) {
  [22:14:10.016]     }
  [22:14:10.016]     else {
  [22:14:10.016]         sink(type = "output", split = FALSE)
  [22:14:10.016]         if (TRUE) {
  [22:14:10.016]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.016]         }
  [22:14:10.016]         else {
  [22:14:10.016]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.016]         }
  [22:14:10.016]         close(...future.stdout)
  [22:14:10.016]         ...future.stdout <- NULL
  [22:14:10.016]     }
  [22:14:10.016]     ...future.result$conditions <- ...future.conditions
  [22:14:10.016]     ...future.result
  [22:14:10.016] }
  [22:14:10.019] plan(): Setting new future strategy stack:
  [22:14:10.020] List of future strategies:
  [22:14:10.020] 1. sequential:
  [22:14:10.020]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.020]    - tweaked: FALSE
  [22:14:10.020]    - call: NULL
  [22:14:10.021] plan(): nbrOfWorkers() = 1
  [22:14:10.022] plan(): Setting new future strategy stack:
  [22:14:10.022] List of future strategies:
  [22:14:10.022] 1. multisession:
  [22:14:10.022]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.022]    - tweaked: FALSE
  [22:14:10.022]    - call: plan(strategy)
  [22:14:10.023] plan(): nbrOfWorkers() = 1
  [22:14:10.024] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:10.029] futureCall() ...
  [22:14:10.030] Globals to be used in the future:
  [22:14:10.030] List of 3
  [22:14:10.030]  $ a   : num 3
  [22:14:10.030]  $ FUN :function (x, y)  
  [22:14:10.030]  $ args:List of 2
  [22:14:10.030]   ..$ x: num 42
  [22:14:10.030]   ..$ y: num 12
  [22:14:10.030]  - attr(*, "where")=List of 3
  [22:14:10.030]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:10.030]   ..$ FUN :<environment: 0x2a85900> 
  [22:14:10.030]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:10.030]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.030]  - attr(*, "resolved")= logi FALSE
  [22:14:10.030]  - attr(*, "total_size")= num NA
  [22:14:10.043] getGlobalsAndPackages() ...
  [22:14:10.044] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.044] Resolving globals: FALSE
  [22:14:10.045] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.046] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.046] 
  [22:14:10.046] getGlobalsAndPackages() ... DONE
  [22:14:10.047] futureCall() ... DONE
  SequentialFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x2a6eab8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [22:14:10.050] Packages needed by the future expression (n = 0): <none>
  [22:14:10.051] Packages needed by future strategies (n = 0): <none>
  [22:14:10.058] {
  [22:14:10.058]     {
  [22:14:10.058]         ...future.startTime <- Sys.time()
  [22:14:10.058]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.058]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.058]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.058]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.058]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.058]         {
  [22:14:10.058]             {
  [22:14:10.058]                 has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.058]                 version <- if (has_future) 
  [22:14:10.058]                   packageVersion("future")
  [22:14:10.058]                 else NULL
  [22:14:10.058]                 if (!has_future || version < "1.8.0") {
  [22:14:10.058]                   info <- c(r_version = gsub("R version ", "", 
  [22:14:10.058]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.058]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.058]                     os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.058]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.058]                   info <- sprintf("%s: %s", names(info), info)
  [22:14:10.058]                   info <- paste(info, collapse = "; ")
  [22:14:10.058]                   if (!has_future) {
  [22:14:10.058]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.058]                       info)
  [22:14:10.058]                   }
  [22:14:10.058]                   else {
  [22:14:10.058]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.058]                       info, version)
  [22:14:10.058]                   }
  [22:14:10.058]                   stop(msg)
  [22:14:10.058]                 }
  [22:14:10.058]             }
  [22:14:10.058]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.058]         }
  [22:14:10.058]     }
  [22:14:10.058]     if (is.na(TRUE)) {
  [22:14:10.058]     }
  [22:14:10.058]     else {
  [22:14:10.058]         if (TRUE) {
  [22:14:10.058]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.058]         }
  [22:14:10.058]         else {
  [22:14:10.058]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.058]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.058]         }
  [22:14:10.058]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.058]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.058]             sink(type = "output", split = FALSE)
  [22:14:10.058]             close(...future.stdout)
  [22:14:10.058]         }, add = TRUE)
  [22:14:10.058]     }
  [22:14:10.058]     ...future.frame <- sys.nframe()
  [22:14:10.058]     ...future.conditions <- list()
  [22:14:10.058]     ...future.result <- tryCatch({
  [22:14:10.058]         withCallingHandlers({
  [22:14:10.058]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.058]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.058]                 version = "1.8")
  [22:14:10.058]         }, condition = local({
  [22:14:10.058]             inherits <- base::inherits
  [22:14:10.058]             invokeRestart <- base::invokeRestart
  [22:14:10.058]             length <- base::length
  [22:14:10.058]             seq.int <- base::seq.int
  [22:14:10.058]             sys.calls <- base::sys.calls
  [22:14:10.058]             `[[` <- base::`[[`
  [22:14:10.058]             `+` <- base::`+`
  [22:14:10.058]             `<<-` <- base::`<<-`
  [22:14:10.058]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.058]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.058]                   3L)]
  [22:14:10.058]             }
  [22:14:10.058]             function(cond) {
  [22:14:10.058]                 if (inherits(cond, "error")) {
  [22:14:10.058]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.058]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.058]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.058]                     signaled = 0L)
  [22:14:10.058]                   signalCondition(cond)
  [22:14:10.058]                 }
  [22:14:10.058]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:14:10.058]                 ))) {
  [22:14:10.058]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:14:10.058]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.058]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.058]                   if (inherits(cond, "message")) {
  [22:14:10.058]                     if (!signal) 
  [22:14:10.058]                       invokeRestart("muffleMessage")
  [22:14:10.058]                   }
  [22:14:10.058]                   else if (inherits(cond, "warning")) {
  [22:14:10.058]                     if (!signal) 
  [22:14:10.058]                       invokeRestart("muffleWarning")
  [22:14:10.058]                   }
  [22:14:10.058]                   else {
  [22:14:10.058]                     if (!signal) {
  [22:14:10.058]                       restarts <- computeRestarts(cond)
  [22:14:10.058]                       for (restart in restarts) {
  [22:14:10.058]                         name <- restart$name
  [22:14:10.058]                         if (is.null(name)) 
  [22:14:10.058]                           next
  [22:14:10.058]                         if (!grepl("^muffle", name)) 
  [22:14:10.058]                           next
  [22:14:10.058]                         invokeRestart(restart)
  [22:14:10.058]                         break
  [22:14:10.058]                       }
  [22:14:10.058]                     }
  [22:14:10.058]                   }
  [22:14:10.058]                 }
  [22:14:10.058]             }
  [22:14:10.058]         }))
  [22:14:10.058]     }, error = function(ex) {
  [22:14:10.058]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.058]             version = "1.8"), class = "FutureResult")
  [22:14:10.058]     }, finally = {
  [22:14:10.058]         {
  [22:14:10.058]             NULL
  [22:14:10.058]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.058]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.058]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:10.058]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:10.058]                 ...) 
  [22:14:10.058]             {
  [22:14:10.058]                 if (substitute) 
  [22:14:10.058]                   expr <- substitute(expr)
  [22:14:10.058]                 if (is.function(workers)) 
  [22:14:10.058]                   workers <- workers()
  [22:14:10.058]                 workers <- as.integer(workers)
  [22:14:10.058]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:10.058]                   workers >= 1)
  [22:14:10.058]                 if (workers == 1L) {
  [22:14:10.058]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.058]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:10.058]                     local = TRUE, label = label, ...))
  [22:14:10.058]                 }
  [22:14:10.058]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:10.058]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:10.058]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.058]                   globals = globals, persistent = persistent, 
  [22:14:10.058]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:10.058]                   label = label, ...)
  [22:14:10.058]                 if (!future$lazy) 
  [22:14:10.058]                   future <- run(future)
  [22:14:10.058]                 invisible(future)
  [22:14:10.058]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.058]         }
  [22:14:10.058]         options(...future.oldOptions)
  [22:14:10.058]     })
  [22:14:10.058]     if (is.na(TRUE)) {
  [22:14:10.058]     }
  [22:14:10.058]     else {
  [22:14:10.058]         sink(type = "output", split = FALSE)
  [22:14:10.058]         if (TRUE) {
  [22:14:10.058]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.058]         }
  [22:14:10.058]         else {
  [22:14:10.058]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.058]         }
  [22:14:10.058]         close(...future.stdout)
  [22:14:10.058]         ...future.stdout <- NULL
  [22:14:10.058]     }
  [22:14:10.058]     ...future.result$conditions <- ...future.conditions
  [22:14:10.058]     ...future.result
  [22:14:10.058] }
  [22:14:10.062] plan(): Setting new future strategy stack:
  [22:14:10.062] List of future strategies:
  [22:14:10.062] 1. sequential:
  [22:14:10.062]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.062]    - tweaked: FALSE
  [22:14:10.062]    - call: NULL
  [22:14:10.063] plan(): nbrOfWorkers() = 1
  [22:14:10.064] plan(): Setting new future strategy stack:
  [22:14:10.065] List of future strategies:
  [22:14:10.065] 1. multisession:
  [22:14:10.065]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.065]    - tweaked: FALSE
  [22:14:10.065]    - call: plan(strategy)
  [22:14:10.066] plan(): nbrOfWorkers() = 1
  [22:14:10.067] SequentialFuture started (and completed)
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  - plan('multicore') ...
  [22:14:10.082] plan(): Setting new future strategy stack:
  [22:14:10.082] List of future strategies:
  [22:14:10.082] 1. multicore:
  [22:14:10.082]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.082]    - tweaked: FALSE
  [22:14:10.082]    - call: plan(strategy)
  [22:14:10.084] plan(): nbrOfWorkers() = 2
  [22:14:10.084] futureCall() ...
  [22:14:10.085] Globals to be used in the future:
  [22:14:10.085] List of 2
  [22:14:10.085]  $ FUN :function (x, y)  
  [22:14:10.085]  $ args:List of 2
  [22:14:10.085]   ..$ x: num 42
  [22:14:10.085]   ..$ y: num 12
  [22:14:10.085]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.085]  - attr(*, "where")=List of 2
  [22:14:10.085]   ..$ FUN :<environment: 0xbdadc0> 
  [22:14:10.085]   ..$ args:<environment: 0xbdadc0> 
  [22:14:10.085]  - attr(*, "resolved")= logi FALSE
  [22:14:10.085]  - attr(*, "total_size")= num NA
  [22:14:10.096] getGlobalsAndPackages() ...
  [22:14:10.097] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:10.097] Resolving globals: FALSE
  [22:14:10.098] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:10.099] - globals: [2] 'FUN', 'args'
  [22:14:10.099] 
  [22:14:10.099] getGlobalsAndPackages() ... DONE
  [22:14:10.101] Packages needed by the future expression (n = 0): <none>
  [22:14:10.102] Packages needed by future strategies (n = 0): <none>
  [22:14:10.106] {
  [22:14:10.106]     {
  [22:14:10.106]         ...future.startTime <- Sys.time()
  [22:14:10.106]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.106]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.106]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.106]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.106]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.106]         {
  [22:14:10.106]             {
  [22:14:10.106]                 {
  [22:14:10.106]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.106]                   version <- if (has_future) 
  [22:14:10.106]                     packageVersion("future")
  [22:14:10.106]                   else NULL
  [22:14:10.106]                   if (!has_future || version < "1.8.0") {
  [22:14:10.106]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.106]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.106]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.106]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.106]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.106]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.106]                     info <- paste(info, collapse = "; ")
  [22:14:10.106]                     if (!has_future) {
  [22:14:10.106]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.106]                         info)
  [22:14:10.106]                     }
  [22:14:10.106]                     else {
  [22:14:10.106]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.106]                         info, version)
  [22:14:10.106]                     }
  [22:14:10.106]                     stop(msg)
  [22:14:10.106]                   }
  [22:14:10.106]                 }
  [22:14:10.106]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.106]                 options(mc.cores = 1L)
  [22:14:10.106]             }
  [22:14:10.106]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.106]         }
  [22:14:10.106]     }
  [22:14:10.106]     if (is.na(TRUE)) {
  [22:14:10.106]     }
  [22:14:10.106]     else {
  [22:14:10.106]         if (TRUE) {
  [22:14:10.106]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.106]         }
  [22:14:10.106]         else {
  [22:14:10.106]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.106]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.106]         }
  [22:14:10.106]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.106]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.106]             sink(type = "output", split = FALSE)
  [22:14:10.106]             close(...future.stdout)
  [22:14:10.106]         }, add = TRUE)
  [22:14:10.106]     }
  [22:14:10.106]     ...future.frame <- sys.nframe()
  [22:14:10.106]     ...future.conditions <- list()
  [22:14:10.106]     ...future.result <- tryCatch({
  [22:14:10.106]         withCallingHandlers({
  [22:14:10.106]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.106]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.106]                 version = "1.8")
  [22:14:10.106]         }, condition = local({
  [22:14:10.106]             inherits <- base::inherits
  [22:14:10.106]             invokeRestart <- base::invokeRestart
  [22:14:10.106]             length <- base::length
  [22:14:10.106]             seq.int <- base::seq.int
  [22:14:10.106]             sys.calls <- base::sys.calls
  [22:14:10.106]             `[[` <- base::`[[`
  [22:14:10.106]             `+` <- base::`+`
  [22:14:10.106]             `<<-` <- base::`<<-`
  [22:14:10.106]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.106]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.106]                   3L)]
  [22:14:10.106]             }
  [22:14:10.106]             function(cond) {
  [22:14:10.106]                 if (inherits(cond, "error")) {
  [22:14:10.106]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.106]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.106]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.106]                     signaled = 0L)
  [22:14:10.106]                   signalCondition(cond)
  [22:14:10.106]                 }
  [22:14:10.106]                 else if (inherits(cond, "condition")) {
  [22:14:10.106]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.106]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.106]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.106]                   if (inherits(cond, "message")) {
  [22:14:10.106]                     if (!signal) 
  [22:14:10.106]                       invokeRestart("muffleMessage")
  [22:14:10.106]                   }
  [22:14:10.106]                   else if (inherits(cond, "warning")) {
  [22:14:10.106]                     if (!signal) 
  [22:14:10.106]                       invokeRestart("muffleWarning")
  [22:14:10.106]                   }
  [22:14:10.106]                   else {
  [22:14:10.106]                     if (!signal) {
  [22:14:10.106]                       restarts <- computeRestarts(cond)
  [22:14:10.106]                       for (restart in restarts) {
  [22:14:10.106]                         name <- restart$name
  [22:14:10.106]                         if (is.null(name)) 
  [22:14:10.106]                           next
  [22:14:10.106]                         if (!grepl("^muffle", name)) 
  [22:14:10.106]                           next
  [22:14:10.106]                         invokeRestart(restart)
  [22:14:10.106]                         break
  [22:14:10.106]                       }
  [22:14:10.106]                     }
  [22:14:10.106]                   }
  [22:14:10.106]                 }
  [22:14:10.106]             }
  [22:14:10.106]         }))
  [22:14:10.106]     }, error = function(ex) {
  [22:14:10.106]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.106]             version = "1.8"), class = "FutureResult")
  [22:14:10.106]     }, finally = {
  [22:14:10.106]         {
  [22:14:10.106]             {
  [22:14:10.106]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.106]             }
  [22:14:10.106]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.106]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.106]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.106]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.106]             {
  [22:14:10.106]                 if (substitute) 
  [22:14:10.106]                   expr <- substitute(expr)
  [22:14:10.106]                 if (is.function(workers)) 
  [22:14:10.106]                   workers <- workers()
  [22:14:10.106]                 workers <- as.integer(workers)
  [22:14:10.106]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.106]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.106]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.106]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.106]                     local = TRUE, label = label, ...))
  [22:14:10.106]                 }
  [22:14:10.106]                 oopts <- options(mc.cores = workers)
  [22:14:10.106]                 on.exit(options(oopts))
  [22:14:10.106]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.106]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.106]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.106]                   label = label, ...)
  [22:14:10.106]                 if (!future$lazy) 
  [22:14:10.106]                   future <- run(future)
  [22:14:10.106]                 invisible(future)
  [22:14:10.106]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.106]         }
  [22:14:10.106]         options(...future.oldOptions)
  [22:14:10.106]     })
  [22:14:10.106]     if (is.na(TRUE)) {
  [22:14:10.106]     }
  [22:14:10.106]     else {
  [22:14:10.106]         sink(type = "output", split = FALSE)
  [22:14:10.106]         if (TRUE) {
  [22:14:10.106]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.106]         }
  [22:14:10.106]         else {
  [22:14:10.106]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.106]         }
  [22:14:10.106]         close(...future.stdout)
  [22:14:10.106]         ...future.stdout <- NULL
  [22:14:10.106]     }
  [22:14:10.106]     ...future.result$conditions <- ...future.conditions
  [22:14:10.106]     ...future.result
  [22:14:10.106] }
  [22:14:10.109] requestCore(): workers = 2
  [22:14:10.113] MulticoreFuture started
  [22:14:10.114] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x298a630>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.123] plan(): Setting new future strategy stack:
  [22:14:10.123] List of future strategies:
  [22:14:10.123] 1. sequential:
  [22:14:10.123]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.123]    - tweaked: FALSE
  [22:14:10.123]    - call: NULL
  [22:14:10.125] plan(): nbrOfWorkers() = 1
  [22:14:10.126] plan(): Setting new future strategy stack:
  [22:14:10.126] List of future strategies:
  [22:14:10.126] 1. multicore:
  [22:14:10.126]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.126]    - tweaked: FALSE
  [22:14:10.126]    - call: plan(strategy)
  [22:14:10.128] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:10.153] futureCall() ...
  [22:14:10.154] Globals to be used in the future:
  [22:14:10.154] List of 3
  [22:14:10.154]  $ a   : num 3
  [22:14:10.154]  $ FUN :function (x, y)  
  [22:14:10.154]  $ args:List of 2
  [22:14:10.154]   ..$ x: num 42
  [22:14:10.154]   ..$ y: num 12
  [22:14:10.154]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.154]  - attr(*, "where")=List of 3
  [22:14:10.154]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.154]   ..$ FUN :<environment: 0x327a840> 
  [22:14:10.154]   ..$ args:<environment: 0x323d0f0> 
  [22:14:10.154]  - attr(*, "resolved")= logi FALSE
  [22:14:10.154]  - attr(*, "total_size")= num NA
  [22:14:10.175] getGlobalsAndPackages() ...
  [22:14:10.175] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.175] Resolving globals: FALSE
  [22:14:10.177] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.177] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.177] 
  [22:14:10.178] getGlobalsAndPackages() ... DONE
  [22:14:10.180] Packages needed by the future expression (n = 0): <none>
  [22:14:10.180] Packages needed by future strategies (n = 0): <none>
  [22:14:10.185] {
  [22:14:10.185]     {
  [22:14:10.185]         ...future.startTime <- Sys.time()
  [22:14:10.185]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.185]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.185]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.185]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.185]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.185]         {
  [22:14:10.185]             {
  [22:14:10.185]                 {
  [22:14:10.185]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.185]                   version <- if (has_future) 
  [22:14:10.185]                     packageVersion("future")
  [22:14:10.185]                   else NULL
  [22:14:10.185]                   if (!has_future || version < "1.8.0") {
  [22:14:10.185]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.185]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.185]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.185]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.185]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.185]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.185]                     info <- paste(info, collapse = "; ")
  [22:14:10.185]                     if (!has_future) {
  [22:14:10.185]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.185]                         info)
  [22:14:10.185]                     }
  [22:14:10.185]                     else {
  [22:14:10.185]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.185]                         info, version)
  [22:14:10.185]                     }
  [22:14:10.185]                     stop(msg)
  [22:14:10.185]                   }
  [22:14:10.185]                 }
  [22:14:10.185]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.185]                 options(mc.cores = 1L)
  [22:14:10.185]             }
  [22:14:10.185]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.185]         }
  [22:14:10.185]     }
  [22:14:10.185]     if (is.na(TRUE)) {
  [22:14:10.185]     }
  [22:14:10.185]     else {
  [22:14:10.185]         if (TRUE) {
  [22:14:10.185]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.185]         }
  [22:14:10.185]         else {
  [22:14:10.185]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.185]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.185]         }
  [22:14:10.185]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.185]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.185]             sink(type = "output", split = FALSE)
  [22:14:10.185]             close(...future.stdout)
  [22:14:10.185]         }, add = TRUE)
  [22:14:10.185]     }
  [22:14:10.185]     ...future.frame <- sys.nframe()
  [22:14:10.185]     ...future.conditions <- list()
  [22:14:10.185]     ...future.result <- tryCatch({
  [22:14:10.185]         withCallingHandlers({
  [22:14:10.185]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.185]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.185]                 version = "1.8")
  [22:14:10.185]         }, condition = local({
  [22:14:10.185]             inherits <- base::inherits
  [22:14:10.185]             invokeRestart <- base::invokeRestart
  [22:14:10.185]             length <- base::length
  [22:14:10.185]             seq.int <- base::seq.int
  [22:14:10.185]             sys.calls <- base::sys.calls
  [22:14:10.185]             `[[` <- base::`[[`
  [22:14:10.185]             `+` <- base::`+`
  [22:14:10.185]             `<<-` <- base::`<<-`
  [22:14:10.185]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.185]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.185]                   3L)]
  [22:14:10.185]             }
  [22:14:10.185]             function(cond) {
  [22:14:10.185]                 if (inherits(cond, "error")) {
  [22:14:10.185]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.185]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.185]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.185]                     signaled = 0L)
  [22:14:10.185]                   signalCondition(cond)
  [22:14:10.185]                 }
  [22:14:10.185]                 else if (inherits(cond, "condition")) {
  [22:14:10.185]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.185]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.185]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.185]                   if (inherits(cond, "message")) {
  [22:14:10.185]                     if (!signal) 
  [22:14:10.185]                       invokeRestart("muffleMessage")
  [22:14:10.185]                   }
  [22:14:10.185]                   else if (inherits(cond, "warning")) {
  [22:14:10.185]                     if (!signal) 
  [22:14:10.185]                       invokeRestart("muffleWarning")
  [22:14:10.185]                   }
  [22:14:10.185]                   else {
  [22:14:10.185]                     if (!signal) {
  [22:14:10.185]                       restarts <- computeRestarts(cond)
  [22:14:10.185]                       for (restart in restarts) {
  [22:14:10.185]                         name <- restart$name
  [22:14:10.185]                         if (is.null(name)) 
  [22:14:10.185]                           next
  [22:14:10.185]                         if (!grepl("^muffle", name)) 
  [22:14:10.185]                           next
  [22:14:10.185]                         invokeRestart(restart)
  [22:14:10.185]                         break
  [22:14:10.185]                       }
  [22:14:10.185]                     }
  [22:14:10.185]                   }
  [22:14:10.185]                 }
  [22:14:10.185]             }
  [22:14:10.185]         }))
  [22:14:10.185]     }, error = function(ex) {
  [22:14:10.185]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.185]             version = "1.8"), class = "FutureResult")
  [22:14:10.185]     }, finally = {
  [22:14:10.185]         {
  [22:14:10.185]             {
  [22:14:10.185]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.185]             }
  [22:14:10.185]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.185]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.185]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.185]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.185]             {
  [22:14:10.185]                 if (substitute) 
  [22:14:10.185]                   expr <- substitute(expr)
  [22:14:10.185]                 if (is.function(workers)) 
  [22:14:10.185]                   workers <- workers()
  [22:14:10.185]                 workers <- as.integer(workers)
  [22:14:10.185]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.185]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.185]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.185]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.185]                     local = TRUE, label = label, ...))
  [22:14:10.185]                 }
  [22:14:10.185]                 oopts <- options(mc.cores = workers)
  [22:14:10.185]                 on.exit(options(oopts))
  [22:14:10.185]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.185]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.185]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.185]                   label = label, ...)
  [22:14:10.185]                 if (!future$lazy) 
  [22:14:10.185]                   future <- run(future)
  [22:14:10.185]                 invisible(future)
  [22:14:10.185]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.185]         }
  [22:14:10.185]         options(...future.oldOptions)
  [22:14:10.185]     })
  [22:14:10.185]     if (is.na(TRUE)) {
  [22:14:10.185]     }
  [22:14:10.185]     else {
  [22:14:10.185]         sink(type = "output", split = FALSE)
  [22:14:10.185]         if (TRUE) {
  [22:14:10.185]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.185]         }
  [22:14:10.185]         else {
  [22:14:10.185]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.185]         }
  [22:14:10.185]         close(...future.stdout)
  [22:14:10.185]         ...future.stdout <- NULL
  [22:14:10.185]     }
  [22:14:10.185]     ...future.result$conditions <- ...future.conditions
  [22:14:10.185]     ...future.result
  [22:14:10.185] }
  [22:14:10.188] requestCore(): workers = 2
  [22:14:10.191] MulticoreFuture started
  [22:14:10.192] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0xf0fd10>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.196] plan(): Setting new future strategy stack:
  [22:14:10.197] List of future strategies:
  [22:14:10.197] 1. sequential:
  [22:14:10.197]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.197]    - tweaked: FALSE
  [22:14:10.197]    - call: NULL
  [22:14:10.199] plan(): nbrOfWorkers() = 1
  [22:14:10.200] plan(): Setting new future strategy stack:
  [22:14:10.201] List of future strategies:
  [22:14:10.201] 1. multicore:
  [22:14:10.201]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.201]    - tweaked: FALSE
  [22:14:10.201]    - call: plan(strategy)
  [22:14:10.203] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:10.213] futureCall() ...
  [22:14:10.214] Globals to be used in the future:
  [22:14:10.214] List of 3
  [22:14:10.214]  $ a   : num 3
  [22:14:10.214]  $ FUN :function (x, y)  
  [22:14:10.214]  $ args:List of 2
  [22:14:10.214]   ..$ x: num 42
  [22:14:10.214]   ..$ y: num 12
  [22:14:10.214]  - attr(*, "where")=List of 3
  [22:14:10.214]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:10.214]   ..$ FUN :<environment: 0xe28310> 
  [22:14:10.214]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:10.214]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.214]  - attr(*, "resolved")= logi FALSE
  [22:14:10.214]  - attr(*, "total_size")= num NA
  [22:14:10.240] getGlobalsAndPackages() ...
  [22:14:10.240] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.240] Resolving globals: FALSE
  [22:14:10.242] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.242] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.242] 
  [22:14:10.243] getGlobalsAndPackages() ... DONE
  [22:14:10.245] Packages needed by the future expression (n = 0): <none>
  [22:14:10.245] Packages needed by future strategies (n = 0): <none>
  [22:14:10.250] {
  [22:14:10.250]     {
  [22:14:10.250]         ...future.startTime <- Sys.time()
  [22:14:10.250]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.250]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.250]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.250]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.250]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.250]         {
  [22:14:10.250]             {
  [22:14:10.250]                 {
  [22:14:10.250]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.250]                   version <- if (has_future) 
  [22:14:10.250]                     packageVersion("future")
  [22:14:10.250]                   else NULL
  [22:14:10.250]                   if (!has_future || version < "1.8.0") {
  [22:14:10.250]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.250]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.250]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.250]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.250]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.250]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.250]                     info <- paste(info, collapse = "; ")
  [22:14:10.250]                     if (!has_future) {
  [22:14:10.250]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.250]                         info)
  [22:14:10.250]                     }
  [22:14:10.250]                     else {
  [22:14:10.250]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.250]                         info, version)
  [22:14:10.250]                     }
  [22:14:10.250]                     stop(msg)
  [22:14:10.250]                   }
  [22:14:10.250]                 }
  [22:14:10.250]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.250]                 options(mc.cores = 1L)
  [22:14:10.250]             }
  [22:14:10.250]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.250]         }
  [22:14:10.250]     }
  [22:14:10.250]     if (is.na(TRUE)) {
  [22:14:10.250]     }
  [22:14:10.250]     else {
  [22:14:10.250]         if (TRUE) {
  [22:14:10.250]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.250]         }
  [22:14:10.250]         else {
  [22:14:10.250]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.250]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.250]         }
  [22:14:10.250]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.250]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.250]             sink(type = "output", split = FALSE)
  [22:14:10.250]             close(...future.stdout)
  [22:14:10.250]         }, add = TRUE)
  [22:14:10.250]     }
  [22:14:10.250]     ...future.frame <- sys.nframe()
  [22:14:10.250]     ...future.conditions <- list()
  [22:14:10.250]     ...future.result <- tryCatch({
  [22:14:10.250]         withCallingHandlers({
  [22:14:10.250]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.250]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.250]                 version = "1.8")
  [22:14:10.250]         }, condition = local({
  [22:14:10.250]             inherits <- base::inherits
  [22:14:10.250]             invokeRestart <- base::invokeRestart
  [22:14:10.250]             length <- base::length
  [22:14:10.250]             seq.int <- base::seq.int
  [22:14:10.250]             sys.calls <- base::sys.calls
  [22:14:10.250]             `[[` <- base::`[[`
  [22:14:10.250]             `+` <- base::`+`
  [22:14:10.250]             `<<-` <- base::`<<-`
  [22:14:10.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.250]                   3L)]
  [22:14:10.250]             }
  [22:14:10.250]             function(cond) {
  [22:14:10.250]                 if (inherits(cond, "error")) {
  [22:14:10.250]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.250]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.250]                     signaled = 0L)
  [22:14:10.250]                   signalCondition(cond)
  [22:14:10.250]                 }
  [22:14:10.250]                 else if (inherits(cond, "condition")) {
  [22:14:10.250]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.250]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.250]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.250]                   if (inherits(cond, "message")) {
  [22:14:10.250]                     if (!signal) 
  [22:14:10.250]                       invokeRestart("muffleMessage")
  [22:14:10.250]                   }
  [22:14:10.250]                   else if (inherits(cond, "warning")) {
  [22:14:10.250]                     if (!signal) 
  [22:14:10.250]                       invokeRestart("muffleWarning")
  [22:14:10.250]                   }
  [22:14:10.250]                   else {
  [22:14:10.250]                     if (!signal) {
  [22:14:10.250]                       restarts <- computeRestarts(cond)
  [22:14:10.250]                       for (restart in restarts) {
  [22:14:10.250]                         name <- restart$name
  [22:14:10.250]                         if (is.null(name)) 
  [22:14:10.250]                           next
  [22:14:10.250]                         if (!grepl("^muffle", name)) 
  [22:14:10.250]                           next
  [22:14:10.250]                         invokeRestart(restart)
  [22:14:10.250]                         break
  [22:14:10.250]                       }
  [22:14:10.250]                     }
  [22:14:10.250]                   }
  [22:14:10.250]                 }
  [22:14:10.250]             }
  [22:14:10.250]         }))
  [22:14:10.250]     }, error = function(ex) {
  [22:14:10.250]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.250]             version = "1.8"), class = "FutureResult")
  [22:14:10.250]     }, finally = {
  [22:14:10.250]         {
  [22:14:10.250]             {
  [22:14:10.250]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.250]             }
  [22:14:10.250]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.250]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.250]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.250]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.250]             {
  [22:14:10.250]                 if (substitute) 
  [22:14:10.250]                   expr <- substitute(expr)
  [22:14:10.250]                 if (is.function(workers)) 
  [22:14:10.250]                   workers <- workers()
  [22:14:10.250]                 workers <- as.integer(workers)
  [22:14:10.250]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.250]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.250]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.250]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.250]                     local = TRUE, label = label, ...))
  [22:14:10.250]                 }
  [22:14:10.250]                 oopts <- options(mc.cores = workers)
  [22:14:10.250]                 on.exit(options(oopts))
  [22:14:10.250]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.250]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.250]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.250]                   label = label, ...)
  [22:14:10.250]                 if (!future$lazy) 
  [22:14:10.250]                   future <- run(future)
  [22:14:10.250]                 invisible(future)
  [22:14:10.250]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.250]         }
  [22:14:10.250]         options(...future.oldOptions)
  [22:14:10.250]     })
  [22:14:10.250]     if (is.na(TRUE)) {
  [22:14:10.250]     }
  [22:14:10.250]     else {
  [22:14:10.250]         sink(type = "output", split = FALSE)
  [22:14:10.250]         if (TRUE) {
  [22:14:10.250]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.250]         }
  [22:14:10.250]         else {
  [22:14:10.250]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.250]         }
  [22:14:10.250]         close(...future.stdout)
  [22:14:10.250]         ...future.stdout <- NULL
  [22:14:10.250]     }
  [22:14:10.250]     ...future.result$conditions <- ...future.conditions
  [22:14:10.250]     ...future.result
  [22:14:10.250] }
  [22:14:10.253] requestCore(): workers = 2
  [22:14:10.256] MulticoreFuture started
  [22:14:10.257] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2bd3868>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.274] plan(): Setting new future strategy stack:
  [22:14:10.275] List of future strategies:
  [22:14:10.275] 1. sequential:
  [22:14:10.275]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.275]    - tweaked: FALSE
  [22:14:10.275]    - call: NULL
  [22:14:10.276] plan(): nbrOfWorkers() = 1
  [22:14:10.278] plan(): Setting new future strategy stack:
  [22:14:10.278] List of future strategies:
  [22:14:10.278] 1. multicore:
  [22:14:10.278]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.278]    - tweaked: FALSE
  [22:14:10.278]    - call: plan(strategy)
  [22:14:10.280] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:10.290] futureCall() ...
  [22:14:10.290] Finding globals ...
  [22:14:10.291] getGlobalsAndPackages() ...
  [22:14:10.291] Searching for globals...
  [22:14:10.308] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:10.308] Searching for globals ... DONE
  [22:14:10.309] Resolving globals: FALSE
  [22:14:10.310] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:10.311] - globals: [3] 'FUN', 'args', 'a'
  [22:14:10.311] 
  [22:14:10.312] getGlobalsAndPackages() ... DONE
  [22:14:10.312]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:10.312] 
  [22:14:10.313] Finding globals ... DONE
  [22:14:10.313] Globals to be used in the future:
  [22:14:10.313] List of 3
  [22:14:10.313]  $ FUN :function (x, y)  
  [22:14:10.313]  $ args:List of 2
  [22:14:10.313]   ..$ x: num 42
  [22:14:10.313]   ..$ y: num 12
  [22:14:10.313]  $ a   : num 3
  [22:14:10.313]  - attr(*, "where")=List of 3
  [22:14:10.313]   ..$ FUN :<environment: 0x1a6ec38> 
  [22:14:10.313]   ..$ args:<environment: 0x32996f8> 
  [22:14:10.313]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.313]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.313]  - attr(*, "resolved")= logi FALSE
  [22:14:10.313]  - attr(*, "total_size")= num 2592
  [22:14:10.328] getGlobalsAndPackages() ...
  [22:14:10.328] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:10.329] Resolving globals: FALSE
  [22:14:10.330] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.331] - globals: [3] 'FUN', 'args', 'a'
  [22:14:10.331] 
  [22:14:10.331] getGlobalsAndPackages() ... DONE
  [22:14:10.333] Packages needed by the future expression (n = 0): <none>
  [22:14:10.334] Packages needed by future strategies (n = 0): <none>
  [22:14:10.339] {
  [22:14:10.339]     {
  [22:14:10.339]         ...future.startTime <- Sys.time()
  [22:14:10.339]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.339]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.339]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.339]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.339]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.339]         {
  [22:14:10.339]             {
  [22:14:10.339]                 {
  [22:14:10.339]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.339]                   version <- if (has_future) 
  [22:14:10.339]                     packageVersion("future")
  [22:14:10.339]                   else NULL
  [22:14:10.339]                   if (!has_future || version < "1.8.0") {
  [22:14:10.339]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.339]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.339]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.339]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.339]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.339]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.339]                     info <- paste(info, collapse = "; ")
  [22:14:10.339]                     if (!has_future) {
  [22:14:10.339]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.339]                         info)
  [22:14:10.339]                     }
  [22:14:10.339]                     else {
  [22:14:10.339]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.339]                         info, version)
  [22:14:10.339]                     }
  [22:14:10.339]                     stop(msg)
  [22:14:10.339]                   }
  [22:14:10.339]                 }
  [22:14:10.339]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.339]                 options(mc.cores = 1L)
  [22:14:10.339]             }
  [22:14:10.339]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.339]         }
  [22:14:10.339]     }
  [22:14:10.339]     if (is.na(TRUE)) {
  [22:14:10.339]     }
  [22:14:10.339]     else {
  [22:14:10.339]         if (TRUE) {
  [22:14:10.339]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.339]         }
  [22:14:10.339]         else {
  [22:14:10.339]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.339]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.339]         }
  [22:14:10.339]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.339]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.339]             sink(type = "output", split = FALSE)
  [22:14:10.339]             close(...future.stdout)
  [22:14:10.339]         }, add = TRUE)
  [22:14:10.339]     }
  [22:14:10.339]     ...future.frame <- sys.nframe()
  [22:14:10.339]     ...future.conditions <- list()
  [22:14:10.339]     ...future.result <- tryCatch({
  [22:14:10.339]         withCallingHandlers({
  [22:14:10.339]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.339]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.339]                 version = "1.8")
  [22:14:10.339]         }, condition = local({
  [22:14:10.339]             inherits <- base::inherits
  [22:14:10.339]             invokeRestart <- base::invokeRestart
  [22:14:10.339]             length <- base::length
  [22:14:10.339]             seq.int <- base::seq.int
  [22:14:10.339]             sys.calls <- base::sys.calls
  [22:14:10.339]             `[[` <- base::`[[`
  [22:14:10.339]             `+` <- base::`+`
  [22:14:10.339]             `<<-` <- base::`<<-`
  [22:14:10.339]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.339]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.339]                   3L)]
  [22:14:10.339]             }
  [22:14:10.339]             function(cond) {
  [22:14:10.339]                 if (inherits(cond, "error")) {
  [22:14:10.339]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.339]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.339]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.339]                     signaled = 0L)
  [22:14:10.339]                   signalCondition(cond)
  [22:14:10.339]                 }
  [22:14:10.339]                 else if (inherits(cond, "condition")) {
  [22:14:10.339]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.339]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.339]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.339]                   if (inherits(cond, "message")) {
  [22:14:10.339]                     if (!signal) 
  [22:14:10.339]                       invokeRestart("muffleMessage")
  [22:14:10.339]                   }
  [22:14:10.339]                   else if (inherits(cond, "warning")) {
  [22:14:10.339]                     if (!signal) 
  [22:14:10.339]                       invokeRestart("muffleWarning")
  [22:14:10.339]                   }
  [22:14:10.339]                   else {
  [22:14:10.339]                     if (!signal) {
  [22:14:10.339]                       restarts <- computeRestarts(cond)
  [22:14:10.339]                       for (restart in restarts) {
  [22:14:10.339]                         name <- restart$name
  [22:14:10.339]                         if (is.null(name)) 
  [22:14:10.339]                           next
  [22:14:10.339]                         if (!grepl("^muffle", name)) 
  [22:14:10.339]                           next
  [22:14:10.339]                         invokeRestart(restart)
  [22:14:10.339]                         break
  [22:14:10.339]                       }
  [22:14:10.339]                     }
  [22:14:10.339]                   }
  [22:14:10.339]                 }
  [22:14:10.339]             }
  [22:14:10.339]         }))
  [22:14:10.339]     }, error = function(ex) {
  [22:14:10.339]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.339]             version = "1.8"), class = "FutureResult")
  [22:14:10.339]     }, finally = {
  [22:14:10.339]         {
  [22:14:10.339]             {
  [22:14:10.339]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.339]             }
  [22:14:10.339]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.339]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.339]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.339]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.339]             {
  [22:14:10.339]                 if (substitute) 
  [22:14:10.339]                   expr <- substitute(expr)
  [22:14:10.339]                 if (is.function(workers)) 
  [22:14:10.339]                   workers <- workers()
  [22:14:10.339]                 workers <- as.integer(workers)
  [22:14:10.339]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.339]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.339]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.339]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.339]                     local = TRUE, label = label, ...))
  [22:14:10.339]                 }
  [22:14:10.339]                 oopts <- options(mc.cores = workers)
  [22:14:10.339]                 on.exit(options(oopts))
  [22:14:10.339]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.339]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.339]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.339]                   label = label, ...)
  [22:14:10.339]                 if (!future$lazy) 
  [22:14:10.339]                   future <- run(future)
  [22:14:10.339]                 invisible(future)
  [22:14:10.339]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.339]         }
  [22:14:10.339]         options(...future.oldOptions)
  [22:14:10.339]     })
  [22:14:10.339]     if (is.na(TRUE)) {
  [22:14:10.339]     }
  [22:14:10.339]     else {
  [22:14:10.339]         sink(type = "output", split = FALSE)
  [22:14:10.339]         if (TRUE) {
  [22:14:10.339]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.339]         }
  [22:14:10.339]         else {
  [22:14:10.339]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.339]         }
  [22:14:10.339]         close(...future.stdout)
  [22:14:10.339]         ...future.stdout <- NULL
  [22:14:10.339]     }
  [22:14:10.339]     ...future.result$conditions <- ...future.conditions
  [22:14:10.339]     ...future.result
  [22:14:10.339] }
  [22:14:10.342] requestCore(): workers = 2
  [22:14:10.345] MulticoreFuture started
  [22:14:10.346] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1dc2470>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.358] plan(): Setting new future strategy stack:
  [22:14:10.359] List of future strategies:
  [22:14:10.359] 1. sequential:
  [22:14:10.359]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.359]    - tweaked: FALSE
  [22:14:10.359]    - call: NULL
  [22:14:10.361] plan(): nbrOfWorkers() = 1
  [22:14:10.362] plan(): Setting new future strategy stack:
  [22:14:10.363] List of future strategies:
  [22:14:10.363] 1. multicore:
  [22:14:10.363]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.363]    - tweaked: FALSE
  [22:14:10.363]    - call: plan(strategy)
  [22:14:10.365] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:10.389] futureCall() ...
  [22:14:10.390] Globals to be used in the future:
  [22:14:10.390] List of 3
  [22:14:10.390]  $ a   : num 3
  [22:14:10.390]  $ FUN :function (x, y)  
  [22:14:10.390]  $ args:List of 2
  [22:14:10.390]   ..$ x: num 42
  [22:14:10.390]   ..$ y: num 12
  [22:14:10.390]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.390]  - attr(*, "where")=List of 3
  [22:14:10.390]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.390]   ..$ FUN :<environment: 0x29f2018> 
  [22:14:10.390]   ..$ args:<environment: 0x29cebd0> 
  [22:14:10.390]  - attr(*, "resolved")= logi FALSE
  [22:14:10.390]  - attr(*, "total_size")= num NA
  [22:14:10.406] getGlobalsAndPackages() ...
  [22:14:10.406] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.406] Resolving globals: FALSE
  [22:14:10.408] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.408] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.408] 
  [22:14:10.409] getGlobalsAndPackages() ... DONE
  [22:14:10.411] Packages needed by the future expression (n = 0): <none>
  [22:14:10.411] Packages needed by future strategies (n = 0): <none>
  [22:14:10.416] {
  [22:14:10.416]     {
  [22:14:10.416]         ...future.startTime <- Sys.time()
  [22:14:10.416]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.416]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.416]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.416]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.416]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.416]         {
  [22:14:10.416]             {
  [22:14:10.416]                 {
  [22:14:10.416]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.416]                   version <- if (has_future) 
  [22:14:10.416]                     packageVersion("future")
  [22:14:10.416]                   else NULL
  [22:14:10.416]                   if (!has_future || version < "1.8.0") {
  [22:14:10.416]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.416]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.416]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.416]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.416]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.416]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.416]                     info <- paste(info, collapse = "; ")
  [22:14:10.416]                     if (!has_future) {
  [22:14:10.416]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.416]                         info)
  [22:14:10.416]                     }
  [22:14:10.416]                     else {
  [22:14:10.416]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.416]                         info, version)
  [22:14:10.416]                     }
  [22:14:10.416]                     stop(msg)
  [22:14:10.416]                   }
  [22:14:10.416]                 }
  [22:14:10.416]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.416]                 options(mc.cores = 1L)
  [22:14:10.416]             }
  [22:14:10.416]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.416]         }
  [22:14:10.416]     }
  [22:14:10.416]     if (is.na(TRUE)) {
  [22:14:10.416]     }
  [22:14:10.416]     else {
  [22:14:10.416]         if (TRUE) {
  [22:14:10.416]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.416]         }
  [22:14:10.416]         else {
  [22:14:10.416]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.416]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.416]         }
  [22:14:10.416]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.416]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.416]             sink(type = "output", split = FALSE)
  [22:14:10.416]             close(...future.stdout)
  [22:14:10.416]         }, add = TRUE)
  [22:14:10.416]     }
  [22:14:10.416]     ...future.frame <- sys.nframe()
  [22:14:10.416]     ...future.conditions <- list()
  [22:14:10.416]     ...future.result <- tryCatch({
  [22:14:10.416]         withCallingHandlers({
  [22:14:10.416]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.416]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.416]                 version = "1.8")
  [22:14:10.416]         }, condition = local({
  [22:14:10.416]             inherits <- base::inherits
  [22:14:10.416]             invokeRestart <- base::invokeRestart
  [22:14:10.416]             length <- base::length
  [22:14:10.416]             seq.int <- base::seq.int
  [22:14:10.416]             sys.calls <- base::sys.calls
  [22:14:10.416]             `[[` <- base::`[[`
  [22:14:10.416]             `+` <- base::`+`
  [22:14:10.416]             `<<-` <- base::`<<-`
  [22:14:10.416]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.416]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.416]                   3L)]
  [22:14:10.416]             }
  [22:14:10.416]             function(cond) {
  [22:14:10.416]                 if (inherits(cond, "error")) {
  [22:14:10.416]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.416]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.416]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.416]                     signaled = 0L)
  [22:14:10.416]                   signalCondition(cond)
  [22:14:10.416]                 }
  [22:14:10.416]                 else if (inherits(cond, "condition")) {
  [22:14:10.416]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.416]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.416]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.416]                   if (inherits(cond, "message")) {
  [22:14:10.416]                     if (!signal) 
  [22:14:10.416]                       invokeRestart("muffleMessage")
  [22:14:10.416]                   }
  [22:14:10.416]                   else if (inherits(cond, "warning")) {
  [22:14:10.416]                     if (!signal) 
  [22:14:10.416]                       invokeRestart("muffleWarning")
  [22:14:10.416]                   }
  [22:14:10.416]                   else {
  [22:14:10.416]                     if (!signal) {
  [22:14:10.416]                       restarts <- computeRestarts(cond)
  [22:14:10.416]                       for (restart in restarts) {
  [22:14:10.416]                         name <- restart$name
  [22:14:10.416]                         if (is.null(name)) 
  [22:14:10.416]                           next
  [22:14:10.416]                         if (!grepl("^muffle", name)) 
  [22:14:10.416]                           next
  [22:14:10.416]                         invokeRestart(restart)
  [22:14:10.416]                         break
  [22:14:10.416]                       }
  [22:14:10.416]                     }
  [22:14:10.416]                   }
  [22:14:10.416]                 }
  [22:14:10.416]             }
  [22:14:10.416]         }))
  [22:14:10.416]     }, error = function(ex) {
  [22:14:10.416]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.416]             version = "1.8"), class = "FutureResult")
  [22:14:10.416]     }, finally = {
  [22:14:10.416]         {
  [22:14:10.416]             {
  [22:14:10.416]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.416]             }
  [22:14:10.416]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.416]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.416]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.416]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.416]             {
  [22:14:10.416]                 if (substitute) 
  [22:14:10.416]                   expr <- substitute(expr)
  [22:14:10.416]                 if (is.function(workers)) 
  [22:14:10.416]                   workers <- workers()
  [22:14:10.416]                 workers <- as.integer(workers)
  [22:14:10.416]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.416]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.416]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.416]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.416]                     local = TRUE, label = label, ...))
  [22:14:10.416]                 }
  [22:14:10.416]                 oopts <- options(mc.cores = workers)
  [22:14:10.416]                 on.exit(options(oopts))
  [22:14:10.416]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.416]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.416]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.416]                   label = label, ...)
  [22:14:10.416]                 if (!future$lazy) 
  [22:14:10.416]                   future <- run(future)
  [22:14:10.416]                 invisible(future)
  [22:14:10.416]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.416]         }
  [22:14:10.416]         options(...future.oldOptions)
  [22:14:10.416]     })
  [22:14:10.416]     if (is.na(TRUE)) {
  [22:14:10.416]     }
  [22:14:10.416]     else {
  [22:14:10.416]         sink(type = "output", split = FALSE)
  [22:14:10.416]         if (TRUE) {
  [22:14:10.416]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.416]         }
  [22:14:10.416]         else {
  [22:14:10.416]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.416]         }
  [22:14:10.416]         close(...future.stdout)
  [22:14:10.416]         ...future.stdout <- NULL
  [22:14:10.416]     }
  [22:14:10.416]     ...future.result$conditions <- ...future.conditions
  [22:14:10.416]     ...future.result
  [22:14:10.416] }
  [22:14:10.422] requestCore(): workers = 2
  [22:14:10.426] MulticoreFuture started
  [22:14:10.427] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2e6f338>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.439] plan(): Setting new future strategy stack:
  [22:14:10.440] List of future strategies:
  [22:14:10.440] 1. sequential:
  [22:14:10.440]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.440]    - tweaked: FALSE
  [22:14:10.440]    - call: NULL
  [22:14:10.443] plan(): nbrOfWorkers() = 1
  [22:14:10.445] plan(): Setting new future strategy stack:
  [22:14:10.446] List of future strategies:
  [22:14:10.446] 1. multicore:
  [22:14:10.446]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.446]    - tweaked: FALSE
  [22:14:10.446]    - call: plan(strategy)
  [22:14:10.449] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:10.459] futureCall() ...
  [22:14:10.460] Globals to be used in the future:
  [22:14:10.461] List of 3
  [22:14:10.461]  $ a   : num 3
  [22:14:10.461]  $ FUN :function (x, y)  
  [22:14:10.461]  $ args:List of 2
  [22:14:10.461]   ..$ x: num 42
  [22:14:10.461]   ..$ y: num 12
  [22:14:10.461]  - attr(*, "where")=List of 3
  [22:14:10.461]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:10.461]   ..$ FUN :<environment: 0x1880dd0> 
  [22:14:10.461]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:10.461]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.461]  - attr(*, "resolved")= logi FALSE
  [22:14:10.461]  - attr(*, "total_size")= num NA
  [22:14:10.480] getGlobalsAndPackages() ...
  [22:14:10.480] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.481] Resolving globals: FALSE
  [22:14:10.482] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.482] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.483] 
  [22:14:10.483] getGlobalsAndPackages() ... DONE
  [22:14:10.485] Packages needed by the future expression (n = 0): <none>
  [22:14:10.485] Packages needed by future strategies (n = 0): <none>
  [22:14:10.490] {
  [22:14:10.490]     {
  [22:14:10.490]         ...future.startTime <- Sys.time()
  [22:14:10.490]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.490]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.490]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.490]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.490]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.490]         {
  [22:14:10.490]             {
  [22:14:10.490]                 {
  [22:14:10.490]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.490]                   version <- if (has_future) 
  [22:14:10.490]                     packageVersion("future")
  [22:14:10.490]                   else NULL
  [22:14:10.490]                   if (!has_future || version < "1.8.0") {
  [22:14:10.490]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.490]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.490]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.490]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.490]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.490]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.490]                     info <- paste(info, collapse = "; ")
  [22:14:10.490]                     if (!has_future) {
  [22:14:10.490]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.490]                         info)
  [22:14:10.490]                     }
  [22:14:10.490]                     else {
  [22:14:10.490]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.490]                         info, version)
  [22:14:10.490]                     }
  [22:14:10.490]                     stop(msg)
  [22:14:10.490]                   }
  [22:14:10.490]                 }
  [22:14:10.490]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.490]                 options(mc.cores = 1L)
  [22:14:10.490]             }
  [22:14:10.490]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.490]         }
  [22:14:10.490]     }
  [22:14:10.490]     if (is.na(TRUE)) {
  [22:14:10.490]     }
  [22:14:10.490]     else {
  [22:14:10.490]         if (TRUE) {
  [22:14:10.490]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.490]         }
  [22:14:10.490]         else {
  [22:14:10.490]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.490]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.490]         }
  [22:14:10.490]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.490]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.490]             sink(type = "output", split = FALSE)
  [22:14:10.490]             close(...future.stdout)
  [22:14:10.490]         }, add = TRUE)
  [22:14:10.490]     }
  [22:14:10.490]     ...future.frame <- sys.nframe()
  [22:14:10.490]     ...future.conditions <- list()
  [22:14:10.490]     ...future.result <- tryCatch({
  [22:14:10.490]         withCallingHandlers({
  [22:14:10.490]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.490]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.490]                 version = "1.8")
  [22:14:10.490]         }, condition = local({
  [22:14:10.490]             inherits <- base::inherits
  [22:14:10.490]             invokeRestart <- base::invokeRestart
  [22:14:10.490]             length <- base::length
  [22:14:10.490]             seq.int <- base::seq.int
  [22:14:10.490]             sys.calls <- base::sys.calls
  [22:14:10.490]             `[[` <- base::`[[`
  [22:14:10.490]             `+` <- base::`+`
  [22:14:10.490]             `<<-` <- base::`<<-`
  [22:14:10.490]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.490]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.490]                   3L)]
  [22:14:10.490]             }
  [22:14:10.490]             function(cond) {
  [22:14:10.490]                 if (inherits(cond, "error")) {
  [22:14:10.490]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.490]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.490]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.490]                     signaled = 0L)
  [22:14:10.490]                   signalCondition(cond)
  [22:14:10.490]                 }
  [22:14:10.490]                 else if (inherits(cond, "condition")) {
  [22:14:10.490]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.490]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.490]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.490]                   if (inherits(cond, "message")) {
  [22:14:10.490]                     if (!signal) 
  [22:14:10.490]                       invokeRestart("muffleMessage")
  [22:14:10.490]                   }
  [22:14:10.490]                   else if (inherits(cond, "warning")) {
  [22:14:10.490]                     if (!signal) 
  [22:14:10.490]                       invokeRestart("muffleWarning")
  [22:14:10.490]                   }
  [22:14:10.490]                   else {
  [22:14:10.490]                     if (!signal) {
  [22:14:10.490]                       restarts <- computeRestarts(cond)
  [22:14:10.490]                       for (restart in restarts) {
  [22:14:10.490]                         name <- restart$name
  [22:14:10.490]                         if (is.null(name)) 
  [22:14:10.490]                           next
  [22:14:10.490]                         if (!grepl("^muffle", name)) 
  [22:14:10.490]                           next
  [22:14:10.490]                         invokeRestart(restart)
  [22:14:10.490]                         break
  [22:14:10.490]                       }
  [22:14:10.490]                     }
  [22:14:10.490]                   }
  [22:14:10.490]                 }
  [22:14:10.490]             }
  [22:14:10.490]         }))
  [22:14:10.490]     }, error = function(ex) {
  [22:14:10.490]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.490]             version = "1.8"), class = "FutureResult")
  [22:14:10.490]     }, finally = {
  [22:14:10.490]         {
  [22:14:10.490]             {
  [22:14:10.490]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.490]             }
  [22:14:10.490]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.490]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.490]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.490]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.490]             {
  [22:14:10.490]                 if (substitute) 
  [22:14:10.490]                   expr <- substitute(expr)
  [22:14:10.490]                 if (is.function(workers)) 
  [22:14:10.490]                   workers <- workers()
  [22:14:10.490]                 workers <- as.integer(workers)
  [22:14:10.490]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.490]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.490]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.490]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.490]                     local = TRUE, label = label, ...))
  [22:14:10.490]                 }
  [22:14:10.490]                 oopts <- options(mc.cores = workers)
  [22:14:10.490]                 on.exit(options(oopts))
  [22:14:10.490]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.490]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.490]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.490]                   label = label, ...)
  [22:14:10.490]                 if (!future$lazy) 
  [22:14:10.490]                   future <- run(future)
  [22:14:10.490]                 invisible(future)
  [22:14:10.490]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.490]         }
  [22:14:10.490]         options(...future.oldOptions)
  [22:14:10.490]     })
  [22:14:10.490]     if (is.na(TRUE)) {
  [22:14:10.490]     }
  [22:14:10.490]     else {
  [22:14:10.490]         sink(type = "output", split = FALSE)
  [22:14:10.490]         if (TRUE) {
  [22:14:10.490]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.490]         }
  [22:14:10.490]         else {
  [22:14:10.490]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.490]         }
  [22:14:10.490]         close(...future.stdout)
  [22:14:10.490]         ...future.stdout <- NULL
  [22:14:10.490]     }
  [22:14:10.490]     ...future.result$conditions <- ...future.conditions
  [22:14:10.490]     ...future.result
  [22:14:10.490] }
  [22:14:10.493] requestCore(): workers = 2
  [22:14:10.496] MulticoreFuture started
  [22:14:10.497] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1bd1870>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  [22:14:10.503] plan(): Setting new future strategy stack:
  [22:14:10.504] List of future strategies:
  [22:14:10.504] 1. sequential:
  [22:14:10.504]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.504]    - tweaked: FALSE
  [22:14:10.504]    - call: NULL
  [22:14:10.505] plan(): nbrOfWorkers() = 1
  [22:14:10.507] plan(): Setting new future strategy stack:
  [22:14:10.507] List of future strategies:
  [22:14:10.507] 1. multicore:
  [22:14:10.507]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.507]    - tweaked: FALSE
  [22:14:10.507]    - call: plan(strategy)
  [22:14:10.510] plan(): nbrOfWorkers() = 2
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:10.519] futureCall() ...
  [22:14:10.519] Globals to be used in the future:
  [22:14:10.520] List of 2
  [22:14:10.520]  $ FUN :function (x, y)  
  [22:14:10.520]  $ args:List of 2
  [22:14:10.520]   ..$ x: num 42
  [22:14:10.520]   ..$ y: num 12
  [22:14:10.520]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.520]  - attr(*, "where")=List of 2
  [22:14:10.520]   ..$ FUN :<environment: 0x2a22710> 
  [22:14:10.520]   ..$ args:<environment: 0x2a22710> 
  [22:14:10.520]  - attr(*, "resolved")= logi FALSE
  [22:14:10.520]  - attr(*, "total_size")= num NA
  [22:14:10.536] getGlobalsAndPackages() ...
  [22:14:10.536] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:10.537] Resolving globals: FALSE
  [22:14:10.538] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:10.538] - globals: [2] 'FUN', 'args'
  [22:14:10.538] 
  [22:14:10.539] getGlobalsAndPackages() ... DONE
  [22:14:10.539] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2df6f28>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.542] Packages needed by the future expression (n = 0): <none>
  [22:14:10.543] Packages needed by future strategies (n = 0): <none>
  [22:14:10.552] {
  [22:14:10.552]     {
  [22:14:10.552]         ...future.startTime <- Sys.time()
  [22:14:10.552]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.552]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.552]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.552]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.552]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.552]         {
  [22:14:10.552]             {
  [22:14:10.552]                 {
  [22:14:10.552]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.552]                   version <- if (has_future) 
  [22:14:10.552]                     packageVersion("future")
  [22:14:10.552]                   else NULL
  [22:14:10.552]                   if (!has_future || version < "1.8.0") {
  [22:14:10.552]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.552]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.552]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.552]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.552]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.552]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.552]                     info <- paste(info, collapse = "; ")
  [22:14:10.552]                     if (!has_future) {
  [22:14:10.552]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.552]                         info)
  [22:14:10.552]                     }
  [22:14:10.552]                     else {
  [22:14:10.552]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.552]                         info, version)
  [22:14:10.552]                     }
  [22:14:10.552]                     stop(msg)
  [22:14:10.552]                   }
  [22:14:10.552]                 }
  [22:14:10.552]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.552]                 options(mc.cores = 1L)
  [22:14:10.552]             }
  [22:14:10.552]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.552]         }
  [22:14:10.552]     }
  [22:14:10.552]     if (is.na(TRUE)) {
  [22:14:10.552]     }
  [22:14:10.552]     else {
  [22:14:10.552]         if (TRUE) {
  [22:14:10.552]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.552]         }
  [22:14:10.552]         else {
  [22:14:10.552]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.552]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.552]         }
  [22:14:10.552]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.552]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.552]             sink(type = "output", split = FALSE)
  [22:14:10.552]             close(...future.stdout)
  [22:14:10.552]         }, add = TRUE)
  [22:14:10.552]     }
  [22:14:10.552]     ...future.frame <- sys.nframe()
  [22:14:10.552]     ...future.conditions <- list()
  [22:14:10.552]     ...future.result <- tryCatch({
  [22:14:10.552]         withCallingHandlers({
  [22:14:10.552]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.552]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.552]                 version = "1.8")
  [22:14:10.552]         }, condition = local({
  [22:14:10.552]             inherits <- base::inherits
  [22:14:10.552]             invokeRestart <- base::invokeRestart
  [22:14:10.552]             length <- base::length
  [22:14:10.552]             seq.int <- base::seq.int
  [22:14:10.552]             sys.calls <- base::sys.calls
  [22:14:10.552]             `[[` <- base::`[[`
  [22:14:10.552]             `+` <- base::`+`
  [22:14:10.552]             `<<-` <- base::`<<-`
  [22:14:10.552]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.552]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.552]                   3L)]
  [22:14:10.552]             }
  [22:14:10.552]             function(cond) {
  [22:14:10.552]                 if (inherits(cond, "error")) {
  [22:14:10.552]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.552]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.552]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.552]                     signaled = 0L)
  [22:14:10.552]                   signalCondition(cond)
  [22:14:10.552]                 }
  [22:14:10.552]                 else if (inherits(cond, "condition")) {
  [22:14:10.552]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.552]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.552]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.552]                   if (inherits(cond, "message")) {
  [22:14:10.552]                     if (!signal) 
  [22:14:10.552]                       invokeRestart("muffleMessage")
  [22:14:10.552]                   }
  [22:14:10.552]                   else if (inherits(cond, "warning")) {
  [22:14:10.552]                     if (!signal) 
  [22:14:10.552]                       invokeRestart("muffleWarning")
  [22:14:10.552]                   }
  [22:14:10.552]                   else {
  [22:14:10.552]                     if (!signal) {
  [22:14:10.552]                       restarts <- computeRestarts(cond)
  [22:14:10.552]                       for (restart in restarts) {
  [22:14:10.552]                         name <- restart$name
  [22:14:10.552]                         if (is.null(name)) 
  [22:14:10.552]                           next
  [22:14:10.552]                         if (!grepl("^muffle", name)) 
  [22:14:10.552]                           next
  [22:14:10.552]                         invokeRestart(restart)
  [22:14:10.552]                         break
  [22:14:10.552]                       }
  [22:14:10.552]                     }
  [22:14:10.552]                   }
  [22:14:10.552]                 }
  [22:14:10.552]             }
  [22:14:10.552]         }))
  [22:14:10.552]     }, error = function(ex) {
  [22:14:10.552]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.552]             version = "1.8"), class = "FutureResult")
  [22:14:10.552]     }, finally = {
  [22:14:10.552]         {
  [22:14:10.552]             {
  [22:14:10.552]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.552]             }
  [22:14:10.552]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.552]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.552]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.552]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.552]             {
  [22:14:10.552]                 if (substitute) 
  [22:14:10.552]                   expr <- substitute(expr)
  [22:14:10.552]                 if (is.function(workers)) 
  [22:14:10.552]                   workers <- workers()
  [22:14:10.552]                 workers <- as.integer(workers)
  [22:14:10.552]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.552]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.552]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.552]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.552]                     local = TRUE, label = label, ...))
  [22:14:10.552]                 }
  [22:14:10.552]                 oopts <- options(mc.cores = workers)
  [22:14:10.552]                 on.exit(options(oopts))
  [22:14:10.552]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.552]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.552]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.552]                   label = label, ...)
  [22:14:10.552]                 if (!future$lazy) 
  [22:14:10.552]                   future <- run(future)
  [22:14:10.552]                 invisible(future)
  [22:14:10.552]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.552]         }
  [22:14:10.552]         options(...future.oldOptions)
  [22:14:10.552]     })
  [22:14:10.552]     if (is.na(TRUE)) {
  [22:14:10.552]     }
  [22:14:10.552]     else {
  [22:14:10.552]         sink(type = "output", split = FALSE)
  [22:14:10.552]         if (TRUE) {
  [22:14:10.552]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.552]         }
  [22:14:10.552]         else {
  [22:14:10.552]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.552]         }
  [22:14:10.552]         close(...future.stdout)
  [22:14:10.552]         ...future.stdout <- NULL
  [22:14:10.552]     }
  [22:14:10.552]     ...future.result$conditions <- ...future.conditions
  [22:14:10.552]     ...future.result
  [22:14:10.552] }
  [22:14:10.554] requestCore(): workers = 2
  [22:14:10.558] MulticoreFuture started
  [22:14:10.563] plan(): Setting new future strategy stack:
  [22:14:10.564] List of future strategies:
  [22:14:10.564] 1. sequential:
  [22:14:10.564]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.564]    - tweaked: FALSE
  [22:14:10.564]    - call: NULL
  [22:14:10.567] plan(): nbrOfWorkers() = 1
  [22:14:10.570] plan(): Setting new future strategy stack:
  [22:14:10.570] List of future strategies:
  [22:14:10.570] 1. multicore:
  [22:14:10.570]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.570]    - tweaked: FALSE
  [22:14:10.570]    - call: plan(strategy)
  [22:14:10.574] plan(): nbrOfWorkers() = 2
  [22:14:10.577] signalConditions() ...
  [22:14:10.578]  - include = 'immediateCondition'
  [22:14:10.578]  - exclude = 
  [22:14:10.579]  - resignal = FALSE
  [22:14:10.579]  - Number of conditions: 1
  [22:14:10.580] signalConditions() ... done
  [22:14:10.580] signalConditions() ...
  [22:14:10.580]  - include = 'immediateCondition'
  [22:14:10.581]  - exclude = 
  [22:14:10.581]  - resignal = FALSE
  [22:14:10.582]  - Number of conditions: 1
  [22:14:10.582] signalConditions() ... done
  [22:14:10.583] Future state: 'finished'
  [22:14:10.583] signalConditions() ...
  [22:14:10.584]  - include = 'condition'
  [22:14:10.584]  - exclude = 'immediateCondition'
  [22:14:10.584]  - resignal = TRUE
  [22:14:10.585]  - Number of conditions: 1
  [22:14:10.585]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:10.586] signalConditions() ... done
  [22:14:10.586] futureCall() ...
  [22:14:10.588] Globals to be used in the future:
  [22:14:10.588] List of 3
  [22:14:10.588]  $ a   : num 3
  [22:14:10.588]  $ FUN :function (x, y)  
  [22:14:10.588]  $ args:List of 2
  [22:14:10.588]   ..$ x: num 42
  [22:14:10.588]   ..$ y: num 12
  [22:14:10.588]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.588]  - attr(*, "where")=List of 3
  [22:14:10.588]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.588]   ..$ FUN :<environment: 0x18b5b98> 
  [22:14:10.588]   ..$ args:<environment: 0x1a71d08> 
  [22:14:10.588]  - attr(*, "resolved")= logi FALSE
  [22:14:10.588]  - attr(*, "total_size")= num NA
  [22:14:10.608] getGlobalsAndPackages() ...
  [22:14:10.608] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.609] Resolving globals: FALSE
  [22:14:10.610] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.610] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.611] 
  [22:14:10.611] getGlobalsAndPackages() ... DONE
  [22:14:10.612] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1c9f3f0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.615] Packages needed by the future expression (n = 0): <none>
  [22:14:10.615] Packages needed by future strategies (n = 0): <none>
  [22:14:10.620] {
  [22:14:10.620]     {
  [22:14:10.620]         ...future.startTime <- Sys.time()
  [22:14:10.620]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.620]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.620]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.620]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.620]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.620]         {
  [22:14:10.620]             {
  [22:14:10.620]                 {
  [22:14:10.620]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.620]                   version <- if (has_future) 
  [22:14:10.620]                     packageVersion("future")
  [22:14:10.620]                   else NULL
  [22:14:10.620]                   if (!has_future || version < "1.8.0") {
  [22:14:10.620]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.620]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.620]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.620]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.620]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.620]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.620]                     info <- paste(info, collapse = "; ")
  [22:14:10.620]                     if (!has_future) {
  [22:14:10.620]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.620]                         info)
  [22:14:10.620]                     }
  [22:14:10.620]                     else {
  [22:14:10.620]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.620]                         info, version)
  [22:14:10.620]                     }
  [22:14:10.620]                     stop(msg)
  [22:14:10.620]                   }
  [22:14:10.620]                 }
  [22:14:10.620]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.620]                 options(mc.cores = 1L)
  [22:14:10.620]             }
  [22:14:10.620]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.620]         }
  [22:14:10.620]     }
  [22:14:10.620]     if (is.na(TRUE)) {
  [22:14:10.620]     }
  [22:14:10.620]     else {
  [22:14:10.620]         if (TRUE) {
  [22:14:10.620]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.620]         }
  [22:14:10.620]         else {
  [22:14:10.620]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.620]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.620]         }
  [22:14:10.620]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.620]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.620]             sink(type = "output", split = FALSE)
  [22:14:10.620]             close(...future.stdout)
  [22:14:10.620]         }, add = TRUE)
  [22:14:10.620]     }
  [22:14:10.620]     ...future.frame <- sys.nframe()
  [22:14:10.620]     ...future.conditions <- list()
  [22:14:10.620]     ...future.result <- tryCatch({
  [22:14:10.620]         withCallingHandlers({
  [22:14:10.620]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.620]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.620]                 version = "1.8")
  [22:14:10.620]         }, condition = local({
  [22:14:10.620]             inherits <- base::inherits
  [22:14:10.620]             invokeRestart <- base::invokeRestart
  [22:14:10.620]             length <- base::length
  [22:14:10.620]             seq.int <- base::seq.int
  [22:14:10.620]             sys.calls <- base::sys.calls
  [22:14:10.620]             `[[` <- base::`[[`
  [22:14:10.620]             `+` <- base::`+`
  [22:14:10.620]             `<<-` <- base::`<<-`
  [22:14:10.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.620]                   3L)]
  [22:14:10.620]             }
  [22:14:10.620]             function(cond) {
  [22:14:10.620]                 if (inherits(cond, "error")) {
  [22:14:10.620]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.620]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.620]                     signaled = 0L)
  [22:14:10.620]                   signalCondition(cond)
  [22:14:10.620]                 }
  [22:14:10.620]                 else if (inherits(cond, "condition")) {
  [22:14:10.620]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.620]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.620]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.620]                   if (inherits(cond, "message")) {
  [22:14:10.620]                     if (!signal) 
  [22:14:10.620]                       invokeRestart("muffleMessage")
  [22:14:10.620]                   }
  [22:14:10.620]                   else if (inherits(cond, "warning")) {
  [22:14:10.620]                     if (!signal) 
  [22:14:10.620]                       invokeRestart("muffleWarning")
  [22:14:10.620]                   }
  [22:14:10.620]                   else {
  [22:14:10.620]                     if (!signal) {
  [22:14:10.620]                       restarts <- computeRestarts(cond)
  [22:14:10.620]                       for (restart in restarts) {
  [22:14:10.620]                         name <- restart$name
  [22:14:10.620]                         if (is.null(name)) 
  [22:14:10.620]                           next
  [22:14:10.620]                         if (!grepl("^muffle", name)) 
  [22:14:10.620]                           next
  [22:14:10.620]                         invokeRestart(restart)
  [22:14:10.620]                         break
  [22:14:10.620]                       }
  [22:14:10.620]                     }
  [22:14:10.620]                   }
  [22:14:10.620]                 }
  [22:14:10.620]             }
  [22:14:10.620]         }))
  [22:14:10.620]     }, error = function(ex) {
  [22:14:10.620]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.620]             version = "1.8"), class = "FutureResult")
  [22:14:10.620]     }, finally = {
  [22:14:10.620]         {
  [22:14:10.620]             {
  [22:14:10.620]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.620]             }
  [22:14:10.620]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.620]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.620]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.620]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.620]             {
  [22:14:10.620]                 if (substitute) 
  [22:14:10.620]                   expr <- substitute(expr)
  [22:14:10.620]                 if (is.function(workers)) 
  [22:14:10.620]                   workers <- workers()
  [22:14:10.620]                 workers <- as.integer(workers)
  [22:14:10.620]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.620]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.620]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.620]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.620]                     local = TRUE, label = label, ...))
  [22:14:10.620]                 }
  [22:14:10.620]                 oopts <- options(mc.cores = workers)
  [22:14:10.620]                 on.exit(options(oopts))
  [22:14:10.620]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.620]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.620]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.620]                   label = label, ...)
  [22:14:10.620]                 if (!future$lazy) 
  [22:14:10.620]                   future <- run(future)
  [22:14:10.620]                 invisible(future)
  [22:14:10.620]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.620]         }
  [22:14:10.620]         options(...future.oldOptions)
  [22:14:10.620]     })
  [22:14:10.620]     if (is.na(TRUE)) {
  [22:14:10.620]     }
  [22:14:10.620]     else {
  [22:14:10.620]         sink(type = "output", split = FALSE)
  [22:14:10.620]         if (TRUE) {
  [22:14:10.620]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.620]         }
  [22:14:10.620]         else {
  [22:14:10.620]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.620]         }
  [22:14:10.620]         close(...future.stdout)
  [22:14:10.620]         ...future.stdout <- NULL
  [22:14:10.620]     }
  [22:14:10.620]     ...future.result$conditions <- ...future.conditions
  [22:14:10.620]     ...future.result
  [22:14:10.620] }
  [22:14:10.623] requestCore(): workers = 2
  [22:14:10.626] MulticoreFuture started
  [22:14:10.630] plan(): Setting new future strategy stack:
  [22:14:10.631] List of future strategies:
  [22:14:10.631] 1. sequential:
  [22:14:10.631]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.631]    - tweaked: FALSE
  [22:14:10.631]    - call: NULL
  [22:14:10.633] plan(): nbrOfWorkers() = 1
  [22:14:10.634] plan(): Setting new future strategy stack:
  [22:14:10.635] List of future strategies:
  [22:14:10.635] 1. multicore:
  [22:14:10.635]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.635]    - tweaked: FALSE
  [22:14:10.635]    - call: plan(strategy)
  [22:14:10.638] plan(): nbrOfWorkers() = 2
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:10.646] futureCall() ...
  [22:14:10.647] Globals to be used in the future:
  [22:14:10.648] List of 3
  [22:14:10.648]  $ a   : num 3
  [22:14:10.648]  $ FUN :function (x, y)  
  [22:14:10.648]  $ args:List of 2
  [22:14:10.648]   ..$ x: num 42
  [22:14:10.648]   ..$ y: num 12
  [22:14:10.648]  - attr(*, "where")=List of 3
  [22:14:10.648]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:10.648]   ..$ FUN :<environment: 0x2a19238> 
  [22:14:10.648]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:10.648]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.648]  - attr(*, "resolved")= logi FALSE
  [22:14:10.648]  - attr(*, "total_size")= num NA
  [22:14:10.663] getGlobalsAndPackages() ...
  [22:14:10.664] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.664] Resolving globals: FALSE
  [22:14:10.665] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.666] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.666] 
  [22:14:10.667] getGlobalsAndPackages() ... DONE
  [22:14:10.667] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2e92298>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.670] Packages needed by the future expression (n = 0): <none>
  [22:14:10.671] Packages needed by future strategies (n = 0): <none>
  [22:14:10.681] {
  [22:14:10.681]     {
  [22:14:10.681]         ...future.startTime <- Sys.time()
  [22:14:10.681]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.681]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.681]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.681]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.681]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.681]         {
  [22:14:10.681]             {
  [22:14:10.681]                 {
  [22:14:10.681]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.681]                   version <- if (has_future) 
  [22:14:10.681]                     packageVersion("future")
  [22:14:10.681]                   else NULL
  [22:14:10.681]                   if (!has_future || version < "1.8.0") {
  [22:14:10.681]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.681]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.681]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.681]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.681]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.681]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.681]                     info <- paste(info, collapse = "; ")
  [22:14:10.681]                     if (!has_future) {
  [22:14:10.681]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.681]                         info)
  [22:14:10.681]                     }
  [22:14:10.681]                     else {
  [22:14:10.681]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.681]                         info, version)
  [22:14:10.681]                     }
  [22:14:10.681]                     stop(msg)
  [22:14:10.681]                   }
  [22:14:10.681]                 }
  [22:14:10.681]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.681]                 options(mc.cores = 1L)
  [22:14:10.681]             }
  [22:14:10.681]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.681]         }
  [22:14:10.681]     }
  [22:14:10.681]     if (is.na(TRUE)) {
  [22:14:10.681]     }
  [22:14:10.681]     else {
  [22:14:10.681]         if (TRUE) {
  [22:14:10.681]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.681]         }
  [22:14:10.681]         else {
  [22:14:10.681]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.681]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.681]         }
  [22:14:10.681]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.681]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.681]             sink(type = "output", split = FALSE)
  [22:14:10.681]             close(...future.stdout)
  [22:14:10.681]         }, add = TRUE)
  [22:14:10.681]     }
  [22:14:10.681]     ...future.frame <- sys.nframe()
  [22:14:10.681]     ...future.conditions <- list()
  [22:14:10.681]     ...future.result <- tryCatch({
  [22:14:10.681]         withCallingHandlers({
  [22:14:10.681]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.681]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.681]                 version = "1.8")
  [22:14:10.681]         }, condition = local({
  [22:14:10.681]             inherits <- base::inherits
  [22:14:10.681]             invokeRestart <- base::invokeRestart
  [22:14:10.681]             length <- base::length
  [22:14:10.681]             seq.int <- base::seq.int
  [22:14:10.681]             sys.calls <- base::sys.calls
  [22:14:10.681]             `[[` <- base::`[[`
  [22:14:10.681]             `+` <- base::`+`
  [22:14:10.681]             `<<-` <- base::`<<-`
  [22:14:10.681]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.681]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.681]                   3L)]
  [22:14:10.681]             }
  [22:14:10.681]             function(cond) {
  [22:14:10.681]                 if (inherits(cond, "error")) {
  [22:14:10.681]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.681]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.681]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.681]                     signaled = 0L)
  [22:14:10.681]                   signalCondition(cond)
  [22:14:10.681]                 }
  [22:14:10.681]                 else if (inherits(cond, "condition")) {
  [22:14:10.681]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.681]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.681]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.681]                   if (inherits(cond, "message")) {
  [22:14:10.681]                     if (!signal) 
  [22:14:10.681]                       invokeRestart("muffleMessage")
  [22:14:10.681]                   }
  [22:14:10.681]                   else if (inherits(cond, "warning")) {
  [22:14:10.681]                     if (!signal) 
  [22:14:10.681]                       invokeRestart("muffleWarning")
  [22:14:10.681]                   }
  [22:14:10.681]                   else {
  [22:14:10.681]                     if (!signal) {
  [22:14:10.681]                       restarts <- computeRestarts(cond)
  [22:14:10.681]                       for (restart in restarts) {
  [22:14:10.681]                         name <- restart$name
  [22:14:10.681]                         if (is.null(name)) 
  [22:14:10.681]                           next
  [22:14:10.681]                         if (!grepl("^muffle", name)) 
  [22:14:10.681]                           next
  [22:14:10.681]                         invokeRestart(restart)
  [22:14:10.681]                         break
  [22:14:10.681]                       }
  [22:14:10.681]                     }
  [22:14:10.681]                   }
  [22:14:10.681]                 }
  [22:14:10.681]             }
  [22:14:10.681]         }))
  [22:14:10.681]     }, error = function(ex) {
  [22:14:10.681]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.681]             version = "1.8"), class = "FutureResult")
  [22:14:10.681]     }, finally = {
  [22:14:10.681]         {
  [22:14:10.681]             {
  [22:14:10.681]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.681]             }
  [22:14:10.681]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.681]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.681]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.681]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.681]             {
  [22:14:10.681]                 if (substitute) 
  [22:14:10.681]                   expr <- substitute(expr)
  [22:14:10.681]                 if (is.function(workers)) 
  [22:14:10.681]                   workers <- workers()
  [22:14:10.681]                 workers <- as.integer(workers)
  [22:14:10.681]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.681]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.681]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.681]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.681]                     local = TRUE, label = label, ...))
  [22:14:10.681]                 }
  [22:14:10.681]                 oopts <- options(mc.cores = workers)
  [22:14:10.681]                 on.exit(options(oopts))
  [22:14:10.681]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.681]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.681]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.681]                   label = label, ...)
  [22:14:10.681]                 if (!future$lazy) 
  [22:14:10.681]                   future <- run(future)
  [22:14:10.681]                 invisible(future)
  [22:14:10.681]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.681]         }
  [22:14:10.681]         options(...future.oldOptions)
  [22:14:10.681]     })
  [22:14:10.681]     if (is.na(TRUE)) {
  [22:14:10.681]     }
  [22:14:10.681]     else {
  [22:14:10.681]         sink(type = "output", split = FALSE)
  [22:14:10.681]         if (TRUE) {
  [22:14:10.681]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.681]         }
  [22:14:10.681]         else {
  [22:14:10.681]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.681]         }
  [22:14:10.681]         close(...future.stdout)
  [22:14:10.681]         ...future.stdout <- NULL
  [22:14:10.681]     }
  [22:14:10.681]     ...future.result$conditions <- ...future.conditions
  [22:14:10.681]     ...future.result
  [22:14:10.681] }
  [22:14:10.683] requestCore(): workers = 2
  [22:14:10.687] MulticoreFuture started
  [22:14:10.697] plan(): Setting new future strategy stack:
  [22:14:10.698] List of future strategies:
  [22:14:10.698] 1. sequential:
  [22:14:10.698]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.698]    - tweaked: FALSE
  [22:14:10.698]    - call: NULL
  [22:14:10.701] plan(): nbrOfWorkers() = 1
  [22:14:10.702] plan(): Setting new future strategy stack:
  [22:14:10.703] List of future strategies:
  [22:14:10.703] 1. multicore:
  [22:14:10.703]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.703]    - tweaked: FALSE
  [22:14:10.703]    - call: plan(strategy)
  [22:14:10.705] plan(): nbrOfWorkers() = 2
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:10.714] futureCall() ...
  [22:14:10.715] Finding globals ...
  [22:14:10.715] getGlobalsAndPackages() ...
  [22:14:10.715] Searching for globals...
  [22:14:10.726] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:10.726] Searching for globals ... DONE
  [22:14:10.726] Resolving globals: FALSE
  [22:14:10.728] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:10.729] - globals: [3] 'FUN', 'args', 'a'
  [22:14:10.729] 
  [22:14:10.729] getGlobalsAndPackages() ... DONE
  [22:14:10.730]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:10.730] 
  [22:14:10.730] Finding globals ... DONE
  [22:14:10.731] Globals to be used in the future:
  [22:14:10.731] List of 3
  [22:14:10.731]  $ FUN :function (x, y)  
  [22:14:10.731]  $ args:List of 2
  [22:14:10.731]   ..$ x: num 42
  [22:14:10.731]   ..$ y: num 12
  [22:14:10.731]  $ a   : num 3
  [22:14:10.731]  - attr(*, "where")=List of 3
  [22:14:10.731]   ..$ FUN :<environment: 0xf79650> 
  [22:14:10.731]   ..$ args:<environment: 0x17405a8> 
  [22:14:10.731]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.731]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.731]  - attr(*, "resolved")= logi FALSE
  [22:14:10.731]  - attr(*, "total_size")= num 2592
  [22:14:10.748] getGlobalsAndPackages() ...
  [22:14:10.748] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:10.748] Resolving globals: FALSE
  [22:14:10.750] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.750] - globals: [3] 'FUN', 'args', 'a'
  [22:14:10.750] 
  [22:14:10.751] getGlobalsAndPackages() ... DONE
  [22:14:10.751] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x282cc50>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.754] Packages needed by the future expression (n = 0): <none>
  [22:14:10.755] Packages needed by future strategies (n = 0): <none>
  [22:14:10.760] {
  [22:14:10.760]     {
  [22:14:10.760]         ...future.startTime <- Sys.time()
  [22:14:10.760]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.760]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.760]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.760]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.760]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.760]         {
  [22:14:10.760]             {
  [22:14:10.760]                 {
  [22:14:10.760]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.760]                   version <- if (has_future) 
  [22:14:10.760]                     packageVersion("future")
  [22:14:10.760]                   else NULL
  [22:14:10.760]                   if (!has_future || version < "1.8.0") {
  [22:14:10.760]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.760]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.760]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.760]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.760]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.760]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.760]                     info <- paste(info, collapse = "; ")
  [22:14:10.760]                     if (!has_future) {
  [22:14:10.760]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.760]                         info)
  [22:14:10.760]                     }
  [22:14:10.760]                     else {
  [22:14:10.760]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.760]                         info, version)
  [22:14:10.760]                     }
  [22:14:10.760]                     stop(msg)
  [22:14:10.760]                   }
  [22:14:10.760]                 }
  [22:14:10.760]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.760]                 options(mc.cores = 1L)
  [22:14:10.760]             }
  [22:14:10.760]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.760]         }
  [22:14:10.760]     }
  [22:14:10.760]     if (is.na(TRUE)) {
  [22:14:10.760]     }
  [22:14:10.760]     else {
  [22:14:10.760]         if (TRUE) {
  [22:14:10.760]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.760]         }
  [22:14:10.760]         else {
  [22:14:10.760]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.760]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.760]         }
  [22:14:10.760]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.760]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.760]             sink(type = "output", split = FALSE)
  [22:14:10.760]             close(...future.stdout)
  [22:14:10.760]         }, add = TRUE)
  [22:14:10.760]     }
  [22:14:10.760]     ...future.frame <- sys.nframe()
  [22:14:10.760]     ...future.conditions <- list()
  [22:14:10.760]     ...future.result <- tryCatch({
  [22:14:10.760]         withCallingHandlers({
  [22:14:10.760]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.760]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.760]                 version = "1.8")
  [22:14:10.760]         }, condition = local({
  [22:14:10.760]             inherits <- base::inherits
  [22:14:10.760]             invokeRestart <- base::invokeRestart
  [22:14:10.760]             length <- base::length
  [22:14:10.760]             seq.int <- base::seq.int
  [22:14:10.760]             sys.calls <- base::sys.calls
  [22:14:10.760]             `[[` <- base::`[[`
  [22:14:10.760]             `+` <- base::`+`
  [22:14:10.760]             `<<-` <- base::`<<-`
  [22:14:10.760]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.760]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.760]                   3L)]
  [22:14:10.760]             }
  [22:14:10.760]             function(cond) {
  [22:14:10.760]                 if (inherits(cond, "error")) {
  [22:14:10.760]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.760]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.760]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.760]                     signaled = 0L)
  [22:14:10.760]                   signalCondition(cond)
  [22:14:10.760]                 }
  [22:14:10.760]                 else if (inherits(cond, "condition")) {
  [22:14:10.760]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.760]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.760]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.760]                   if (inherits(cond, "message")) {
  [22:14:10.760]                     if (!signal) 
  [22:14:10.760]                       invokeRestart("muffleMessage")
  [22:14:10.760]                   }
  [22:14:10.760]                   else if (inherits(cond, "warning")) {
  [22:14:10.760]                     if (!signal) 
  [22:14:10.760]                       invokeRestart("muffleWarning")
  [22:14:10.760]                   }
  [22:14:10.760]                   else {
  [22:14:10.760]                     if (!signal) {
  [22:14:10.760]                       restarts <- computeRestarts(cond)
  [22:14:10.760]                       for (restart in restarts) {
  [22:14:10.760]                         name <- restart$name
  [22:14:10.760]                         if (is.null(name)) 
  [22:14:10.760]                           next
  [22:14:10.760]                         if (!grepl("^muffle", name)) 
  [22:14:10.760]                           next
  [22:14:10.760]                         invokeRestart(restart)
  [22:14:10.760]                         break
  [22:14:10.760]                       }
  [22:14:10.760]                     }
  [22:14:10.760]                   }
  [22:14:10.760]                 }
  [22:14:10.760]             }
  [22:14:10.760]         }))
  [22:14:10.760]     }, error = function(ex) {
  [22:14:10.760]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.760]             version = "1.8"), class = "FutureResult")
  [22:14:10.760]     }, finally = {
  [22:14:10.760]         {
  [22:14:10.760]             {
  [22:14:10.760]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.760]             }
  [22:14:10.760]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.760]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.760]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.760]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.760]             {
  [22:14:10.760]                 if (substitute) 
  [22:14:10.760]                   expr <- substitute(expr)
  [22:14:10.760]                 if (is.function(workers)) 
  [22:14:10.760]                   workers <- workers()
  [22:14:10.760]                 workers <- as.integer(workers)
  [22:14:10.760]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.760]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.760]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.760]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.760]                     local = TRUE, label = label, ...))
  [22:14:10.760]                 }
  [22:14:10.760]                 oopts <- options(mc.cores = workers)
  [22:14:10.760]                 on.exit(options(oopts))
  [22:14:10.760]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.760]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.760]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.760]                   label = label, ...)
  [22:14:10.760]                 if (!future$lazy) 
  [22:14:10.760]                   future <- run(future)
  [22:14:10.760]                 invisible(future)
  [22:14:10.760]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.760]         }
  [22:14:10.760]         options(...future.oldOptions)
  [22:14:10.760]     })
  [22:14:10.760]     if (is.na(TRUE)) {
  [22:14:10.760]     }
  [22:14:10.760]     else {
  [22:14:10.760]         sink(type = "output", split = FALSE)
  [22:14:10.760]         if (TRUE) {
  [22:14:10.760]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.760]         }
  [22:14:10.760]         else {
  [22:14:10.760]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.760]         }
  [22:14:10.760]         close(...future.stdout)
  [22:14:10.760]         ...future.stdout <- NULL
  [22:14:10.760]     }
  [22:14:10.760]     ...future.result$conditions <- ...future.conditions
  [22:14:10.760]     ...future.result
  [22:14:10.760] }
  [22:14:10.763] requestCore(): workers = 2
  [22:14:10.766] MulticoreFuture started
  [22:14:10.773] plan(): Setting new future strategy stack:
  [22:14:10.773] List of future strategies:
  [22:14:10.773] 1. sequential:
  [22:14:10.773]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.773]    - tweaked: FALSE
  [22:14:10.773]    - call: NULL
  [22:14:10.775] plan(): nbrOfWorkers() = 1
  [22:14:10.776] plan(): Setting new future strategy stack:
  [22:14:10.777] List of future strategies:
  [22:14:10.777] 1. multicore:
  [22:14:10.777]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.777]    - tweaked: FALSE
  [22:14:10.777]    - call: plan(strategy)
  [22:14:10.779] plan(): nbrOfWorkers() = 2
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:10.786] futureCall() ...
  [22:14:10.787] Globals to be used in the future:
  [22:14:10.787] List of 3
  [22:14:10.787]  $ a   : num 3
  [22:14:10.787]  $ FUN :function (x, y)  
  [22:14:10.787]  $ args:List of 2
  [22:14:10.787]   ..$ x: num 42
  [22:14:10.787]   ..$ y: num 12
  [22:14:10.787]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.787]  - attr(*, "where")=List of 3
  [22:14:10.787]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:10.787]   ..$ FUN :<environment: 0x2ca3f78> 
  [22:14:10.787]   ..$ args:<environment: 0x2c84bd8> 
  [22:14:10.787]  - attr(*, "resolved")= logi FALSE
  [22:14:10.787]  - attr(*, "total_size")= num NA
  [22:14:10.811] getGlobalsAndPackages() ...
  [22:14:10.812] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.812] Resolving globals: FALSE
  [22:14:10.814] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.814] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.814] 
  [22:14:10.815] getGlobalsAndPackages() ... DONE
  [22:14:10.815] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x324f1d0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.819] Packages needed by the future expression (n = 0): <none>
  [22:14:10.819] Packages needed by future strategies (n = 0): <none>
  [22:14:10.824] {
  [22:14:10.824]     {
  [22:14:10.824]         ...future.startTime <- Sys.time()
  [22:14:10.824]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.824]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.824]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.824]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.824]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.824]         {
  [22:14:10.824]             {
  [22:14:10.824]                 {
  [22:14:10.824]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.824]                   version <- if (has_future) 
  [22:14:10.824]                     packageVersion("future")
  [22:14:10.824]                   else NULL
  [22:14:10.824]                   if (!has_future || version < "1.8.0") {
  [22:14:10.824]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.824]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.824]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.824]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.824]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.824]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.824]                     info <- paste(info, collapse = "; ")
  [22:14:10.824]                     if (!has_future) {
  [22:14:10.824]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.824]                         info)
  [22:14:10.824]                     }
  [22:14:10.824]                     else {
  [22:14:10.824]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.824]                         info, version)
  [22:14:10.824]                     }
  [22:14:10.824]                     stop(msg)
  [22:14:10.824]                   }
  [22:14:10.824]                 }
  [22:14:10.824]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.824]                 options(mc.cores = 1L)
  [22:14:10.824]             }
  [22:14:10.824]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.824]         }
  [22:14:10.824]     }
  [22:14:10.824]     if (is.na(TRUE)) {
  [22:14:10.824]     }
  [22:14:10.824]     else {
  [22:14:10.824]         if (TRUE) {
  [22:14:10.824]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.824]         }
  [22:14:10.824]         else {
  [22:14:10.824]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.824]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.824]         }
  [22:14:10.824]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.824]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.824]             sink(type = "output", split = FALSE)
  [22:14:10.824]             close(...future.stdout)
  [22:14:10.824]         }, add = TRUE)
  [22:14:10.824]     }
  [22:14:10.824]     ...future.frame <- sys.nframe()
  [22:14:10.824]     ...future.conditions <- list()
  [22:14:10.824]     ...future.result <- tryCatch({
  [22:14:10.824]         withCallingHandlers({
  [22:14:10.824]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.824]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.824]                 version = "1.8")
  [22:14:10.824]         }, condition = local({
  [22:14:10.824]             inherits <- base::inherits
  [22:14:10.824]             invokeRestart <- base::invokeRestart
  [22:14:10.824]             length <- base::length
  [22:14:10.824]             seq.int <- base::seq.int
  [22:14:10.824]             sys.calls <- base::sys.calls
  [22:14:10.824]             `[[` <- base::`[[`
  [22:14:10.824]             `+` <- base::`+`
  [22:14:10.824]             `<<-` <- base::`<<-`
  [22:14:10.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.824]                   3L)]
  [22:14:10.824]             }
  [22:14:10.824]             function(cond) {
  [22:14:10.824]                 if (inherits(cond, "error")) {
  [22:14:10.824]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.824]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.824]                     signaled = 0L)
  [22:14:10.824]                   signalCondition(cond)
  [22:14:10.824]                 }
  [22:14:10.824]                 else if (inherits(cond, "condition")) {
  [22:14:10.824]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.824]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.824]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.824]                   if (inherits(cond, "message")) {
  [22:14:10.824]                     if (!signal) 
  [22:14:10.824]                       invokeRestart("muffleMessage")
  [22:14:10.824]                   }
  [22:14:10.824]                   else if (inherits(cond, "warning")) {
  [22:14:10.824]                     if (!signal) 
  [22:14:10.824]                       invokeRestart("muffleWarning")
  [22:14:10.824]                   }
  [22:14:10.824]                   else {
  [22:14:10.824]                     if (!signal) {
  [22:14:10.824]                       restarts <- computeRestarts(cond)
  [22:14:10.824]                       for (restart in restarts) {
  [22:14:10.824]                         name <- restart$name
  [22:14:10.824]                         if (is.null(name)) 
  [22:14:10.824]                           next
  [22:14:10.824]                         if (!grepl("^muffle", name)) 
  [22:14:10.824]                           next
  [22:14:10.824]                         invokeRestart(restart)
  [22:14:10.824]                         break
  [22:14:10.824]                       }
  [22:14:10.824]                     }
  [22:14:10.824]                   }
  [22:14:10.824]                 }
  [22:14:10.824]             }
  [22:14:10.824]         }))
  [22:14:10.824]     }, error = function(ex) {
  [22:14:10.824]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.824]             version = "1.8"), class = "FutureResult")
  [22:14:10.824]     }, finally = {
  [22:14:10.824]         {
  [22:14:10.824]             {
  [22:14:10.824]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.824]             }
  [22:14:10.824]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.824]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.824]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.824]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.824]             {
  [22:14:10.824]                 if (substitute) 
  [22:14:10.824]                   expr <- substitute(expr)
  [22:14:10.824]                 if (is.function(workers)) 
  [22:14:10.824]                   workers <- workers()
  [22:14:10.824]                 workers <- as.integer(workers)
  [22:14:10.824]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.824]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.824]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.824]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.824]                     local = TRUE, label = label, ...))
  [22:14:10.824]                 }
  [22:14:10.824]                 oopts <- options(mc.cores = workers)
  [22:14:10.824]                 on.exit(options(oopts))
  [22:14:10.824]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.824]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.824]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.824]                   label = label, ...)
  [22:14:10.824]                 if (!future$lazy) 
  [22:14:10.824]                   future <- run(future)
  [22:14:10.824]                 invisible(future)
  [22:14:10.824]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.824]         }
  [22:14:10.824]         options(...future.oldOptions)
  [22:14:10.824]     })
  [22:14:10.824]     if (is.na(TRUE)) {
  [22:14:10.824]     }
  [22:14:10.824]     else {
  [22:14:10.824]         sink(type = "output", split = FALSE)
  [22:14:10.824]         if (TRUE) {
  [22:14:10.824]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.824]         }
  [22:14:10.824]         else {
  [22:14:10.824]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.824]         }
  [22:14:10.824]         close(...future.stdout)
  [22:14:10.824]         ...future.stdout <- NULL
  [22:14:10.824]     }
  [22:14:10.824]     ...future.result$conditions <- ...future.conditions
  [22:14:10.824]     ...future.result
  [22:14:10.824] }
  [22:14:10.827] requestCore(): workers = 2
  [22:14:10.830] MulticoreFuture started
  [22:14:10.846] plan(): Setting new future strategy stack:
  [22:14:10.847] List of future strategies:
  [22:14:10.847] 1. sequential:
  [22:14:10.847]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.847]    - tweaked: FALSE
  [22:14:10.847]    - call: NULL
  [22:14:10.849] plan(): nbrOfWorkers() = 1
  [22:14:10.850] plan(): Setting new future strategy stack:
  [22:14:10.851] List of future strategies:
  [22:14:10.851] 1. multicore:
  [22:14:10.851]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.851]    - tweaked: FALSE
  [22:14:10.851]    - call: plan(strategy)
  [22:14:10.856] plan(): nbrOfWorkers() = 2
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:10.863] futureCall() ...
  [22:14:10.864] Globals to be used in the future:
  [22:14:10.865] List of 3
  [22:14:10.865]  $ a   : num 3
  [22:14:10.865]  $ FUN :function (x, y)  
  [22:14:10.865]  $ args:List of 2
  [22:14:10.865]   ..$ x: num 42
  [22:14:10.865]   ..$ y: num 12
  [22:14:10.865]  - attr(*, "where")=List of 3
  [22:14:10.865]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:10.865]   ..$ FUN :<environment: 0x12f6d50> 
  [22:14:10.865]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:10.865]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:10.865]  - attr(*, "resolved")= logi FALSE
  [22:14:10.865]  - attr(*, "total_size")= num NA
  [22:14:10.885] getGlobalsAndPackages() ...
  [22:14:10.886] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:10.886] Resolving globals: FALSE
  [22:14:10.887] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:10.888] - globals: [3] 'a', 'FUN', 'args'
  [22:14:10.888] 
  [22:14:10.889] getGlobalsAndPackages() ... DONE
  [22:14:10.889] futureCall() ... DONE
  MulticoreFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2980b70>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:10.892] Packages needed by the future expression (n = 0): <none>
  [22:14:10.893] Packages needed by future strategies (n = 0): <none>
  [22:14:10.897] {
  [22:14:10.897]     {
  [22:14:10.897]         ...future.startTime <- Sys.time()
  [22:14:10.897]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:10.897]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:10.897]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:10.897]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:10.897]             future.resolve.recursive = NULL, width = 80L)
  [22:14:10.897]         {
  [22:14:10.897]             {
  [22:14:10.897]                 {
  [22:14:10.897]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:10.897]                   version <- if (has_future) 
  [22:14:10.897]                     packageVersion("future")
  [22:14:10.897]                   else NULL
  [22:14:10.897]                   if (!has_future || version < "1.8.0") {
  [22:14:10.897]                     info <- c(r_version = gsub("R version ", 
  [22:14:10.897]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:10.897]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:10.897]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:10.897]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:10.897]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:10.897]                     info <- paste(info, collapse = "; ")
  [22:14:10.897]                     if (!has_future) {
  [22:14:10.897]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:10.897]                         info)
  [22:14:10.897]                     }
  [22:14:10.897]                     else {
  [22:14:10.897]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:10.897]                         info, version)
  [22:14:10.897]                     }
  [22:14:10.897]                     stop(msg)
  [22:14:10.897]                   }
  [22:14:10.897]                 }
  [22:14:10.897]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:10.897]                 options(mc.cores = 1L)
  [22:14:10.897]             }
  [22:14:10.897]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:10.897]         }
  [22:14:10.897]     }
  [22:14:10.897]     if (is.na(TRUE)) {
  [22:14:10.897]     }
  [22:14:10.897]     else {
  [22:14:10.897]         if (TRUE) {
  [22:14:10.897]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:10.897]         }
  [22:14:10.897]         else {
  [22:14:10.897]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:10.897]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:10.897]         }
  [22:14:10.897]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:10.897]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:10.897]             sink(type = "output", split = FALSE)
  [22:14:10.897]             close(...future.stdout)
  [22:14:10.897]         }, add = TRUE)
  [22:14:10.897]     }
  [22:14:10.897]     ...future.frame <- sys.nframe()
  [22:14:10.897]     ...future.conditions <- list()
  [22:14:10.897]     ...future.result <- tryCatch({
  [22:14:10.897]         withCallingHandlers({
  [22:14:10.897]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:10.897]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:10.897]                 version = "1.8")
  [22:14:10.897]         }, condition = local({
  [22:14:10.897]             inherits <- base::inherits
  [22:14:10.897]             invokeRestart <- base::invokeRestart
  [22:14:10.897]             length <- base::length
  [22:14:10.897]             seq.int <- base::seq.int
  [22:14:10.897]             sys.calls <- base::sys.calls
  [22:14:10.897]             `[[` <- base::`[[`
  [22:14:10.897]             `+` <- base::`+`
  [22:14:10.897]             `<<-` <- base::`<<-`
  [22:14:10.897]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:10.897]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:10.897]                   3L)]
  [22:14:10.897]             }
  [22:14:10.897]             function(cond) {
  [22:14:10.897]                 if (inherits(cond, "error")) {
  [22:14:10.897]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.897]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:10.897]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:10.897]                     signaled = 0L)
  [22:14:10.897]                   signalCondition(cond)
  [22:14:10.897]                 }
  [22:14:10.897]                 else if (inherits(cond, "condition")) {
  [22:14:10.897]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:10.897]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:10.897]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:10.897]                   if (inherits(cond, "message")) {
  [22:14:10.897]                     if (!signal) 
  [22:14:10.897]                       invokeRestart("muffleMessage")
  [22:14:10.897]                   }
  [22:14:10.897]                   else if (inherits(cond, "warning")) {
  [22:14:10.897]                     if (!signal) 
  [22:14:10.897]                       invokeRestart("muffleWarning")
  [22:14:10.897]                   }
  [22:14:10.897]                   else {
  [22:14:10.897]                     if (!signal) {
  [22:14:10.897]                       restarts <- computeRestarts(cond)
  [22:14:10.897]                       for (restart in restarts) {
  [22:14:10.897]                         name <- restart$name
  [22:14:10.897]                         if (is.null(name)) 
  [22:14:10.897]                           next
  [22:14:10.897]                         if (!grepl("^muffle", name)) 
  [22:14:10.897]                           next
  [22:14:10.897]                         invokeRestart(restart)
  [22:14:10.897]                         break
  [22:14:10.897]                       }
  [22:14:10.897]                     }
  [22:14:10.897]                   }
  [22:14:10.897]                 }
  [22:14:10.897]             }
  [22:14:10.897]         }))
  [22:14:10.897]     }, error = function(ex) {
  [22:14:10.897]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:10.897]             version = "1.8"), class = "FutureResult")
  [22:14:10.897]     }, finally = {
  [22:14:10.897]         {
  [22:14:10.897]             {
  [22:14:10.897]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:10.897]             }
  [22:14:10.897]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:10.897]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:10.897]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:14:10.897]                 earlySignal = FALSE, label = NULL, ...) 
  [22:14:10.897]             {
  [22:14:10.897]                 if (substitute) 
  [22:14:10.897]                   expr <- substitute(expr)
  [22:14:10.897]                 if (is.function(workers)) 
  [22:14:10.897]                   workers <- workers()
  [22:14:10.897]                 workers <- as.integer(workers)
  [22:14:10.897]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:14:10.897]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:14:10.897]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:10.897]                     lazy = lazy, seed = seed, globals = globals, 
  [22:14:10.897]                     local = TRUE, label = label, ...))
  [22:14:10.897]                 }
  [22:14:10.897]                 oopts <- options(mc.cores = workers)
  [22:14:10.897]                 on.exit(options(oopts))
  [22:14:10.897]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:14:10.897]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:10.897]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:14:10.897]                   label = label, ...)
  [22:14:10.897]                 if (!future$lazy) 
  [22:14:10.897]                   future <- run(future)
  [22:14:10.897]                 invisible(future)
  [22:14:10.897]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:10.897]         }
  [22:14:10.897]         options(...future.oldOptions)
  [22:14:10.897]     })
  [22:14:10.897]     if (is.na(TRUE)) {
  [22:14:10.897]     }
  [22:14:10.897]     else {
  [22:14:10.897]         sink(type = "output", split = FALSE)
  [22:14:10.897]         if (TRUE) {
  [22:14:10.897]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:10.897]         }
  [22:14:10.897]         else {
  [22:14:10.897]             ...future.result["stdout"] <- list(NULL)
  [22:14:10.897]         }
  [22:14:10.897]         close(...future.stdout)
  [22:14:10.897]         ...future.stdout <- NULL
  [22:14:10.897]     }
  [22:14:10.897]     ...future.result$conditions <- ...future.conditions
  [22:14:10.897]     ...future.result
  [22:14:10.897] }
  [22:14:10.900] requestCore(): workers = 2
  [22:14:10.904] MulticoreFuture started
  [22:14:10.930] plan(): Setting new future strategy stack:
  [22:14:10.931] List of future strategies:
  [22:14:10.931] 1. sequential:
  [22:14:10.931]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.931]    - tweaked: FALSE
  [22:14:10.931]    - call: NULL
  [22:14:10.933] plan(): nbrOfWorkers() = 1
  [22:14:10.934] plan(): Setting new future strategy stack:
  [22:14:10.934] List of future strategies:
  [22:14:10.934] 1. multicore:
  [22:14:10.934]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:14:10.934]    - tweaked: FALSE
  [22:14:10.934]    - call: plan(strategy)
  [22:14:10.937] plan(): nbrOfWorkers() = 2
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  - plan('multisession') ...
  [22:14:10.944] plan(): Setting new future strategy stack:
  [22:14:10.945] List of future strategies:
  [22:14:10.945] 1. multisession:
  [22:14:10.945]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.945]    - tweaked: FALSE
  [22:14:10.945]    - call: plan(strategy)
  [22:14:10.946] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [22:14:10.947] multisession:
  [22:14:10.947] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:10.947] - tweaked: FALSE
  [22:14:10.947] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11663
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c8941b6b694.pid"), silent = TRUE)' -e "file.exists('/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c8941b6b694.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureCall.R:gimli:hornik:23689' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c8941b6b694.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11663 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c895d8d7daf.pid"), silent = TRUE)' -e "file.exists('/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c895d8d7daf.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureCall.R:gimli:hornik:23689' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c895d8d7daf.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11663 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
  [22:14:26.070] getGlobalsAndPackages() ...
  [22:14:26.071] Not searching for globals
  [22:14:26.079] - globals: [0] <none>
  [22:14:26.079] getGlobalsAndPackages() ... DONE
  [22:14:26.082] Packages needed by the future expression (n = 0): <none>
  [22:14:26.082] Packages needed by future strategies (n = 0): <none>
  [22:14:26.087] {
  [22:14:26.087]     {
  [22:14:26.087]         ...future.startTime <- Sys.time()
  [22:14:26.087]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.087]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.087]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.087]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.087]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.087]         {
  [22:14:26.087]             {
  [22:14:26.087]                 {
  [22:14:26.087]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.087]                   version <- if (has_future) 
  [22:14:26.087]                     packageVersion("future")
  [22:14:26.087]                   else NULL
  [22:14:26.087]                   if (!has_future || version < "1.8.0") {
  [22:14:26.087]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.087]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.087]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.087]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.087]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.087]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.087]                     info <- paste(info, collapse = "; ")
  [22:14:26.087]                     if (!has_future) {
  [22:14:26.087]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.087]                         info)
  [22:14:26.087]                     }
  [22:14:26.087]                     else {
  [22:14:26.087]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.087]                         info, version)
  [22:14:26.087]                     }
  [22:14:26.087]                     stop(msg)
  [22:14:26.087]                   }
  [22:14:26.087]                 }
  [22:14:26.087]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.087]                 options(mc.cores = 1L)
  [22:14:26.087]             }
  [22:14:26.087]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.087]         }
  [22:14:26.087]     }
  [22:14:26.087]     if (is.na(TRUE)) {
  [22:14:26.087]     }
  [22:14:26.087]     else {
  [22:14:26.087]         if (TRUE) {
  [22:14:26.087]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.087]         }
  [22:14:26.087]         else {
  [22:14:26.087]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.087]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.087]         }
  [22:14:26.087]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.087]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.087]             sink(type = "output", split = FALSE)
  [22:14:26.087]             close(...future.stdout)
  [22:14:26.087]         }, add = TRUE)
  [22:14:26.087]     }
  [22:14:26.087]     ...future.frame <- sys.nframe()
  [22:14:26.087]     ...future.conditions <- list()
  [22:14:26.087]     ...future.result <- tryCatch({
  [22:14:26.087]         withCallingHandlers({
  [22:14:26.087]             ...future.value <- local(NA)
  [22:14:26.087]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.087]                 version = "1.8")
  [22:14:26.087]         }, condition = local({
  [22:14:26.087]             inherits <- base::inherits
  [22:14:26.087]             invokeRestart <- base::invokeRestart
  [22:14:26.087]             length <- base::length
  [22:14:26.087]             seq.int <- base::seq.int
  [22:14:26.087]             sys.calls <- base::sys.calls
  [22:14:26.087]             `[[` <- base::`[[`
  [22:14:26.087]             `+` <- base::`+`
  [22:14:26.087]             `<<-` <- base::`<<-`
  [22:14:26.087]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.087]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.087]                   3L)]
  [22:14:26.087]             }
  [22:14:26.087]             function(cond) {
  [22:14:26.087]                 if (inherits(cond, "error")) {
  [22:14:26.087]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.087]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.087]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.087]                     signaled = 0L)
  [22:14:26.087]                   signalCondition(cond)
  [22:14:26.087]                 }
  [22:14:26.087]                 else if (inherits(cond, "condition")) {
  [22:14:26.087]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.087]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.087]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.087]                   if (inherits(cond, "message")) {
  [22:14:26.087]                     if (!signal) 
  [22:14:26.087]                       invokeRestart("muffleMessage")
  [22:14:26.087]                   }
  [22:14:26.087]                   else if (inherits(cond, "warning")) {
  [22:14:26.087]                     if (!signal) 
  [22:14:26.087]                       invokeRestart("muffleWarning")
  [22:14:26.087]                   }
  [22:14:26.087]                   else {
  [22:14:26.087]                     if (!signal) {
  [22:14:26.087]                       restarts <- computeRestarts(cond)
  [22:14:26.087]                       for (restart in restarts) {
  [22:14:26.087]                         name <- restart$name
  [22:14:26.087]                         if (is.null(name)) 
  [22:14:26.087]                           next
  [22:14:26.087]                         if (!grepl("^muffle", name)) 
  [22:14:26.087]                           next
  [22:14:26.087]                         invokeRestart(restart)
  [22:14:26.087]                         break
  [22:14:26.087]                       }
  [22:14:26.087]                     }
  [22:14:26.087]                   }
  [22:14:26.087]                 }
  [22:14:26.087]             }
  [22:14:26.087]         }))
  [22:14:26.087]     }, error = function(ex) {
  [22:14:26.087]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.087]             version = "1.8"), class = "FutureResult")
  [22:14:26.087]     }, finally = {
  [22:14:26.087]         {
  [22:14:26.087]             {
  [22:14:26.087]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.087]             }
  [22:14:26.087]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.087]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.087]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.087]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.087]                 ...) 
  [22:14:26.087]             {
  [22:14:26.087]                 if (substitute) 
  [22:14:26.087]                   expr <- substitute(expr)
  [22:14:26.087]                 if (is.function(workers)) 
  [22:14:26.087]                   workers <- workers()
  [22:14:26.087]                 workers <- as.integer(workers)
  [22:14:26.087]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.087]                   workers >= 1)
  [22:14:26.087]                 if (workers == 1L) {
  [22:14:26.087]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.087]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.087]                     local = TRUE, label = label, ...))
  [22:14:26.087]                 }
  [22:14:26.087]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.087]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.087]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.087]                   globals = globals, persistent = persistent, 
  [22:14:26.087]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.087]                   label = label, ...)
  [22:14:26.087]                 if (!future$lazy) 
  [22:14:26.087]                   future <- run(future)
  [22:14:26.087]                 invisible(future)
  [22:14:26.087]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.087]         }
  [22:14:26.087]         options(...future.oldOptions)
  [22:14:26.087]     })
  [22:14:26.087]     if (is.na(TRUE)) {
  [22:14:26.087]     }
  [22:14:26.087]     else {
  [22:14:26.087]         sink(type = "output", split = FALSE)
  [22:14:26.087]         if (TRUE) {
  [22:14:26.087]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.087]         }
  [22:14:26.087]         else {
  [22:14:26.087]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.087]         }
  [22:14:26.087]         close(...future.stdout)
  [22:14:26.087]         ...future.stdout <- NULL
  [22:14:26.087]     }
  [22:14:26.087]     ...future.result$conditions <- ...future.conditions
  [22:14:26.087]     ...future.result
  [22:14:26.087] }
  [22:14:26.091] MultisessionFuture started
  [22:14:26.092] result() for ClusterFuture ...
  [22:14:26.093] - Validating connection of MultisessionFuture
  [22:14:26.309] - class(result): FutureResult
  [22:14:26.310] result() for ClusterFuture ...
  [22:14:26.310] - result already collected: FutureResult
  [22:14:26.311] result() for ClusterFuture ... done
  [22:14:26.311] result() for ClusterFuture ... done
  [22:14:26.312] result() for ClusterFuture ...
  [22:14:26.312] - result already collected: FutureResult
  [22:14:26.312] result() for ClusterFuture ... done
  [22:14:26.313] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [22:14:26.314] plan(): nbrOfWorkers() = 2
  [22:14:26.314] futureCall() ...
  [22:14:26.315] Globals to be used in the future:
  [22:14:26.315] List of 2
  [22:14:26.315]  $ FUN :function (x, y)  
  [22:14:26.315]  $ args:List of 2
  [22:14:26.315]   ..$ x: num 42
  [22:14:26.315]   ..$ y: num 12
  [22:14:26.315]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.315]  - attr(*, "where")=List of 2
  [22:14:26.315]   ..$ FUN :<environment: 0xc21770> 
  [22:14:26.315]   ..$ args:<environment: 0xc21770> 
  [22:14:26.315]  - attr(*, "resolved")= logi FALSE
  [22:14:26.315]  - attr(*, "total_size")= num NA
  [22:14:26.353] getGlobalsAndPackages() ...
  [22:14:26.353] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:26.354] Resolving globals: FALSE
  [22:14:26.355] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:26.355] - globals: [2] 'FUN', 'args'
  [22:14:26.355] 
  [22:14:26.356] getGlobalsAndPackages() ... DONE
  [22:14:26.358] Packages needed by the future expression (n = 0): <none>
  [22:14:26.358] Packages needed by future strategies (n = 0): <none>
  [22:14:26.364] {
  [22:14:26.364]     {
  [22:14:26.364]         ...future.startTime <- Sys.time()
  [22:14:26.364]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.364]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.364]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.364]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.364]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.364]         {
  [22:14:26.364]             {
  [22:14:26.364]                 {
  [22:14:26.364]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.364]                   version <- if (has_future) 
  [22:14:26.364]                     packageVersion("future")
  [22:14:26.364]                   else NULL
  [22:14:26.364]                   if (!has_future || version < "1.8.0") {
  [22:14:26.364]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.364]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.364]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.364]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.364]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.364]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.364]                     info <- paste(info, collapse = "; ")
  [22:14:26.364]                     if (!has_future) {
  [22:14:26.364]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.364]                         info)
  [22:14:26.364]                     }
  [22:14:26.364]                     else {
  [22:14:26.364]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.364]                         info, version)
  [22:14:26.364]                     }
  [22:14:26.364]                     stop(msg)
  [22:14:26.364]                   }
  [22:14:26.364]                 }
  [22:14:26.364]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.364]                 options(mc.cores = 1L)
  [22:14:26.364]             }
  [22:14:26.364]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.364]         }
  [22:14:26.364]     }
  [22:14:26.364]     if (is.na(TRUE)) {
  [22:14:26.364]     }
  [22:14:26.364]     else {
  [22:14:26.364]         if (TRUE) {
  [22:14:26.364]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.364]         }
  [22:14:26.364]         else {
  [22:14:26.364]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.364]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.364]         }
  [22:14:26.364]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.364]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.364]             sink(type = "output", split = FALSE)
  [22:14:26.364]             close(...future.stdout)
  [22:14:26.364]         }, add = TRUE)
  [22:14:26.364]     }
  [22:14:26.364]     ...future.frame <- sys.nframe()
  [22:14:26.364]     ...future.conditions <- list()
  [22:14:26.364]     ...future.result <- tryCatch({
  [22:14:26.364]         withCallingHandlers({
  [22:14:26.364]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.364]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.364]                 version = "1.8")
  [22:14:26.364]         }, condition = local({
  [22:14:26.364]             inherits <- base::inherits
  [22:14:26.364]             invokeRestart <- base::invokeRestart
  [22:14:26.364]             length <- base::length
  [22:14:26.364]             seq.int <- base::seq.int
  [22:14:26.364]             sys.calls <- base::sys.calls
  [22:14:26.364]             `[[` <- base::`[[`
  [22:14:26.364]             `+` <- base::`+`
  [22:14:26.364]             `<<-` <- base::`<<-`
  [22:14:26.364]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.364]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.364]                   3L)]
  [22:14:26.364]             }
  [22:14:26.364]             function(cond) {
  [22:14:26.364]                 if (inherits(cond, "error")) {
  [22:14:26.364]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.364]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.364]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.364]                     signaled = 0L)
  [22:14:26.364]                   signalCondition(cond)
  [22:14:26.364]                 }
  [22:14:26.364]                 else if (inherits(cond, "condition")) {
  [22:14:26.364]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.364]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.364]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.364]                   if (inherits(cond, "message")) {
  [22:14:26.364]                     if (!signal) 
  [22:14:26.364]                       invokeRestart("muffleMessage")
  [22:14:26.364]                   }
  [22:14:26.364]                   else if (inherits(cond, "warning")) {
  [22:14:26.364]                     if (!signal) 
  [22:14:26.364]                       invokeRestart("muffleWarning")
  [22:14:26.364]                   }
  [22:14:26.364]                   else {
  [22:14:26.364]                     if (!signal) {
  [22:14:26.364]                       restarts <- computeRestarts(cond)
  [22:14:26.364]                       for (restart in restarts) {
  [22:14:26.364]                         name <- restart$name
  [22:14:26.364]                         if (is.null(name)) 
  [22:14:26.364]                           next
  [22:14:26.364]                         if (!grepl("^muffle", name)) 
  [22:14:26.364]                           next
  [22:14:26.364]                         invokeRestart(restart)
  [22:14:26.364]                         break
  [22:14:26.364]                       }
  [22:14:26.364]                     }
  [22:14:26.364]                   }
  [22:14:26.364]                 }
  [22:14:26.364]             }
  [22:14:26.364]         }))
  [22:14:26.364]     }, error = function(ex) {
  [22:14:26.364]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.364]             version = "1.8"), class = "FutureResult")
  [22:14:26.364]     }, finally = {
  [22:14:26.364]         {
  [22:14:26.364]             {
  [22:14:26.364]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.364]             }
  [22:14:26.364]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.364]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.364]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.364]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.364]                 ...) 
  [22:14:26.364]             {
  [22:14:26.364]                 if (substitute) 
  [22:14:26.364]                   expr <- substitute(expr)
  [22:14:26.364]                 if (is.function(workers)) 
  [22:14:26.364]                   workers <- workers()
  [22:14:26.364]                 workers <- as.integer(workers)
  [22:14:26.364]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.364]                   workers >= 1)
  [22:14:26.364]                 if (workers == 1L) {
  [22:14:26.364]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.364]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.364]                     local = TRUE, label = label, ...))
  [22:14:26.364]                 }
  [22:14:26.364]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.364]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.364]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.364]                   globals = globals, persistent = persistent, 
  [22:14:26.364]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.364]                   label = label, ...)
  [22:14:26.364]                 if (!future$lazy) 
  [22:14:26.364]                   future <- run(future)
  [22:14:26.364]                 invisible(future)
  [22:14:26.364]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.364]         }
  [22:14:26.364]         options(...future.oldOptions)
  [22:14:26.364]     })
  [22:14:26.364]     if (is.na(TRUE)) {
  [22:14:26.364]     }
  [22:14:26.364]     else {
  [22:14:26.364]         sink(type = "output", split = FALSE)
  [22:14:26.364]         if (TRUE) {
  [22:14:26.364]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.364]         }
  [22:14:26.364]         else {
  [22:14:26.364]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.364]         }
  [22:14:26.364]         close(...future.stdout)
  [22:14:26.364]         ...future.stdout <- NULL
  [22:14:26.364]     }
  [22:14:26.364]     ...future.result$conditions <- ...future.conditions
  [22:14:26.364]     ...future.result
  [22:14:26.364] }
  [22:14:26.367] Exporting 2 global objects (2.48 KiB) to cluster node #1 ...
  [22:14:26.368] Exporting 'FUN' (2.37 KiB) to cluster node #1 ...
  [22:14:26.369] Exporting 'FUN' (2.37 KiB) to cluster node #1 ... DONE
  [22:14:26.369] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.370] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.371] Exporting 2 global objects (2.48 KiB) to cluster node #1 ... DONE
  [22:14:26.372] MultisessionFuture started
  [22:14:26.372] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0xc21770>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:26.421] result() for ClusterFuture ...
  [22:14:26.422] - Validating connection of MultisessionFuture
  [22:14:26.422] - class(result): FutureResult
  [22:14:26.423] result() for ClusterFuture ...
  [22:14:26.424] - result already collected: FutureResult
  [22:14:26.424] result() for ClusterFuture ... done
  [22:14:26.424] signalConditions() ...
  [22:14:26.425]  - include = 'immediateCondition'
  [22:14:26.425]  - exclude = 
  [22:14:26.425]  - resignal = FALSE
  [22:14:26.426]  - Number of conditions: 1
  [22:14:26.426] signalConditions() ... done
  [22:14:26.427] result() for ClusterFuture ... done
  [22:14:26.427] result() for ClusterFuture ...
  [22:14:26.427] - result already collected: FutureResult
  [22:14:26.428] result() for ClusterFuture ... done
  [22:14:26.428] signalConditions() ...
  [22:14:26.428]  - include = 'immediateCondition'
  [22:14:26.429]  - exclude = 
  [22:14:26.429]  - resignal = FALSE
  [22:14:26.429]  - Number of conditions: 1
  [22:14:26.430] signalConditions() ... done
  [22:14:26.430] Future state: 'finished'
  [22:14:26.431] result() for ClusterFuture ...
  [22:14:26.431] - result already collected: FutureResult
  [22:14:26.431] result() for ClusterFuture ... done
  [22:14:26.432] signalConditions() ...
  [22:14:26.432]  - include = 'condition'
  [22:14:26.444]  - exclude = 'immediateCondition'
  [22:14:26.444]  - resignal = TRUE
  [22:14:26.445]  - Number of conditions: 1
  [22:14:26.445]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:26.446] signalConditions() ... done
  [22:14:26.446] futureCall() ...
  [22:14:26.448] Globals to be used in the future:
  [22:14:26.448] List of 3
  [22:14:26.448]  $ a   : num 3
  [22:14:26.448]  $ FUN :function (x, y)  
  [22:14:26.448]  $ args:List of 2
  [22:14:26.448]   ..$ x: num 42
  [22:14:26.448]   ..$ y: num 12
  [22:14:26.448]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.448]  - attr(*, "where")=List of 3
  [22:14:26.448]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:26.448]   ..$ FUN :<environment: 0x2a9dac0> 
  [22:14:26.448]   ..$ args:<environment: 0x2f78d00> 
  [22:14:26.448]  - attr(*, "resolved")= logi FALSE
  [22:14:26.448]  - attr(*, "total_size")= num NA
  [22:14:26.471] getGlobalsAndPackages() ...
  [22:14:26.472] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:26.472] Resolving globals: FALSE
  [22:14:26.473] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:26.474] - globals: [3] 'a', 'FUN', 'args'
  [22:14:26.474] 
  [22:14:26.491] getGlobalsAndPackages() ... DONE
  [22:14:26.493] Packages needed by the future expression (n = 0): <none>
  [22:14:26.494] Packages needed by future strategies (n = 0): <none>
  [22:14:26.500] {
  [22:14:26.500]     {
  [22:14:26.500]         ...future.startTime <- Sys.time()
  [22:14:26.500]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.500]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.500]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.500]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.500]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.500]         {
  [22:14:26.500]             {
  [22:14:26.500]                 {
  [22:14:26.500]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.500]                   version <- if (has_future) 
  [22:14:26.500]                     packageVersion("future")
  [22:14:26.500]                   else NULL
  [22:14:26.500]                   if (!has_future || version < "1.8.0") {
  [22:14:26.500]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.500]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.500]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.500]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.500]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.500]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.500]                     info <- paste(info, collapse = "; ")
  [22:14:26.500]                     if (!has_future) {
  [22:14:26.500]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.500]                         info)
  [22:14:26.500]                     }
  [22:14:26.500]                     else {
  [22:14:26.500]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.500]                         info, version)
  [22:14:26.500]                     }
  [22:14:26.500]                     stop(msg)
  [22:14:26.500]                   }
  [22:14:26.500]                 }
  [22:14:26.500]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.500]                 options(mc.cores = 1L)
  [22:14:26.500]             }
  [22:14:26.500]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.500]         }
  [22:14:26.500]     }
  [22:14:26.500]     if (is.na(TRUE)) {
  [22:14:26.500]     }
  [22:14:26.500]     else {
  [22:14:26.500]         if (TRUE) {
  [22:14:26.500]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.500]         }
  [22:14:26.500]         else {
  [22:14:26.500]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.500]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.500]         }
  [22:14:26.500]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.500]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.500]             sink(type = "output", split = FALSE)
  [22:14:26.500]             close(...future.stdout)
  [22:14:26.500]         }, add = TRUE)
  [22:14:26.500]     }
  [22:14:26.500]     ...future.frame <- sys.nframe()
  [22:14:26.500]     ...future.conditions <- list()
  [22:14:26.500]     ...future.result <- tryCatch({
  [22:14:26.500]         withCallingHandlers({
  [22:14:26.500]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.500]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.500]                 version = "1.8")
  [22:14:26.500]         }, condition = local({
  [22:14:26.500]             inherits <- base::inherits
  [22:14:26.500]             invokeRestart <- base::invokeRestart
  [22:14:26.500]             length <- base::length
  [22:14:26.500]             seq.int <- base::seq.int
  [22:14:26.500]             sys.calls <- base::sys.calls
  [22:14:26.500]             `[[` <- base::`[[`
  [22:14:26.500]             `+` <- base::`+`
  [22:14:26.500]             `<<-` <- base::`<<-`
  [22:14:26.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.500]                   3L)]
  [22:14:26.500]             }
  [22:14:26.500]             function(cond) {
  [22:14:26.500]                 if (inherits(cond, "error")) {
  [22:14:26.500]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.500]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.500]                     signaled = 0L)
  [22:14:26.500]                   signalCondition(cond)
  [22:14:26.500]                 }
  [22:14:26.500]                 else if (inherits(cond, "condition")) {
  [22:14:26.500]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.500]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.500]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.500]                   if (inherits(cond, "message")) {
  [22:14:26.500]                     if (!signal) 
  [22:14:26.500]                       invokeRestart("muffleMessage")
  [22:14:26.500]                   }
  [22:14:26.500]                   else if (inherits(cond, "warning")) {
  [22:14:26.500]                     if (!signal) 
  [22:14:26.500]                       invokeRestart("muffleWarning")
  [22:14:26.500]                   }
  [22:14:26.500]                   else {
  [22:14:26.500]                     if (!signal) {
  [22:14:26.500]                       restarts <- computeRestarts(cond)
  [22:14:26.500]                       for (restart in restarts) {
  [22:14:26.500]                         name <- restart$name
  [22:14:26.500]                         if (is.null(name)) 
  [22:14:26.500]                           next
  [22:14:26.500]                         if (!grepl("^muffle", name)) 
  [22:14:26.500]                           next
  [22:14:26.500]                         invokeRestart(restart)
  [22:14:26.500]                         break
  [22:14:26.500]                       }
  [22:14:26.500]                     }
  [22:14:26.500]                   }
  [22:14:26.500]                 }
  [22:14:26.500]             }
  [22:14:26.500]         }))
  [22:14:26.500]     }, error = function(ex) {
  [22:14:26.500]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.500]             version = "1.8"), class = "FutureResult")
  [22:14:26.500]     }, finally = {
  [22:14:26.500]         {
  [22:14:26.500]             {
  [22:14:26.500]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.500]             }
  [22:14:26.500]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.500]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.500]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.500]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.500]                 ...) 
  [22:14:26.500]             {
  [22:14:26.500]                 if (substitute) 
  [22:14:26.500]                   expr <- substitute(expr)
  [22:14:26.500]                 if (is.function(workers)) 
  [22:14:26.500]                   workers <- workers()
  [22:14:26.500]                 workers <- as.integer(workers)
  [22:14:26.500]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.500]                   workers >= 1)
  [22:14:26.500]                 if (workers == 1L) {
  [22:14:26.500]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.500]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.500]                     local = TRUE, label = label, ...))
  [22:14:26.500]                 }
  [22:14:26.500]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.500]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.500]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.500]                   globals = globals, persistent = persistent, 
  [22:14:26.500]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.500]                   label = label, ...)
  [22:14:26.500]                 if (!future$lazy) 
  [22:14:26.500]                   future <- run(future)
  [22:14:26.500]                 invisible(future)
  [22:14:26.500]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.500]         }
  [22:14:26.500]         options(...future.oldOptions)
  [22:14:26.500]     })
  [22:14:26.500]     if (is.na(TRUE)) {
  [22:14:26.500]     }
  [22:14:26.500]     else {
  [22:14:26.500]         sink(type = "output", split = FALSE)
  [22:14:26.500]         if (TRUE) {
  [22:14:26.500]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.500]         }
  [22:14:26.500]         else {
  [22:14:26.500]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.500]         }
  [22:14:26.500]         close(...future.stdout)
  [22:14:26.500]         ...future.stdout <- NULL
  [22:14:26.500]     }
  [22:14:26.500]     ...future.result$conditions <- ...future.conditions
  [22:14:26.500]     ...future.result
  [22:14:26.500] }
  [22:14:26.504] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:26.504] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:26.505] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:26.506] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:26.507] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:26.508] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.523] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.523] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:26.524] MultisessionFuture started
  [22:14:26.525] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2f78d00>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:26.571] result() for ClusterFuture ...
  [22:14:26.571] - Validating connection of MultisessionFuture
  [22:14:26.572] - class(result): FutureResult
  [22:14:26.572] result() for ClusterFuture ...
  [22:14:26.573] - result already collected: FutureResult
  [22:14:26.573] result() for ClusterFuture ... done
  [22:14:26.573] result() for ClusterFuture ... done
  [22:14:26.574] result() for ClusterFuture ...
  [22:14:26.574] - result already collected: FutureResult
  [22:14:26.574] result() for ClusterFuture ... done
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:26.580] futureCall() ...
  [22:14:26.581] Globals to be used in the future:
  [22:14:26.581] List of 3
  [22:14:26.581]  $ a   : num 3
  [22:14:26.581]  $ FUN :function (x, y)  
  [22:14:26.581]  $ args:List of 2
  [22:14:26.581]   ..$ x: num 42
  [22:14:26.581]   ..$ y: num 12
  [22:14:26.581]  - attr(*, "where")=List of 3
  [22:14:26.581]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:26.581]   ..$ FUN :<environment: 0x2a74508> 
  [22:14:26.581]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:26.581]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.581]  - attr(*, "resolved")= logi FALSE
  [22:14:26.581]  - attr(*, "total_size")= num NA
  [22:14:26.608] getGlobalsAndPackages() ...
  [22:14:26.608] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:26.609] Resolving globals: FALSE
  [22:14:26.610] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:26.610] - globals: [3] 'a', 'FUN', 'args'
  [22:14:26.611] 
  [22:14:26.611] getGlobalsAndPackages() ... DONE
  [22:14:26.613] Packages needed by the future expression (n = 0): <none>
  [22:14:26.613] Packages needed by future strategies (n = 0): <none>
  [22:14:26.618] {
  [22:14:26.618]     {
  [22:14:26.618]         ...future.startTime <- Sys.time()
  [22:14:26.618]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.618]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.618]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.618]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.618]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.618]         {
  [22:14:26.618]             {
  [22:14:26.618]                 {
  [22:14:26.618]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.618]                   version <- if (has_future) 
  [22:14:26.618]                     packageVersion("future")
  [22:14:26.618]                   else NULL
  [22:14:26.618]                   if (!has_future || version < "1.8.0") {
  [22:14:26.618]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.618]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.618]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.618]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.618]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.618]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.618]                     info <- paste(info, collapse = "; ")
  [22:14:26.618]                     if (!has_future) {
  [22:14:26.618]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.618]                         info)
  [22:14:26.618]                     }
  [22:14:26.618]                     else {
  [22:14:26.618]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.618]                         info, version)
  [22:14:26.618]                     }
  [22:14:26.618]                     stop(msg)
  [22:14:26.618]                   }
  [22:14:26.618]                 }
  [22:14:26.618]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.618]                 options(mc.cores = 1L)
  [22:14:26.618]             }
  [22:14:26.618]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.618]         }
  [22:14:26.618]     }
  [22:14:26.618]     if (is.na(TRUE)) {
  [22:14:26.618]     }
  [22:14:26.618]     else {
  [22:14:26.618]         if (TRUE) {
  [22:14:26.618]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.618]         }
  [22:14:26.618]         else {
  [22:14:26.618]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.618]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.618]         }
  [22:14:26.618]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.618]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.618]             sink(type = "output", split = FALSE)
  [22:14:26.618]             close(...future.stdout)
  [22:14:26.618]         }, add = TRUE)
  [22:14:26.618]     }
  [22:14:26.618]     ...future.frame <- sys.nframe()
  [22:14:26.618]     ...future.conditions <- list()
  [22:14:26.618]     ...future.result <- tryCatch({
  [22:14:26.618]         withCallingHandlers({
  [22:14:26.618]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.618]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.618]                 version = "1.8")
  [22:14:26.618]         }, condition = local({
  [22:14:26.618]             inherits <- base::inherits
  [22:14:26.618]             invokeRestart <- base::invokeRestart
  [22:14:26.618]             length <- base::length
  [22:14:26.618]             seq.int <- base::seq.int
  [22:14:26.618]             sys.calls <- base::sys.calls
  [22:14:26.618]             `[[` <- base::`[[`
  [22:14:26.618]             `+` <- base::`+`
  [22:14:26.618]             `<<-` <- base::`<<-`
  [22:14:26.618]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.618]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.618]                   3L)]
  [22:14:26.618]             }
  [22:14:26.618]             function(cond) {
  [22:14:26.618]                 if (inherits(cond, "error")) {
  [22:14:26.618]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.618]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.618]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.618]                     signaled = 0L)
  [22:14:26.618]                   signalCondition(cond)
  [22:14:26.618]                 }
  [22:14:26.618]                 else if (inherits(cond, "condition")) {
  [22:14:26.618]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.618]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.618]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.618]                   if (inherits(cond, "message")) {
  [22:14:26.618]                     if (!signal) 
  [22:14:26.618]                       invokeRestart("muffleMessage")
  [22:14:26.618]                   }
  [22:14:26.618]                   else if (inherits(cond, "warning")) {
  [22:14:26.618]                     if (!signal) 
  [22:14:26.618]                       invokeRestart("muffleWarning")
  [22:14:26.618]                   }
  [22:14:26.618]                   else {
  [22:14:26.618]                     if (!signal) {
  [22:14:26.618]                       restarts <- computeRestarts(cond)
  [22:14:26.618]                       for (restart in restarts) {
  [22:14:26.618]                         name <- restart$name
  [22:14:26.618]                         if (is.null(name)) 
  [22:14:26.618]                           next
  [22:14:26.618]                         if (!grepl("^muffle", name)) 
  [22:14:26.618]                           next
  [22:14:26.618]                         invokeRestart(restart)
  [22:14:26.618]                         break
  [22:14:26.618]                       }
  [22:14:26.618]                     }
  [22:14:26.618]                   }
  [22:14:26.618]                 }
  [22:14:26.618]             }
  [22:14:26.618]         }))
  [22:14:26.618]     }, error = function(ex) {
  [22:14:26.618]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.618]             version = "1.8"), class = "FutureResult")
  [22:14:26.618]     }, finally = {
  [22:14:26.618]         {
  [22:14:26.618]             {
  [22:14:26.618]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.618]             }
  [22:14:26.618]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.618]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.618]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.618]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.618]                 ...) 
  [22:14:26.618]             {
  [22:14:26.618]                 if (substitute) 
  [22:14:26.618]                   expr <- substitute(expr)
  [22:14:26.618]                 if (is.function(workers)) 
  [22:14:26.618]                   workers <- workers()
  [22:14:26.618]                 workers <- as.integer(workers)
  [22:14:26.618]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.618]                   workers >= 1)
  [22:14:26.618]                 if (workers == 1L) {
  [22:14:26.618]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.618]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.618]                     local = TRUE, label = label, ...))
  [22:14:26.618]                 }
  [22:14:26.618]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.618]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.618]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.618]                   globals = globals, persistent = persistent, 
  [22:14:26.618]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.618]                   label = label, ...)
  [22:14:26.618]                 if (!future$lazy) 
  [22:14:26.618]                   future <- run(future)
  [22:14:26.618]                 invisible(future)
  [22:14:26.618]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.618]         }
  [22:14:26.618]         options(...future.oldOptions)
  [22:14:26.618]     })
  [22:14:26.618]     if (is.na(TRUE)) {
  [22:14:26.618]     }
  [22:14:26.618]     else {
  [22:14:26.618]         sink(type = "output", split = FALSE)
  [22:14:26.618]         if (TRUE) {
  [22:14:26.618]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.618]         }
  [22:14:26.618]         else {
  [22:14:26.618]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.618]         }
  [22:14:26.618]         close(...future.stdout)
  [22:14:26.618]         ...future.stdout <- NULL
  [22:14:26.618]     }
  [22:14:26.618]     ...future.result$conditions <- ...future.conditions
  [22:14:26.618]     ...future.result
  [22:14:26.618] }
  [22:14:26.622] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:26.622] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:26.623] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:26.624] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:26.625] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:26.625] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.626] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.626] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:26.627] MultisessionFuture started
  [22:14:26.628] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2a62140>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:26.675] result() for ClusterFuture ...
  [22:14:26.675] - Validating connection of MultisessionFuture
  [22:14:26.676] - class(result): FutureResult
  [22:14:26.676] result() for ClusterFuture ...
  [22:14:26.676] - result already collected: FutureResult
  [22:14:26.677] result() for ClusterFuture ... done
  [22:14:26.677] result() for ClusterFuture ... done
  [22:14:26.677] result() for ClusterFuture ...
  [22:14:26.677] - result already collected: FutureResult
  [22:14:26.678] result() for ClusterFuture ... done
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:26.683] futureCall() ...
  [22:14:26.683] Finding globals ...
  [22:14:26.683] getGlobalsAndPackages() ...
  [22:14:26.684] Searching for globals...
  [22:14:26.705] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:26.705] Searching for globals ... DONE
  [22:14:26.706] Resolving globals: FALSE
  [22:14:26.707] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:26.707] - globals: [3] 'FUN', 'args', 'a'
  [22:14:26.708] 
  [22:14:26.708] getGlobalsAndPackages() ... DONE
  [22:14:26.708]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:26.709] 
  [22:14:26.709] Finding globals ... DONE
  [22:14:26.710] Globals to be used in the future:
  [22:14:26.710] List of 3
  [22:14:26.710]  $ FUN :function (x, y)  
  [22:14:26.710]  $ args:List of 2
  [22:14:26.710]   ..$ x: num 42
  [22:14:26.710]   ..$ y: num 12
  [22:14:26.710]  $ a   : num 3
  [22:14:26.710]  - attr(*, "where")=List of 3
  [22:14:26.710]   ..$ FUN :<environment: 0x287ac78> 
  [22:14:26.710]   ..$ args:<environment: 0xd1a188> 
  [22:14:26.710]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:26.710]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.710]  - attr(*, "resolved")= logi FALSE
  [22:14:26.710]  - attr(*, "total_size")= num 2592
  [22:14:26.730] getGlobalsAndPackages() ...
  [22:14:26.731] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:26.731] Resolving globals: FALSE
  [22:14:26.732] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:26.733] - globals: [3] 'FUN', 'args', 'a'
  [22:14:26.733] 
  [22:14:26.733] getGlobalsAndPackages() ... DONE
  [22:14:26.741] Packages needed by the future expression (n = 0): <none>
  [22:14:26.741] Packages needed by future strategies (n = 0): <none>
  [22:14:26.746] {
  [22:14:26.746]     {
  [22:14:26.746]         ...future.startTime <- Sys.time()
  [22:14:26.746]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.746]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.746]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.746]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.746]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.746]         {
  [22:14:26.746]             {
  [22:14:26.746]                 {
  [22:14:26.746]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.746]                   version <- if (has_future) 
  [22:14:26.746]                     packageVersion("future")
  [22:14:26.746]                   else NULL
  [22:14:26.746]                   if (!has_future || version < "1.8.0") {
  [22:14:26.746]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.746]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.746]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.746]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.746]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.746]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.746]                     info <- paste(info, collapse = "; ")
  [22:14:26.746]                     if (!has_future) {
  [22:14:26.746]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.746]                         info)
  [22:14:26.746]                     }
  [22:14:26.746]                     else {
  [22:14:26.746]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.746]                         info, version)
  [22:14:26.746]                     }
  [22:14:26.746]                     stop(msg)
  [22:14:26.746]                   }
  [22:14:26.746]                 }
  [22:14:26.746]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.746]                 options(mc.cores = 1L)
  [22:14:26.746]             }
  [22:14:26.746]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.746]         }
  [22:14:26.746]     }
  [22:14:26.746]     if (is.na(TRUE)) {
  [22:14:26.746]     }
  [22:14:26.746]     else {
  [22:14:26.746]         if (TRUE) {
  [22:14:26.746]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.746]         }
  [22:14:26.746]         else {
  [22:14:26.746]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.746]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.746]         }
  [22:14:26.746]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.746]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.746]             sink(type = "output", split = FALSE)
  [22:14:26.746]             close(...future.stdout)
  [22:14:26.746]         }, add = TRUE)
  [22:14:26.746]     }
  [22:14:26.746]     ...future.frame <- sys.nframe()
  [22:14:26.746]     ...future.conditions <- list()
  [22:14:26.746]     ...future.result <- tryCatch({
  [22:14:26.746]         withCallingHandlers({
  [22:14:26.746]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.746]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.746]                 version = "1.8")
  [22:14:26.746]         }, condition = local({
  [22:14:26.746]             inherits <- base::inherits
  [22:14:26.746]             invokeRestart <- base::invokeRestart
  [22:14:26.746]             length <- base::length
  [22:14:26.746]             seq.int <- base::seq.int
  [22:14:26.746]             sys.calls <- base::sys.calls
  [22:14:26.746]             `[[` <- base::`[[`
  [22:14:26.746]             `+` <- base::`+`
  [22:14:26.746]             `<<-` <- base::`<<-`
  [22:14:26.746]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.746]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.746]                   3L)]
  [22:14:26.746]             }
  [22:14:26.746]             function(cond) {
  [22:14:26.746]                 if (inherits(cond, "error")) {
  [22:14:26.746]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.746]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.746]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.746]                     signaled = 0L)
  [22:14:26.746]                   signalCondition(cond)
  [22:14:26.746]                 }
  [22:14:26.746]                 else if (inherits(cond, "condition")) {
  [22:14:26.746]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.746]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.746]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.746]                   if (inherits(cond, "message")) {
  [22:14:26.746]                     if (!signal) 
  [22:14:26.746]                       invokeRestart("muffleMessage")
  [22:14:26.746]                   }
  [22:14:26.746]                   else if (inherits(cond, "warning")) {
  [22:14:26.746]                     if (!signal) 
  [22:14:26.746]                       invokeRestart("muffleWarning")
  [22:14:26.746]                   }
  [22:14:26.746]                   else {
  [22:14:26.746]                     if (!signal) {
  [22:14:26.746]                       restarts <- computeRestarts(cond)
  [22:14:26.746]                       for (restart in restarts) {
  [22:14:26.746]                         name <- restart$name
  [22:14:26.746]                         if (is.null(name)) 
  [22:14:26.746]                           next
  [22:14:26.746]                         if (!grepl("^muffle", name)) 
  [22:14:26.746]                           next
  [22:14:26.746]                         invokeRestart(restart)
  [22:14:26.746]                         break
  [22:14:26.746]                       }
  [22:14:26.746]                     }
  [22:14:26.746]                   }
  [22:14:26.746]                 }
  [22:14:26.746]             }
  [22:14:26.746]         }))
  [22:14:26.746]     }, error = function(ex) {
  [22:14:26.746]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.746]             version = "1.8"), class = "FutureResult")
  [22:14:26.746]     }, finally = {
  [22:14:26.746]         {
  [22:14:26.746]             {
  [22:14:26.746]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.746]             }
  [22:14:26.746]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.746]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.746]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.746]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.746]                 ...) 
  [22:14:26.746]             {
  [22:14:26.746]                 if (substitute) 
  [22:14:26.746]                   expr <- substitute(expr)
  [22:14:26.746]                 if (is.function(workers)) 
  [22:14:26.746]                   workers <- workers()
  [22:14:26.746]                 workers <- as.integer(workers)
  [22:14:26.746]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.746]                   workers >= 1)
  [22:14:26.746]                 if (workers == 1L) {
  [22:14:26.746]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.746]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.746]                     local = TRUE, label = label, ...))
  [22:14:26.746]                 }
  [22:14:26.746]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.746]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.746]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.746]                   globals = globals, persistent = persistent, 
  [22:14:26.746]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.746]                   label = label, ...)
  [22:14:26.746]                 if (!future$lazy) 
  [22:14:26.746]                   future <- run(future)
  [22:14:26.746]                 invisible(future)
  [22:14:26.746]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.746]         }
  [22:14:26.746]         options(...future.oldOptions)
  [22:14:26.746]     })
  [22:14:26.746]     if (is.na(TRUE)) {
  [22:14:26.746]     }
  [22:14:26.746]     else {
  [22:14:26.746]         sink(type = "output", split = FALSE)
  [22:14:26.746]         if (TRUE) {
  [22:14:26.746]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.746]         }
  [22:14:26.746]         else {
  [22:14:26.746]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.746]         }
  [22:14:26.746]         close(...future.stdout)
  [22:14:26.746]         ...future.stdout <- NULL
  [22:14:26.746]     }
  [22:14:26.746]     ...future.result$conditions <- ...future.conditions
  [22:14:26.746]     ...future.result
  [22:14:26.746] }
  [22:14:26.749] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:26.750] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:26.751] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:26.751] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.752] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.753] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:26.754] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:26.754] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:26.755] MultisessionFuture started
  [22:14:26.755] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0xd1a188>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:26.803] result() for ClusterFuture ...
  [22:14:26.803] - Validating connection of MultisessionFuture
  [22:14:26.804] - class(result): FutureResult
  [22:14:26.804] result() for ClusterFuture ...
  [22:14:26.804] - result already collected: FutureResult
  [22:14:26.804] result() for ClusterFuture ... done
  [22:14:26.805] result() for ClusterFuture ... done
  [22:14:26.805] result() for ClusterFuture ...
  [22:14:26.805] - result already collected: FutureResult
  [22:14:26.806] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:26.811] futureCall() ...
  [22:14:26.811] Globals to be used in the future:
  [22:14:26.812] List of 3
  [22:14:26.812]  $ a   : num 3
  [22:14:26.812]  $ FUN :function (x, y)  
  [22:14:26.812]  $ args:List of 2
  [22:14:26.812]   ..$ x: num 42
  [22:14:26.812]   ..$ y: num 12
  [22:14:26.812]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.812]  - attr(*, "where")=List of 3
  [22:14:26.812]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:26.812]   ..$ FUN :<environment: 0x1de1018> 
  [22:14:26.812]   ..$ args:<environment: 0x1258b80> 
  [22:14:26.812]  - attr(*, "resolved")= logi FALSE
  [22:14:26.812]  - attr(*, "total_size")= num NA
  [22:14:26.832] getGlobalsAndPackages() ...
  [22:14:26.832] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:26.833] Resolving globals: FALSE
  [22:14:26.834] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:26.834] - globals: [3] 'a', 'FUN', 'args'
  [22:14:26.835] 
  [22:14:26.835] getGlobalsAndPackages() ... DONE
  [22:14:26.837] Packages needed by the future expression (n = 0): <none>
  [22:14:26.837] Packages needed by future strategies (n = 0): <none>
  [22:14:26.842] {
  [22:14:26.842]     {
  [22:14:26.842]         ...future.startTime <- Sys.time()
  [22:14:26.842]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.842]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.842]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.842]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.842]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.842]         {
  [22:14:26.842]             {
  [22:14:26.842]                 {
  [22:14:26.842]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.842]                   version <- if (has_future) 
  [22:14:26.842]                     packageVersion("future")
  [22:14:26.842]                   else NULL
  [22:14:26.842]                   if (!has_future || version < "1.8.0") {
  [22:14:26.842]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.842]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.842]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.842]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.842]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.842]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.842]                     info <- paste(info, collapse = "; ")
  [22:14:26.842]                     if (!has_future) {
  [22:14:26.842]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.842]                         info)
  [22:14:26.842]                     }
  [22:14:26.842]                     else {
  [22:14:26.842]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.842]                         info, version)
  [22:14:26.842]                     }
  [22:14:26.842]                     stop(msg)
  [22:14:26.842]                   }
  [22:14:26.842]                 }
  [22:14:26.842]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.842]                 options(mc.cores = 1L)
  [22:14:26.842]             }
  [22:14:26.842]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.842]         }
  [22:14:26.842]     }
  [22:14:26.842]     if (is.na(TRUE)) {
  [22:14:26.842]     }
  [22:14:26.842]     else {
  [22:14:26.842]         if (TRUE) {
  [22:14:26.842]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.842]         }
  [22:14:26.842]         else {
  [22:14:26.842]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.842]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.842]         }
  [22:14:26.842]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.842]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.842]             sink(type = "output", split = FALSE)
  [22:14:26.842]             close(...future.stdout)
  [22:14:26.842]         }, add = TRUE)
  [22:14:26.842]     }
  [22:14:26.842]     ...future.frame <- sys.nframe()
  [22:14:26.842]     ...future.conditions <- list()
  [22:14:26.842]     ...future.result <- tryCatch({
  [22:14:26.842]         withCallingHandlers({
  [22:14:26.842]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.842]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.842]                 version = "1.8")
  [22:14:26.842]         }, condition = local({
  [22:14:26.842]             inherits <- base::inherits
  [22:14:26.842]             invokeRestart <- base::invokeRestart
  [22:14:26.842]             length <- base::length
  [22:14:26.842]             seq.int <- base::seq.int
  [22:14:26.842]             sys.calls <- base::sys.calls
  [22:14:26.842]             `[[` <- base::`[[`
  [22:14:26.842]             `+` <- base::`+`
  [22:14:26.842]             `<<-` <- base::`<<-`
  [22:14:26.842]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.842]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.842]                   3L)]
  [22:14:26.842]             }
  [22:14:26.842]             function(cond) {
  [22:14:26.842]                 if (inherits(cond, "error")) {
  [22:14:26.842]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.842]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.842]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.842]                     signaled = 0L)
  [22:14:26.842]                   signalCondition(cond)
  [22:14:26.842]                 }
  [22:14:26.842]                 else if (inherits(cond, "condition")) {
  [22:14:26.842]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.842]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.842]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.842]                   if (inherits(cond, "message")) {
  [22:14:26.842]                     if (!signal) 
  [22:14:26.842]                       invokeRestart("muffleMessage")
  [22:14:26.842]                   }
  [22:14:26.842]                   else if (inherits(cond, "warning")) {
  [22:14:26.842]                     if (!signal) 
  [22:14:26.842]                       invokeRestart("muffleWarning")
  [22:14:26.842]                   }
  [22:14:26.842]                   else {
  [22:14:26.842]                     if (!signal) {
  [22:14:26.842]                       restarts <- computeRestarts(cond)
  [22:14:26.842]                       for (restart in restarts) {
  [22:14:26.842]                         name <- restart$name
  [22:14:26.842]                         if (is.null(name)) 
  [22:14:26.842]                           next
  [22:14:26.842]                         if (!grepl("^muffle", name)) 
  [22:14:26.842]                           next
  [22:14:26.842]                         invokeRestart(restart)
  [22:14:26.842]                         break
  [22:14:26.842]                       }
  [22:14:26.842]                     }
  [22:14:26.842]                   }
  [22:14:26.842]                 }
  [22:14:26.842]             }
  [22:14:26.842]         }))
  [22:14:26.842]     }, error = function(ex) {
  [22:14:26.842]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.842]             version = "1.8"), class = "FutureResult")
  [22:14:26.842]     }, finally = {
  [22:14:26.842]         {
  [22:14:26.842]             {
  [22:14:26.842]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.842]             }
  [22:14:26.842]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.842]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.842]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.842]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.842]                 ...) 
  [22:14:26.842]             {
  [22:14:26.842]                 if (substitute) 
  [22:14:26.842]                   expr <- substitute(expr)
  [22:14:26.842]                 if (is.function(workers)) 
  [22:14:26.842]                   workers <- workers()
  [22:14:26.842]                 workers <- as.integer(workers)
  [22:14:26.842]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.842]                   workers >= 1)
  [22:14:26.842]                 if (workers == 1L) {
  [22:14:26.842]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.842]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.842]                     local = TRUE, label = label, ...))
  [22:14:26.842]                 }
  [22:14:26.842]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.842]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.842]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.842]                   globals = globals, persistent = persistent, 
  [22:14:26.842]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.842]                   label = label, ...)
  [22:14:26.842]                 if (!future$lazy) 
  [22:14:26.842]                   future <- run(future)
  [22:14:26.842]                 invisible(future)
  [22:14:26.842]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.842]         }
  [22:14:26.842]         options(...future.oldOptions)
  [22:14:26.842]     })
  [22:14:26.842]     if (is.na(TRUE)) {
  [22:14:26.842]     }
  [22:14:26.842]     else {
  [22:14:26.842]         sink(type = "output", split = FALSE)
  [22:14:26.842]         if (TRUE) {
  [22:14:26.842]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.842]         }
  [22:14:26.842]         else {
  [22:14:26.842]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.842]         }
  [22:14:26.842]         close(...future.stdout)
  [22:14:26.842]         ...future.stdout <- NULL
  [22:14:26.842]     }
  [22:14:26.842]     ...future.result$conditions <- ...future.conditions
  [22:14:26.842]     ...future.result
  [22:14:26.842] }
  [22:14:26.845] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:26.846] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:26.847] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:26.847] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:26.848] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:26.848] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.849] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.850] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:26.851] MultisessionFuture started
  [22:14:26.851] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1258b80>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:26.895] result() for ClusterFuture ...
  [22:14:26.895] - Validating connection of MultisessionFuture
  [22:14:26.896] - class(result): FutureResult
  [22:14:26.896] result() for ClusterFuture ...
  [22:14:26.897] - result already collected: FutureResult
  [22:14:26.897] result() for ClusterFuture ... done
  [22:14:26.897] result() for ClusterFuture ... done
  [22:14:26.898] result() for ClusterFuture ...
  [22:14:26.898] - result already collected: FutureResult
  [22:14:26.898] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:26.904] futureCall() ...
  [22:14:26.904] Globals to be used in the future:
  [22:14:26.905] List of 3
  [22:14:26.905]  $ a   : num 3
  [22:14:26.905]  $ FUN :function (x, y)  
  [22:14:26.905]  $ args:List of 2
  [22:14:26.905]   ..$ x: num 42
  [22:14:26.905]   ..$ y: num 12
  [22:14:26.905]  - attr(*, "where")=List of 3
  [22:14:26.905]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:26.905]   ..$ FUN :<environment: 0x1767f60> 
  [22:14:26.905]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:26.905]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:26.905]  - attr(*, "resolved")= logi FALSE
  [22:14:26.905]  - attr(*, "total_size")= num NA
  [22:14:26.943] getGlobalsAndPackages() ...
  [22:14:26.943] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:26.944] Resolving globals: FALSE
  [22:14:26.945] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:26.945] - globals: [3] 'a', 'FUN', 'args'
  [22:14:26.945] 
  [22:14:26.946] getGlobalsAndPackages() ... DONE
  [22:14:26.948] Packages needed by the future expression (n = 0): <none>
  [22:14:26.948] Packages needed by future strategies (n = 0): <none>
  [22:14:26.965] {
  [22:14:26.965]     {
  [22:14:26.965]         ...future.startTime <- Sys.time()
  [22:14:26.965]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:26.965]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:26.965]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:26.965]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:26.965]             future.resolve.recursive = NULL, width = 80L)
  [22:14:26.965]         {
  [22:14:26.965]             {
  [22:14:26.965]                 {
  [22:14:26.965]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:26.965]                   version <- if (has_future) 
  [22:14:26.965]                     packageVersion("future")
  [22:14:26.965]                   else NULL
  [22:14:26.965]                   if (!has_future || version < "1.8.0") {
  [22:14:26.965]                     info <- c(r_version = gsub("R version ", 
  [22:14:26.965]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:26.965]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:26.965]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:26.965]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:26.965]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:26.965]                     info <- paste(info, collapse = "; ")
  [22:14:26.965]                     if (!has_future) {
  [22:14:26.965]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:26.965]                         info)
  [22:14:26.965]                     }
  [22:14:26.965]                     else {
  [22:14:26.965]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:26.965]                         info, version)
  [22:14:26.965]                     }
  [22:14:26.965]                     stop(msg)
  [22:14:26.965]                   }
  [22:14:26.965]                 }
  [22:14:26.965]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:26.965]                 options(mc.cores = 1L)
  [22:14:26.965]             }
  [22:14:26.965]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:26.965]         }
  [22:14:26.965]     }
  [22:14:26.965]     if (is.na(TRUE)) {
  [22:14:26.965]     }
  [22:14:26.965]     else {
  [22:14:26.965]         if (TRUE) {
  [22:14:26.965]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:26.965]         }
  [22:14:26.965]         else {
  [22:14:26.965]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:26.965]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:26.965]         }
  [22:14:26.965]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:26.965]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:26.965]             sink(type = "output", split = FALSE)
  [22:14:26.965]             close(...future.stdout)
  [22:14:26.965]         }, add = TRUE)
  [22:14:26.965]     }
  [22:14:26.965]     ...future.frame <- sys.nframe()
  [22:14:26.965]     ...future.conditions <- list()
  [22:14:26.965]     ...future.result <- tryCatch({
  [22:14:26.965]         withCallingHandlers({
  [22:14:26.965]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:26.965]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:26.965]                 version = "1.8")
  [22:14:26.965]         }, condition = local({
  [22:14:26.965]             inherits <- base::inherits
  [22:14:26.965]             invokeRestart <- base::invokeRestart
  [22:14:26.965]             length <- base::length
  [22:14:26.965]             seq.int <- base::seq.int
  [22:14:26.965]             sys.calls <- base::sys.calls
  [22:14:26.965]             `[[` <- base::`[[`
  [22:14:26.965]             `+` <- base::`+`
  [22:14:26.965]             `<<-` <- base::`<<-`
  [22:14:26.965]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:26.965]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:26.965]                   3L)]
  [22:14:26.965]             }
  [22:14:26.965]             function(cond) {
  [22:14:26.965]                 if (inherits(cond, "error")) {
  [22:14:26.965]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.965]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:26.965]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:26.965]                     signaled = 0L)
  [22:14:26.965]                   signalCondition(cond)
  [22:14:26.965]                 }
  [22:14:26.965]                 else if (inherits(cond, "condition")) {
  [22:14:26.965]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:26.965]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:26.965]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:26.965]                   if (inherits(cond, "message")) {
  [22:14:26.965]                     if (!signal) 
  [22:14:26.965]                       invokeRestart("muffleMessage")
  [22:14:26.965]                   }
  [22:14:26.965]                   else if (inherits(cond, "warning")) {
  [22:14:26.965]                     if (!signal) 
  [22:14:26.965]                       invokeRestart("muffleWarning")
  [22:14:26.965]                   }
  [22:14:26.965]                   else {
  [22:14:26.965]                     if (!signal) {
  [22:14:26.965]                       restarts <- computeRestarts(cond)
  [22:14:26.965]                       for (restart in restarts) {
  [22:14:26.965]                         name <- restart$name
  [22:14:26.965]                         if (is.null(name)) 
  [22:14:26.965]                           next
  [22:14:26.965]                         if (!grepl("^muffle", name)) 
  [22:14:26.965]                           next
  [22:14:26.965]                         invokeRestart(restart)
  [22:14:26.965]                         break
  [22:14:26.965]                       }
  [22:14:26.965]                     }
  [22:14:26.965]                   }
  [22:14:26.965]                 }
  [22:14:26.965]             }
  [22:14:26.965]         }))
  [22:14:26.965]     }, error = function(ex) {
  [22:14:26.965]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:26.965]             version = "1.8"), class = "FutureResult")
  [22:14:26.965]     }, finally = {
  [22:14:26.965]         {
  [22:14:26.965]             {
  [22:14:26.965]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:26.965]             }
  [22:14:26.965]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:26.965]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:26.965]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:26.965]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:26.965]                 ...) 
  [22:14:26.965]             {
  [22:14:26.965]                 if (substitute) 
  [22:14:26.965]                   expr <- substitute(expr)
  [22:14:26.965]                 if (is.function(workers)) 
  [22:14:26.965]                   workers <- workers()
  [22:14:26.965]                 workers <- as.integer(workers)
  [22:14:26.965]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:26.965]                   workers >= 1)
  [22:14:26.965]                 if (workers == 1L) {
  [22:14:26.965]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:26.965]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:26.965]                     local = TRUE, label = label, ...))
  [22:14:26.965]                 }
  [22:14:26.965]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:26.965]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:26.965]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:26.965]                   globals = globals, persistent = persistent, 
  [22:14:26.965]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:26.965]                   label = label, ...)
  [22:14:26.965]                 if (!future$lazy) 
  [22:14:26.965]                   future <- run(future)
  [22:14:26.965]                 invisible(future)
  [22:14:26.965]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:26.965]         }
  [22:14:26.965]         options(...future.oldOptions)
  [22:14:26.965]     })
  [22:14:26.965]     if (is.na(TRUE)) {
  [22:14:26.965]     }
  [22:14:26.965]     else {
  [22:14:26.965]         sink(type = "output", split = FALSE)
  [22:14:26.965]         if (TRUE) {
  [22:14:26.965]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:26.965]         }
  [22:14:26.965]         else {
  [22:14:26.965]             ...future.result["stdout"] <- list(NULL)
  [22:14:26.965]         }
  [22:14:26.965]         close(...future.stdout)
  [22:14:26.965]         ...future.stdout <- NULL
  [22:14:26.965]     }
  [22:14:26.965]     ...future.result$conditions <- ...future.conditions
  [22:14:26.965]     ...future.result
  [22:14:26.965] }
  [22:14:26.983] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:26.983] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:26.985] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:26.985] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:26.986] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:26.987] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:26.988] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:26.988] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:26.990] MultisessionFuture started
  [22:14:26.990] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x17d7a50>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.035] result() for ClusterFuture ...
  [22:14:27.035] - Validating connection of MultisessionFuture
  [22:14:27.036] - class(result): FutureResult
  [22:14:27.036] result() for ClusterFuture ...
  [22:14:27.036] - result already collected: FutureResult
  [22:14:27.037] result() for ClusterFuture ... done
  [22:14:27.037] result() for ClusterFuture ... done
  [22:14:27.037] result() for ClusterFuture ...
  [22:14:27.037] - result already collected: FutureResult
  [22:14:27.038] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi FALSE
   $ v0     : num 90
   $ v3     : num 90
  [22:14:27.043] futureCall() ...
  [22:14:27.044] Globals to be used in the future:
  [22:14:27.044] List of 2
  [22:14:27.044]  $ FUN :function (x, y)  
  [22:14:27.044]  $ args:List of 2
  [22:14:27.044]   ..$ x: num 42
  [22:14:27.044]   ..$ y: num 12
  [22:14:27.044]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.044]  - attr(*, "where")=List of 2
  [22:14:27.044]   ..$ FUN :<environment: 0x2c09a28> 
  [22:14:27.044]   ..$ args:<environment: 0x2c09a28> 
  [22:14:27.044]  - attr(*, "resolved")= logi FALSE
  [22:14:27.044]  - attr(*, "total_size")= num NA
  [22:14:27.090] getGlobalsAndPackages() ...
  [22:14:27.091] - globals passed as-is: [2] 'FUN', 'args'
  [22:14:27.091] Resolving globals: FALSE
  [22:14:27.092] The total size of the 2 globals is 2.48 KiB (2536 bytes)
  [22:14:27.092] - globals: [2] 'FUN', 'args'
  [22:14:27.093] 
  [22:14:27.093] getGlobalsAndPackages() ... DONE
  [22:14:27.094] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2c09a28>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 2 objects totaling 2.48 KiB (function 'FUN' of 2.37 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.106] Packages needed by the future expression (n = 0): <none>
  [22:14:27.106] Packages needed by future strategies (n = 0): <none>
  [22:14:27.110] {
  [22:14:27.110]     {
  [22:14:27.110]         ...future.startTime <- Sys.time()
  [22:14:27.110]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.110]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.110]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.110]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.110]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.110]         {
  [22:14:27.110]             {
  [22:14:27.110]                 {
  [22:14:27.110]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.110]                   version <- if (has_future) 
  [22:14:27.110]                     packageVersion("future")
  [22:14:27.110]                   else NULL
  [22:14:27.110]                   if (!has_future || version < "1.8.0") {
  [22:14:27.110]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.110]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.110]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.110]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.110]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.110]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.110]                     info <- paste(info, collapse = "; ")
  [22:14:27.110]                     if (!has_future) {
  [22:14:27.110]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.110]                         info)
  [22:14:27.110]                     }
  [22:14:27.110]                     else {
  [22:14:27.110]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.110]                         info, version)
  [22:14:27.110]                     }
  [22:14:27.110]                     stop(msg)
  [22:14:27.110]                   }
  [22:14:27.110]                 }
  [22:14:27.110]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.110]                 options(mc.cores = 1L)
  [22:14:27.110]             }
  [22:14:27.110]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.110]         }
  [22:14:27.110]     }
  [22:14:27.110]     if (is.na(TRUE)) {
  [22:14:27.110]     }
  [22:14:27.110]     else {
  [22:14:27.110]         if (TRUE) {
  [22:14:27.110]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.110]         }
  [22:14:27.110]         else {
  [22:14:27.110]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.110]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.110]         }
  [22:14:27.110]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.110]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.110]             sink(type = "output", split = FALSE)
  [22:14:27.110]             close(...future.stdout)
  [22:14:27.110]         }, add = TRUE)
  [22:14:27.110]     }
  [22:14:27.110]     ...future.frame <- sys.nframe()
  [22:14:27.110]     ...future.conditions <- list()
  [22:14:27.110]     ...future.result <- tryCatch({
  [22:14:27.110]         withCallingHandlers({
  [22:14:27.110]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.110]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.110]                 version = "1.8")
  [22:14:27.110]         }, condition = local({
  [22:14:27.110]             inherits <- base::inherits
  [22:14:27.110]             invokeRestart <- base::invokeRestart
  [22:14:27.110]             length <- base::length
  [22:14:27.110]             seq.int <- base::seq.int
  [22:14:27.110]             sys.calls <- base::sys.calls
  [22:14:27.110]             `[[` <- base::`[[`
  [22:14:27.110]             `+` <- base::`+`
  [22:14:27.110]             `<<-` <- base::`<<-`
  [22:14:27.110]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.110]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.110]                   3L)]
  [22:14:27.110]             }
  [22:14:27.110]             function(cond) {
  [22:14:27.110]                 if (inherits(cond, "error")) {
  [22:14:27.110]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.110]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.110]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.110]                     signaled = 0L)
  [22:14:27.110]                   signalCondition(cond)
  [22:14:27.110]                 }
  [22:14:27.110]                 else if (inherits(cond, "condition")) {
  [22:14:27.110]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.110]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.110]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.110]                   if (inherits(cond, "message")) {
  [22:14:27.110]                     if (!signal) 
  [22:14:27.110]                       invokeRestart("muffleMessage")
  [22:14:27.110]                   }
  [22:14:27.110]                   else if (inherits(cond, "warning")) {
  [22:14:27.110]                     if (!signal) 
  [22:14:27.110]                       invokeRestart("muffleWarning")
  [22:14:27.110]                   }
  [22:14:27.110]                   else {
  [22:14:27.110]                     if (!signal) {
  [22:14:27.110]                       restarts <- computeRestarts(cond)
  [22:14:27.110]                       for (restart in restarts) {
  [22:14:27.110]                         name <- restart$name
  [22:14:27.110]                         if (is.null(name)) 
  [22:14:27.110]                           next
  [22:14:27.110]                         if (!grepl("^muffle", name)) 
  [22:14:27.110]                           next
  [22:14:27.110]                         invokeRestart(restart)
  [22:14:27.110]                         break
  [22:14:27.110]                       }
  [22:14:27.110]                     }
  [22:14:27.110]                   }
  [22:14:27.110]                 }
  [22:14:27.110]             }
  [22:14:27.110]         }))
  [22:14:27.110]     }, error = function(ex) {
  [22:14:27.110]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.110]             version = "1.8"), class = "FutureResult")
  [22:14:27.110]     }, finally = {
  [22:14:27.110]         {
  [22:14:27.110]             {
  [22:14:27.110]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.110]             }
  [22:14:27.110]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.110]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.110]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.110]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.110]                 ...) 
  [22:14:27.110]             {
  [22:14:27.110]                 if (substitute) 
  [22:14:27.110]                   expr <- substitute(expr)
  [22:14:27.110]                 if (is.function(workers)) 
  [22:14:27.110]                   workers <- workers()
  [22:14:27.110]                 workers <- as.integer(workers)
  [22:14:27.110]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.110]                   workers >= 1)
  [22:14:27.110]                 if (workers == 1L) {
  [22:14:27.110]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.110]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.110]                     local = TRUE, label = label, ...))
  [22:14:27.110]                 }
  [22:14:27.110]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.110]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.110]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.110]                   globals = globals, persistent = persistent, 
  [22:14:27.110]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.110]                   label = label, ...)
  [22:14:27.110]                 if (!future$lazy) 
  [22:14:27.110]                   future <- run(future)
  [22:14:27.110]                 invisible(future)
  [22:14:27.110]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.110]         }
  [22:14:27.110]         options(...future.oldOptions)
  [22:14:27.110]     })
  [22:14:27.110]     if (is.na(TRUE)) {
  [22:14:27.110]     }
  [22:14:27.110]     else {
  [22:14:27.110]         sink(type = "output", split = FALSE)
  [22:14:27.110]         if (TRUE) {
  [22:14:27.110]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.110]         }
  [22:14:27.110]         else {
  [22:14:27.110]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.110]         }
  [22:14:27.110]         close(...future.stdout)
  [22:14:27.110]         ...future.stdout <- NULL
  [22:14:27.110]     }
  [22:14:27.110]     ...future.result$conditions <- ...future.conditions
  [22:14:27.110]     ...future.result
  [22:14:27.110] }
  [22:14:27.114] Exporting 2 global objects (2.48 KiB) to cluster node #1 ...
  [22:14:27.115] Exporting 'FUN' (2.37 KiB) to cluster node #1 ...
  [22:14:27.116] Exporting 'FUN' (2.37 KiB) to cluster node #1 ... DONE
  [22:14:27.116] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.117] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.117] Exporting 2 global objects (2.48 KiB) to cluster node #1 ... DONE
  [22:14:27.123] MultisessionFuture started
  [22:14:27.123] result() for ClusterFuture ...
  [22:14:27.124] - Validating connection of MultisessionFuture
  [22:14:27.163] - class(result): FutureResult
  [22:14:27.163] result() for ClusterFuture ...
  [22:14:27.163] - result already collected: FutureResult
  [22:14:27.164] result() for ClusterFuture ... done
  [22:14:27.164] signalConditions() ...
  [22:14:27.164]  - include = 'immediateCondition'
  [22:14:27.165]  - exclude = 
  [22:14:27.165]  - resignal = FALSE
  [22:14:27.165]  - Number of conditions: 1
  [22:14:27.165] signalConditions() ... done
  [22:14:27.166] result() for ClusterFuture ... done
  [22:14:27.166] result() for ClusterFuture ...
  [22:14:27.166] - result already collected: FutureResult
  [22:14:27.166] result() for ClusterFuture ... done
  [22:14:27.167] signalConditions() ...
  [22:14:27.167]  - include = 'immediateCondition'
  [22:14:27.167]  - exclude = 
  [22:14:27.168]  - resignal = FALSE
  [22:14:27.168]  - Number of conditions: 1
  [22:14:27.168] signalConditions() ... done
  [22:14:27.168] Future state: 'finished'
  [22:14:27.169] result() for ClusterFuture ...
  [22:14:27.169] - result already collected: FutureResult
  [22:14:27.169] result() for ClusterFuture ... done
  [22:14:27.170] signalConditions() ...
  [22:14:27.170]  - include = 'condition'
  [22:14:27.170]  - exclude = 'immediateCondition'
  [22:14:27.170]  - resignal = TRUE
  [22:14:27.171]  - Number of conditions: 1
  [22:14:27.171]  - Condition #1: 'simpleError', 'error', 'condition'
  [22:14:27.171] signalConditions() ... done
  [22:14:27.172] futureCall() ...
  [22:14:27.172] Globals to be used in the future:
  [22:14:27.173] List of 3
  [22:14:27.173]  $ a   : num 3
  [22:14:27.173]  $ FUN :function (x, y)  
  [22:14:27.173]  $ args:List of 2
  [22:14:27.173]   ..$ x: num 42
  [22:14:27.173]   ..$ y: num 12
  [22:14:27.173]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.173]  - attr(*, "where")=List of 3
  [22:14:27.173]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:27.173]   ..$ FUN :<environment: 0x26be770> 
  [22:14:27.173]   ..$ args:<environment: 0x1b02d38> 
  [22:14:27.173]  - attr(*, "resolved")= logi FALSE
  [22:14:27.173]  - attr(*, "total_size")= num NA
  [22:14:27.208] getGlobalsAndPackages() ...
  [22:14:27.209] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:27.209] Resolving globals: FALSE
  [22:14:27.210] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:27.210] - globals: [3] 'a', 'FUN', 'args'
  [22:14:27.211] 
  [22:14:27.211] getGlobalsAndPackages() ... DONE
  [22:14:27.212] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1b02d38>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.225] Packages needed by the future expression (n = 0): <none>
  [22:14:27.230] Packages needed by future strategies (n = 0): <none>
  [22:14:27.234] {
  [22:14:27.234]     {
  [22:14:27.234]         ...future.startTime <- Sys.time()
  [22:14:27.234]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.234]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.234]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.234]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.234]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.234]         {
  [22:14:27.234]             {
  [22:14:27.234]                 {
  [22:14:27.234]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.234]                   version <- if (has_future) 
  [22:14:27.234]                     packageVersion("future")
  [22:14:27.234]                   else NULL
  [22:14:27.234]                   if (!has_future || version < "1.8.0") {
  [22:14:27.234]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.234]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.234]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.234]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.234]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.234]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.234]                     info <- paste(info, collapse = "; ")
  [22:14:27.234]                     if (!has_future) {
  [22:14:27.234]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.234]                         info)
  [22:14:27.234]                     }
  [22:14:27.234]                     else {
  [22:14:27.234]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.234]                         info, version)
  [22:14:27.234]                     }
  [22:14:27.234]                     stop(msg)
  [22:14:27.234]                   }
  [22:14:27.234]                 }
  [22:14:27.234]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.234]                 options(mc.cores = 1L)
  [22:14:27.234]             }
  [22:14:27.234]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.234]         }
  [22:14:27.234]     }
  [22:14:27.234]     if (is.na(TRUE)) {
  [22:14:27.234]     }
  [22:14:27.234]     else {
  [22:14:27.234]         if (TRUE) {
  [22:14:27.234]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.234]         }
  [22:14:27.234]         else {
  [22:14:27.234]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.234]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.234]         }
  [22:14:27.234]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.234]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.234]             sink(type = "output", split = FALSE)
  [22:14:27.234]             close(...future.stdout)
  [22:14:27.234]         }, add = TRUE)
  [22:14:27.234]     }
  [22:14:27.234]     ...future.frame <- sys.nframe()
  [22:14:27.234]     ...future.conditions <- list()
  [22:14:27.234]     ...future.result <- tryCatch({
  [22:14:27.234]         withCallingHandlers({
  [22:14:27.234]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.234]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.234]                 version = "1.8")
  [22:14:27.234]         }, condition = local({
  [22:14:27.234]             inherits <- base::inherits
  [22:14:27.234]             invokeRestart <- base::invokeRestart
  [22:14:27.234]             length <- base::length
  [22:14:27.234]             seq.int <- base::seq.int
  [22:14:27.234]             sys.calls <- base::sys.calls
  [22:14:27.234]             `[[` <- base::`[[`
  [22:14:27.234]             `+` <- base::`+`
  [22:14:27.234]             `<<-` <- base::`<<-`
  [22:14:27.234]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.234]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.234]                   3L)]
  [22:14:27.234]             }
  [22:14:27.234]             function(cond) {
  [22:14:27.234]                 if (inherits(cond, "error")) {
  [22:14:27.234]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.234]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.234]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.234]                     signaled = 0L)
  [22:14:27.234]                   signalCondition(cond)
  [22:14:27.234]                 }
  [22:14:27.234]                 else if (inherits(cond, "condition")) {
  [22:14:27.234]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.234]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.234]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.234]                   if (inherits(cond, "message")) {
  [22:14:27.234]                     if (!signal) 
  [22:14:27.234]                       invokeRestart("muffleMessage")
  [22:14:27.234]                   }
  [22:14:27.234]                   else if (inherits(cond, "warning")) {
  [22:14:27.234]                     if (!signal) 
  [22:14:27.234]                       invokeRestart("muffleWarning")
  [22:14:27.234]                   }
  [22:14:27.234]                   else {
  [22:14:27.234]                     if (!signal) {
  [22:14:27.234]                       restarts <- computeRestarts(cond)
  [22:14:27.234]                       for (restart in restarts) {
  [22:14:27.234]                         name <- restart$name
  [22:14:27.234]                         if (is.null(name)) 
  [22:14:27.234]                           next
  [22:14:27.234]                         if (!grepl("^muffle", name)) 
  [22:14:27.234]                           next
  [22:14:27.234]                         invokeRestart(restart)
  [22:14:27.234]                         break
  [22:14:27.234]                       }
  [22:14:27.234]                     }
  [22:14:27.234]                   }
  [22:14:27.234]                 }
  [22:14:27.234]             }
  [22:14:27.234]         }))
  [22:14:27.234]     }, error = function(ex) {
  [22:14:27.234]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.234]             version = "1.8"), class = "FutureResult")
  [22:14:27.234]     }, finally = {
  [22:14:27.234]         {
  [22:14:27.234]             {
  [22:14:27.234]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.234]             }
  [22:14:27.234]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.234]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.234]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.234]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.234]                 ...) 
  [22:14:27.234]             {
  [22:14:27.234]                 if (substitute) 
  [22:14:27.234]                   expr <- substitute(expr)
  [22:14:27.234]                 if (is.function(workers)) 
  [22:14:27.234]                   workers <- workers()
  [22:14:27.234]                 workers <- as.integer(workers)
  [22:14:27.234]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.234]                   workers >= 1)
  [22:14:27.234]                 if (workers == 1L) {
  [22:14:27.234]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.234]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.234]                     local = TRUE, label = label, ...))
  [22:14:27.234]                 }
  [22:14:27.234]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.234]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.234]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.234]                   globals = globals, persistent = persistent, 
  [22:14:27.234]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.234]                   label = label, ...)
  [22:14:27.234]                 if (!future$lazy) 
  [22:14:27.234]                   future <- run(future)
  [22:14:27.234]                 invisible(future)
  [22:14:27.234]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.234]         }
  [22:14:27.234]         options(...future.oldOptions)
  [22:14:27.234]     })
  [22:14:27.234]     if (is.na(TRUE)) {
  [22:14:27.234]     }
  [22:14:27.234]     else {
  [22:14:27.234]         sink(type = "output", split = FALSE)
  [22:14:27.234]         if (TRUE) {
  [22:14:27.234]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.234]         }
  [22:14:27.234]         else {
  [22:14:27.234]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.234]         }
  [22:14:27.234]         close(...future.stdout)
  [22:14:27.234]         ...future.stdout <- NULL
  [22:14:27.234]     }
  [22:14:27.234]     ...future.result$conditions <- ...future.conditions
  [22:14:27.234]     ...future.result
  [22:14:27.234] }
  [22:14:27.238] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:27.238] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:27.239] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:27.240] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:27.240] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:27.241] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.242] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.242] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:27.243] MultisessionFuture started
  [22:14:27.243] result() for ClusterFuture ...
  [22:14:27.244] - Validating connection of MultisessionFuture
  [22:14:27.290] - class(result): FutureResult
  [22:14:27.291] result() for ClusterFuture ...
  [22:14:27.291] - result already collected: FutureResult
  [22:14:27.291] result() for ClusterFuture ... done
  [22:14:27.291] result() for ClusterFuture ... done
  [22:14:27.292] result() for ClusterFuture ...
  [22:14:27.292] - result already collected: FutureResult
  [22:14:27.292] result() for ClusterFuture ... done
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:27.297] futureCall() ...
  [22:14:27.298] Globals to be used in the future:
  [22:14:27.298] List of 3
  [22:14:27.298]  $ a   : num 3
  [22:14:27.298]  $ FUN :function (x, y)  
  [22:14:27.298]  $ args:List of 2
  [22:14:27.298]   ..$ x: num 42
  [22:14:27.298]   ..$ y: num 12
  [22:14:27.298]  - attr(*, "where")=List of 3
  [22:14:27.298]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:27.298]   ..$ FUN :<environment: 0x1df1f78> 
  [22:14:27.298]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:27.298]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.298]  - attr(*, "resolved")= logi FALSE
  [22:14:27.298]  - attr(*, "total_size")= num NA
  [22:14:27.323] getGlobalsAndPackages() ...
  [22:14:27.323] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:27.324] Resolving globals: FALSE
  [22:14:27.325] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:27.325] - globals: [3] 'a', 'FUN', 'args'
  [22:14:27.325] 
  [22:14:27.326] getGlobalsAndPackages() ... DONE
  [22:14:27.326] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1e56238>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.330] Packages needed by the future expression (n = 0): <none>
  [22:14:27.330] Packages needed by future strategies (n = 0): <none>
  [22:14:27.334] {
  [22:14:27.334]     {
  [22:14:27.334]         ...future.startTime <- Sys.time()
  [22:14:27.334]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.334]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.334]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.334]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.334]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.334]         {
  [22:14:27.334]             {
  [22:14:27.334]                 {
  [22:14:27.334]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.334]                   version <- if (has_future) 
  [22:14:27.334]                     packageVersion("future")
  [22:14:27.334]                   else NULL
  [22:14:27.334]                   if (!has_future || version < "1.8.0") {
  [22:14:27.334]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.334]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.334]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.334]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.334]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.334]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.334]                     info <- paste(info, collapse = "; ")
  [22:14:27.334]                     if (!has_future) {
  [22:14:27.334]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.334]                         info)
  [22:14:27.334]                     }
  [22:14:27.334]                     else {
  [22:14:27.334]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.334]                         info, version)
  [22:14:27.334]                     }
  [22:14:27.334]                     stop(msg)
  [22:14:27.334]                   }
  [22:14:27.334]                 }
  [22:14:27.334]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.334]                 options(mc.cores = 1L)
  [22:14:27.334]             }
  [22:14:27.334]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.334]         }
  [22:14:27.334]     }
  [22:14:27.334]     if (is.na(TRUE)) {
  [22:14:27.334]     }
  [22:14:27.334]     else {
  [22:14:27.334]         if (TRUE) {
  [22:14:27.334]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.334]         }
  [22:14:27.334]         else {
  [22:14:27.334]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.334]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.334]         }
  [22:14:27.334]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.334]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.334]             sink(type = "output", split = FALSE)
  [22:14:27.334]             close(...future.stdout)
  [22:14:27.334]         }, add = TRUE)
  [22:14:27.334]     }
  [22:14:27.334]     ...future.frame <- sys.nframe()
  [22:14:27.334]     ...future.conditions <- list()
  [22:14:27.334]     ...future.result <- tryCatch({
  [22:14:27.334]         withCallingHandlers({
  [22:14:27.334]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.334]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.334]                 version = "1.8")
  [22:14:27.334]         }, condition = local({
  [22:14:27.334]             inherits <- base::inherits
  [22:14:27.334]             invokeRestart <- base::invokeRestart
  [22:14:27.334]             length <- base::length
  [22:14:27.334]             seq.int <- base::seq.int
  [22:14:27.334]             sys.calls <- base::sys.calls
  [22:14:27.334]             `[[` <- base::`[[`
  [22:14:27.334]             `+` <- base::`+`
  [22:14:27.334]             `<<-` <- base::`<<-`
  [22:14:27.334]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.334]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.334]                   3L)]
  [22:14:27.334]             }
  [22:14:27.334]             function(cond) {
  [22:14:27.334]                 if (inherits(cond, "error")) {
  [22:14:27.334]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.334]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.334]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.334]                     signaled = 0L)
  [22:14:27.334]                   signalCondition(cond)
  [22:14:27.334]                 }
  [22:14:27.334]                 else if (inherits(cond, "condition")) {
  [22:14:27.334]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.334]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.334]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.334]                   if (inherits(cond, "message")) {
  [22:14:27.334]                     if (!signal) 
  [22:14:27.334]                       invokeRestart("muffleMessage")
  [22:14:27.334]                   }
  [22:14:27.334]                   else if (inherits(cond, "warning")) {
  [22:14:27.334]                     if (!signal) 
  [22:14:27.334]                       invokeRestart("muffleWarning")
  [22:14:27.334]                   }
  [22:14:27.334]                   else {
  [22:14:27.334]                     if (!signal) {
  [22:14:27.334]                       restarts <- computeRestarts(cond)
  [22:14:27.334]                       for (restart in restarts) {
  [22:14:27.334]                         name <- restart$name
  [22:14:27.334]                         if (is.null(name)) 
  [22:14:27.334]                           next
  [22:14:27.334]                         if (!grepl("^muffle", name)) 
  [22:14:27.334]                           next
  [22:14:27.334]                         invokeRestart(restart)
  [22:14:27.334]                         break
  [22:14:27.334]                       }
  [22:14:27.334]                     }
  [22:14:27.334]                   }
  [22:14:27.334]                 }
  [22:14:27.334]             }
  [22:14:27.334]         }))
  [22:14:27.334]     }, error = function(ex) {
  [22:14:27.334]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.334]             version = "1.8"), class = "FutureResult")
  [22:14:27.334]     }, finally = {
  [22:14:27.334]         {
  [22:14:27.334]             {
  [22:14:27.334]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.334]             }
  [22:14:27.334]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.334]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.334]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.334]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.334]                 ...) 
  [22:14:27.334]             {
  [22:14:27.334]                 if (substitute) 
  [22:14:27.334]                   expr <- substitute(expr)
  [22:14:27.334]                 if (is.function(workers)) 
  [22:14:27.334]                   workers <- workers()
  [22:14:27.334]                 workers <- as.integer(workers)
  [22:14:27.334]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.334]                   workers >= 1)
  [22:14:27.334]                 if (workers == 1L) {
  [22:14:27.334]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.334]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.334]                     local = TRUE, label = label, ...))
  [22:14:27.334]                 }
  [22:14:27.334]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.334]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.334]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.334]                   globals = globals, persistent = persistent, 
  [22:14:27.334]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.334]                   label = label, ...)
  [22:14:27.334]                 if (!future$lazy) 
  [22:14:27.334]                   future <- run(future)
  [22:14:27.334]                 invisible(future)
  [22:14:27.334]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.334]         }
  [22:14:27.334]         options(...future.oldOptions)
  [22:14:27.334]     })
  [22:14:27.334]     if (is.na(TRUE)) {
  [22:14:27.334]     }
  [22:14:27.334]     else {
  [22:14:27.334]         sink(type = "output", split = FALSE)
  [22:14:27.334]         if (TRUE) {
  [22:14:27.334]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.334]         }
  [22:14:27.334]         else {
  [22:14:27.334]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.334]         }
  [22:14:27.334]         close(...future.stdout)
  [22:14:27.334]         ...future.stdout <- NULL
  [22:14:27.334]     }
  [22:14:27.334]     ...future.result$conditions <- ...future.conditions
  [22:14:27.334]     ...future.result
  [22:14:27.334] }
  [22:14:27.342] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:27.342] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:27.343] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:27.344] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:27.344] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:27.345] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.346] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.346] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:27.347] MultisessionFuture started
  [22:14:27.347] result() for ClusterFuture ...
  [22:14:27.348] - Validating connection of MultisessionFuture
  [22:14:27.394] - class(result): FutureResult
  [22:14:27.395] result() for ClusterFuture ...
  [22:14:27.395] - result already collected: FutureResult
  [22:14:27.395] result() for ClusterFuture ... done
  [22:14:27.396] result() for ClusterFuture ... done
  [22:14:27.396] result() for ClusterFuture ...
  [22:14:27.396] - result already collected: FutureResult
  [22:14:27.397] result() for ClusterFuture ... done
  List of 4
   $ globals: logi FALSE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Warning in rm(list = c("v1", "v2", "v3")) : object 'v1' not found
  [22:14:27.408] futureCall() ...
  [22:14:27.408] Finding globals ...
  [22:14:27.408] getGlobalsAndPackages() ...
  [22:14:27.409] Searching for globals...
  [22:14:27.413] - globals found: [7] 'do.call', 'FUN', 'args', '*', 'a', '(', '-'
  [22:14:27.414] Searching for globals ... DONE
  [22:14:27.414] Resolving globals: FALSE
  [22:14:27.416] The total size of the 3 globals is 2.53 KiB (2592 bytes)
  [22:14:27.416] - globals: [3] 'FUN', 'args', 'a'
  [22:14:27.416] 
  [22:14:27.417] getGlobalsAndPackages() ... DONE
  [22:14:27.417]  - globals found: [3] 'FUN', 'args', 'a'
  [22:14:27.417] 
  [22:14:27.418] Finding globals ... DONE
  [22:14:27.418] Globals to be used in the future:
  [22:14:27.418] List of 3
  [22:14:27.418]  $ FUN :function (x, y)  
  [22:14:27.418]  $ args:List of 2
  [22:14:27.418]   ..$ x: num 42
  [22:14:27.418]   ..$ y: num 12
  [22:14:27.418]  $ a   : num 3
  [22:14:27.418]  - attr(*, "where")=List of 3
  [22:14:27.418]   ..$ FUN :<environment: 0x140f3e0> 
  [22:14:27.418]   ..$ args:<environment: 0x1d97638> 
  [22:14:27.418]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:27.418]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.418]  - attr(*, "resolved")= logi FALSE
  [22:14:27.418]  - attr(*, "total_size")= num 2592
  [22:14:27.439] getGlobalsAndPackages() ...
  [22:14:27.440] - globals passed as-is: [3] 'FUN', 'args', 'a'
  [22:14:27.440] Resolving globals: FALSE
  [22:14:27.441] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:27.442] - globals: [3] 'FUN', 'args', 'a'
  [22:14:27.442] 
  [22:14:27.442] getGlobalsAndPackages() ... DONE
  [22:14:27.443] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x1d97638>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.447] Packages needed by the future expression (n = 0): <none>
  [22:14:27.447] Packages needed by future strategies (n = 0): <none>
  [22:14:27.452] {
  [22:14:27.452]     {
  [22:14:27.452]         ...future.startTime <- Sys.time()
  [22:14:27.452]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.452]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.452]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.452]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.452]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.452]         {
  [22:14:27.452]             {
  [22:14:27.452]                 {
  [22:14:27.452]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.452]                   version <- if (has_future) 
  [22:14:27.452]                     packageVersion("future")
  [22:14:27.452]                   else NULL
  [22:14:27.452]                   if (!has_future || version < "1.8.0") {
  [22:14:27.452]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.452]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.452]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.452]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.452]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.452]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.452]                     info <- paste(info, collapse = "; ")
  [22:14:27.452]                     if (!has_future) {
  [22:14:27.452]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.452]                         info)
  [22:14:27.452]                     }
  [22:14:27.452]                     else {
  [22:14:27.452]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.452]                         info, version)
  [22:14:27.452]                     }
  [22:14:27.452]                     stop(msg)
  [22:14:27.452]                   }
  [22:14:27.452]                 }
  [22:14:27.452]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.452]                 options(mc.cores = 1L)
  [22:14:27.452]             }
  [22:14:27.452]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.452]         }
  [22:14:27.452]     }
  [22:14:27.452]     if (is.na(TRUE)) {
  [22:14:27.452]     }
  [22:14:27.452]     else {
  [22:14:27.452]         if (TRUE) {
  [22:14:27.452]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.452]         }
  [22:14:27.452]         else {
  [22:14:27.452]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.452]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.452]         }
  [22:14:27.452]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.452]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.452]             sink(type = "output", split = FALSE)
  [22:14:27.452]             close(...future.stdout)
  [22:14:27.452]         }, add = TRUE)
  [22:14:27.452]     }
  [22:14:27.452]     ...future.frame <- sys.nframe()
  [22:14:27.452]     ...future.conditions <- list()
  [22:14:27.452]     ...future.result <- tryCatch({
  [22:14:27.452]         withCallingHandlers({
  [22:14:27.452]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.452]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.452]                 version = "1.8")
  [22:14:27.452]         }, condition = local({
  [22:14:27.452]             inherits <- base::inherits
  [22:14:27.452]             invokeRestart <- base::invokeRestart
  [22:14:27.452]             length <- base::length
  [22:14:27.452]             seq.int <- base::seq.int
  [22:14:27.452]             sys.calls <- base::sys.calls
  [22:14:27.452]             `[[` <- base::`[[`
  [22:14:27.452]             `+` <- base::`+`
  [22:14:27.452]             `<<-` <- base::`<<-`
  [22:14:27.452]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.452]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.452]                   3L)]
  [22:14:27.452]             }
  [22:14:27.452]             function(cond) {
  [22:14:27.452]                 if (inherits(cond, "error")) {
  [22:14:27.452]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.452]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.452]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.452]                     signaled = 0L)
  [22:14:27.452]                   signalCondition(cond)
  [22:14:27.452]                 }
  [22:14:27.452]                 else if (inherits(cond, "condition")) {
  [22:14:27.452]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.452]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.452]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.452]                   if (inherits(cond, "message")) {
  [22:14:27.452]                     if (!signal) 
  [22:14:27.452]                       invokeRestart("muffleMessage")
  [22:14:27.452]                   }
  [22:14:27.452]                   else if (inherits(cond, "warning")) {
  [22:14:27.452]                     if (!signal) 
  [22:14:27.452]                       invokeRestart("muffleWarning")
  [22:14:27.452]                   }
  [22:14:27.452]                   else {
  [22:14:27.452]                     if (!signal) {
  [22:14:27.452]                       restarts <- computeRestarts(cond)
  [22:14:27.452]                       for (restart in restarts) {
  [22:14:27.452]                         name <- restart$name
  [22:14:27.452]                         if (is.null(name)) 
  [22:14:27.452]                           next
  [22:14:27.452]                         if (!grepl("^muffle", name)) 
  [22:14:27.452]                           next
  [22:14:27.452]                         invokeRestart(restart)
  [22:14:27.452]                         break
  [22:14:27.452]                       }
  [22:14:27.452]                     }
  [22:14:27.452]                   }
  [22:14:27.452]                 }
  [22:14:27.452]             }
  [22:14:27.452]         }))
  [22:14:27.452]     }, error = function(ex) {
  [22:14:27.452]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.452]             version = "1.8"), class = "FutureResult")
  [22:14:27.452]     }, finally = {
  [22:14:27.452]         {
  [22:14:27.452]             {
  [22:14:27.452]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.452]             }
  [22:14:27.452]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.452]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.452]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.452]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.452]                 ...) 
  [22:14:27.452]             {
  [22:14:27.452]                 if (substitute) 
  [22:14:27.452]                   expr <- substitute(expr)
  [22:14:27.452]                 if (is.function(workers)) 
  [22:14:27.452]                   workers <- workers()
  [22:14:27.452]                 workers <- as.integer(workers)
  [22:14:27.452]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.452]                   workers >= 1)
  [22:14:27.452]                 if (workers == 1L) {
  [22:14:27.452]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.452]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.452]                     local = TRUE, label = label, ...))
  [22:14:27.452]                 }
  [22:14:27.452]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.452]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.452]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.452]                   globals = globals, persistent = persistent, 
  [22:14:27.452]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.452]                   label = label, ...)
  [22:14:27.452]                 if (!future$lazy) 
  [22:14:27.452]                   future <- run(future)
  [22:14:27.452]                 invisible(future)
  [22:14:27.452]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.452]         }
  [22:14:27.452]         options(...future.oldOptions)
  [22:14:27.452]     })
  [22:14:27.452]     if (is.na(TRUE)) {
  [22:14:27.452]     }
  [22:14:27.452]     else {
  [22:14:27.452]         sink(type = "output", split = FALSE)
  [22:14:27.452]         if (TRUE) {
  [22:14:27.452]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.452]         }
  [22:14:27.452]         else {
  [22:14:27.452]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.452]         }
  [22:14:27.452]         close(...future.stdout)
  [22:14:27.452]         ...future.stdout <- NULL
  [22:14:27.452]     }
  [22:14:27.452]     ...future.result$conditions <- ...future.conditions
  [22:14:27.452]     ...future.result
  [22:14:27.452] }
  [22:14:27.457] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:27.458] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:27.459] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:27.460] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.461] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.461] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:27.462] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:27.463] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:27.464] MultisessionFuture started
  [22:14:27.464] result() for ClusterFuture ...
  [22:14:27.464] - Validating connection of MultisessionFuture
  [22:14:27.510] - class(result): FutureResult
  [22:14:27.511] result() for ClusterFuture ...
  [22:14:27.511] - result already collected: FutureResult
  [22:14:27.511] result() for ClusterFuture ... done
  [22:14:27.512] result() for ClusterFuture ... done
  [22:14:27.512] result() for ClusterFuture ...
  [22:14:27.512] - result already collected: FutureResult
  [22:14:27.512] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v1     : num 90
  [22:14:27.523] futureCall() ...
  [22:14:27.524] Globals to be used in the future:
  [22:14:27.524] List of 3
  [22:14:27.524]  $ a   : num 3
  [22:14:27.524]  $ FUN :function (x, y)  
  [22:14:27.524]  $ args:List of 2
  [22:14:27.524]   ..$ x: num 42
  [22:14:27.524]   ..$ y: num 12
  [22:14:27.524]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.524]  - attr(*, "where")=List of 3
  [22:14:27.524]   ..$ a   :<environment: R_GlobalEnv> 
  [22:14:27.524]   ..$ FUN :<environment: 0x2d61de8> 
  [22:14:27.524]   ..$ args:<environment: 0x2d8b9d0> 
  [22:14:27.524]  - attr(*, "resolved")= logi FALSE
  [22:14:27.524]  - attr(*, "total_size")= num NA
  [22:14:27.545] getGlobalsAndPackages() ...
  [22:14:27.545] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:27.546] Resolving globals: FALSE
  [22:14:27.547] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:27.547] - globals: [3] 'a', 'FUN', 'args'
  [22:14:27.548] 
  [22:14:27.548] getGlobalsAndPackages() ... DONE
  [22:14:27.549] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2d8b9d0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.552] Packages needed by the future expression (n = 0): <none>
  [22:14:27.553] Packages needed by future strategies (n = 0): <none>
  [22:14:27.557] {
  [22:14:27.557]     {
  [22:14:27.557]         ...future.startTime <- Sys.time()
  [22:14:27.557]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.557]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.557]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.557]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.557]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.557]         {
  [22:14:27.557]             {
  [22:14:27.557]                 {
  [22:14:27.557]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.557]                   version <- if (has_future) 
  [22:14:27.557]                     packageVersion("future")
  [22:14:27.557]                   else NULL
  [22:14:27.557]                   if (!has_future || version < "1.8.0") {
  [22:14:27.557]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.557]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.557]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.557]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.557]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.557]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.557]                     info <- paste(info, collapse = "; ")
  [22:14:27.557]                     if (!has_future) {
  [22:14:27.557]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.557]                         info)
  [22:14:27.557]                     }
  [22:14:27.557]                     else {
  [22:14:27.557]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.557]                         info, version)
  [22:14:27.557]                     }
  [22:14:27.557]                     stop(msg)
  [22:14:27.557]                   }
  [22:14:27.557]                 }
  [22:14:27.557]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.557]                 options(mc.cores = 1L)
  [22:14:27.557]             }
  [22:14:27.557]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.557]         }
  [22:14:27.557]     }
  [22:14:27.557]     if (is.na(TRUE)) {
  [22:14:27.557]     }
  [22:14:27.557]     else {
  [22:14:27.557]         if (TRUE) {
  [22:14:27.557]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.557]         }
  [22:14:27.557]         else {
  [22:14:27.557]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.557]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.557]         }
  [22:14:27.557]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.557]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.557]             sink(type = "output", split = FALSE)
  [22:14:27.557]             close(...future.stdout)
  [22:14:27.557]         }, add = TRUE)
  [22:14:27.557]     }
  [22:14:27.557]     ...future.frame <- sys.nframe()
  [22:14:27.557]     ...future.conditions <- list()
  [22:14:27.557]     ...future.result <- tryCatch({
  [22:14:27.557]         withCallingHandlers({
  [22:14:27.557]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.557]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.557]                 version = "1.8")
  [22:14:27.557]         }, condition = local({
  [22:14:27.557]             inherits <- base::inherits
  [22:14:27.557]             invokeRestart <- base::invokeRestart
  [22:14:27.557]             length <- base::length
  [22:14:27.557]             seq.int <- base::seq.int
  [22:14:27.557]             sys.calls <- base::sys.calls
  [22:14:27.557]             `[[` <- base::`[[`
  [22:14:27.557]             `+` <- base::`+`
  [22:14:27.557]             `<<-` <- base::`<<-`
  [22:14:27.557]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.557]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.557]                   3L)]
  [22:14:27.557]             }
  [22:14:27.557]             function(cond) {
  [22:14:27.557]                 if (inherits(cond, "error")) {
  [22:14:27.557]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.557]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.557]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.557]                     signaled = 0L)
  [22:14:27.557]                   signalCondition(cond)
  [22:14:27.557]                 }
  [22:14:27.557]                 else if (inherits(cond, "condition")) {
  [22:14:27.557]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.557]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.557]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.557]                   if (inherits(cond, "message")) {
  [22:14:27.557]                     if (!signal) 
  [22:14:27.557]                       invokeRestart("muffleMessage")
  [22:14:27.557]                   }
  [22:14:27.557]                   else if (inherits(cond, "warning")) {
  [22:14:27.557]                     if (!signal) 
  [22:14:27.557]                       invokeRestart("muffleWarning")
  [22:14:27.557]                   }
  [22:14:27.557]                   else {
  [22:14:27.557]                     if (!signal) {
  [22:14:27.557]                       restarts <- computeRestarts(cond)
  [22:14:27.557]                       for (restart in restarts) {
  [22:14:27.557]                         name <- restart$name
  [22:14:27.557]                         if (is.null(name)) 
  [22:14:27.557]                           next
  [22:14:27.557]                         if (!grepl("^muffle", name)) 
  [22:14:27.557]                           next
  [22:14:27.557]                         invokeRestart(restart)
  [22:14:27.557]                         break
  [22:14:27.557]                       }
  [22:14:27.557]                     }
  [22:14:27.557]                   }
  [22:14:27.557]                 }
  [22:14:27.557]             }
  [22:14:27.557]         }))
  [22:14:27.557]     }, error = function(ex) {
  [22:14:27.557]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.557]             version = "1.8"), class = "FutureResult")
  [22:14:27.557]     }, finally = {
  [22:14:27.557]         {
  [22:14:27.557]             {
  [22:14:27.557]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.557]             }
  [22:14:27.557]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.557]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.557]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.557]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.557]                 ...) 
  [22:14:27.557]             {
  [22:14:27.557]                 if (substitute) 
  [22:14:27.557]                   expr <- substitute(expr)
  [22:14:27.557]                 if (is.function(workers)) 
  [22:14:27.557]                   workers <- workers()
  [22:14:27.557]                 workers <- as.integer(workers)
  [22:14:27.557]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.557]                   workers >= 1)
  [22:14:27.557]                 if (workers == 1L) {
  [22:14:27.557]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.557]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.557]                     local = TRUE, label = label, ...))
  [22:14:27.557]                 }
  [22:14:27.557]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.557]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.557]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.557]                   globals = globals, persistent = persistent, 
  [22:14:27.557]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.557]                   label = label, ...)
  [22:14:27.557]                 if (!future$lazy) 
  [22:14:27.557]                   future <- run(future)
  [22:14:27.557]                 invisible(future)
  [22:14:27.557]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.557]         }
  [22:14:27.557]         options(...future.oldOptions)
  [22:14:27.557]     })
  [22:14:27.557]     if (is.na(TRUE)) {
  [22:14:27.557]     }
  [22:14:27.557]     else {
  [22:14:27.557]         sink(type = "output", split = FALSE)
  [22:14:27.557]         if (TRUE) {
  [22:14:27.557]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.557]         }
  [22:14:27.557]         else {
  [22:14:27.557]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.557]         }
  [22:14:27.557]         close(...future.stdout)
  [22:14:27.557]         ...future.stdout <- NULL
  [22:14:27.557]     }
  [22:14:27.557]     ...future.result$conditions <- ...future.conditions
  [22:14:27.557]     ...future.result
  [22:14:27.557] }
  [22:14:27.561] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:27.562] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:27.563] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:27.563] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:27.564] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:27.565] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.566] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.566] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:27.567] MultisessionFuture started
  [22:14:27.567] result() for ClusterFuture ...
  [22:14:27.567] - Validating connection of MultisessionFuture
  [22:14:27.645] - class(result): FutureResult
  [22:14:27.646] result() for ClusterFuture ...
  [22:14:27.646] - result already collected: FutureResult
  [22:14:27.646] result() for ClusterFuture ... done
  [22:14:27.646] result() for ClusterFuture ... done
  [22:14:27.647] result() for ClusterFuture ...
  [22:14:27.647] - result already collected: FutureResult
  [22:14:27.647] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v2     : num 90
  [22:14:27.652] futureCall() ...
  [22:14:27.653] Globals to be used in the future:
  [22:14:27.653] List of 3
  [22:14:27.653]  $ a   : num 3
  [22:14:27.653]  $ FUN :function (x, y)  
  [22:14:27.653]  $ args:List of 2
  [22:14:27.653]   ..$ x: num 42
  [22:14:27.653]   ..$ y: num 12
  [22:14:27.653]  - attr(*, "where")=List of 3
  [22:14:27.653]   ..$ a   :<environment: R_EmptyEnv> 
  [22:14:27.653]   ..$ FUN :<environment: 0x2a25548> 
  [22:14:27.653]   ..$ args:<environment: R_EmptyEnv> 
  [22:14:27.653]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:14:27.653]  - attr(*, "resolved")= logi FALSE
  [22:14:27.653]  - attr(*, "total_size")= num NA
  [22:14:27.680] getGlobalsAndPackages() ...
  [22:14:27.680] - globals passed as-is: [3] 'a', 'FUN', 'args'
  [22:14:27.681] Resolving globals: FALSE
  [22:14:27.682] The total size of the 3 globals is 1.31 KiB (1344 bytes)
  [22:14:27.682] - globals: [3] 'a', 'FUN', 'args'
  [22:14:27.683] 
  [22:14:27.683] getGlobalsAndPackages() ... DONE
  [22:14:27.684] futureCall() ... DONE
  MultisessionFuture:
  Label: '<none>'
  Expression:
  do.call(what = FUN, args = args)
  Lazy evaluation: TRUE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: 0x2a06030>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 1972f0c5-86a2-4cc9-0f20-ff0ecaec2427
  Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [22:14:27.688] Packages needed by the future expression (n = 0): <none>
  [22:14:27.688] Packages needed by future strategies (n = 0): <none>
  [22:14:27.693] {
  [22:14:27.693]     {
  [22:14:27.693]         ...future.startTime <- Sys.time()
  [22:14:27.693]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [22:14:27.693]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:14:27.693]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:14:27.693]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:14:27.693]             future.resolve.recursive = NULL, width = 80L)
  [22:14:27.693]         {
  [22:14:27.693]             {
  [22:14:27.693]                 {
  [22:14:27.693]                   has_future <- requireNamespace("future", quietly = TRUE)
  [22:14:27.693]                   version <- if (has_future) 
  [22:14:27.693]                     packageVersion("future")
  [22:14:27.693]                   else NULL
  [22:14:27.693]                   if (!has_future || version < "1.8.0") {
  [22:14:27.693]                     info <- c(r_version = gsub("R version ", 
  [22:14:27.693]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [22:14:27.693]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [22:14:27.693]                       os = paste(Sys.info()[c("sysname", "release", 
  [22:14:27.693]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [22:14:27.693]                     info <- sprintf("%s: %s", names(info), info)
  [22:14:27.693]                     info <- paste(info, collapse = "; ")
  [22:14:27.693]                     if (!has_future) {
  [22:14:27.693]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [22:14:27.693]                         info)
  [22:14:27.693]                     }
  [22:14:27.693]                     else {
  [22:14:27.693]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:14:27.693]                         info, version)
  [22:14:27.693]                     }
  [22:14:27.693]                     stop(msg)
  [22:14:27.693]                   }
  [22:14:27.693]                 }
  [22:14:27.693]                 ...future.mc.cores.old <- getOption("mc.cores")
  [22:14:27.693]                 options(mc.cores = 1L)
  [22:14:27.693]             }
  [22:14:27.693]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:14:27.693]         }
  [22:14:27.693]     }
  [22:14:27.693]     if (is.na(TRUE)) {
  [22:14:27.693]     }
  [22:14:27.693]     else {
  [22:14:27.693]         if (TRUE) {
  [22:14:27.693]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [22:14:27.693]         }
  [22:14:27.693]         else {
  [22:14:27.693]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [22:14:27.693]                 windows = "NUL", "/dev/null"), open = "w")
  [22:14:27.693]         }
  [22:14:27.693]         sink(...future.stdout, type = "output", split = FALSE)
  [22:14:27.693]         on.exit(if (!is.null(...future.stdout)) {
  [22:14:27.693]             sink(type = "output", split = FALSE)
  [22:14:27.693]             close(...future.stdout)
  [22:14:27.693]         }, add = TRUE)
  [22:14:27.693]     }
  [22:14:27.693]     ...future.frame <- sys.nframe()
  [22:14:27.693]     ...future.conditions <- list()
  [22:14:27.693]     ...future.result <- tryCatch({
  [22:14:27.693]         withCallingHandlers({
  [22:14:27.693]             ...future.value <- local(do.call(what = FUN, args = args))
  [22:14:27.693]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [22:14:27.693]                 version = "1.8")
  [22:14:27.693]         }, condition = local({
  [22:14:27.693]             inherits <- base::inherits
  [22:14:27.693]             invokeRestart <- base::invokeRestart
  [22:14:27.693]             length <- base::length
  [22:14:27.693]             seq.int <- base::seq.int
  [22:14:27.693]             sys.calls <- base::sys.calls
  [22:14:27.693]             `[[` <- base::`[[`
  [22:14:27.693]             `+` <- base::`+`
  [22:14:27.693]             `<<-` <- base::`<<-`
  [22:14:27.693]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:14:27.693]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:14:27.693]                   3L)]
  [22:14:27.693]             }
  [22:14:27.693]             function(cond) {
  [22:14:27.693]                 if (inherits(cond, "error")) {
  [22:14:27.693]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.693]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:14:27.693]                     cond$call), timestamp = base::Sys.time(), 
  [22:14:27.693]                     signaled = 0L)
  [22:14:27.693]                   signalCondition(cond)
  [22:14:27.693]                 }
  [22:14:27.693]                 else if (inherits(cond, "condition")) {
  [22:14:27.693]                   signal <- FALSE && inherits(cond, character(0))
  [22:14:27.693]                   ...future.conditions[[length(...future.conditions) + 
  [22:14:27.693]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [22:14:27.693]                   if (inherits(cond, "message")) {
  [22:14:27.693]                     if (!signal) 
  [22:14:27.693]                       invokeRestart("muffleMessage")
  [22:14:27.693]                   }
  [22:14:27.693]                   else if (inherits(cond, "warning")) {
  [22:14:27.693]                     if (!signal) 
  [22:14:27.693]                       invokeRestart("muffleWarning")
  [22:14:27.693]                   }
  [22:14:27.693]                   else {
  [22:14:27.693]                     if (!signal) {
  [22:14:27.693]                       restarts <- computeRestarts(cond)
  [22:14:27.693]                       for (restart in restarts) {
  [22:14:27.693]                         name <- restart$name
  [22:14:27.693]                         if (is.null(name)) 
  [22:14:27.693]                           next
  [22:14:27.693]                         if (!grepl("^muffle", name)) 
  [22:14:27.693]                           next
  [22:14:27.693]                         invokeRestart(restart)
  [22:14:27.693]                         break
  [22:14:27.693]                       }
  [22:14:27.693]                     }
  [22:14:27.693]                   }
  [22:14:27.693]                 }
  [22:14:27.693]             }
  [22:14:27.693]         }))
  [22:14:27.693]     }, error = function(ex) {
  [22:14:27.693]         structure(list(value = NULL, conditions = ...future.conditions, 
  [22:14:27.693]             version = "1.8"), class = "FutureResult")
  [22:14:27.693]     }, finally = {
  [22:14:27.693]         {
  [22:14:27.693]             {
  [22:14:27.693]                 options(mc.cores = ...future.mc.cores.old)
  [22:14:27.693]             }
  [22:14:27.693]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:14:27.693]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:14:27.693]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:14:27.693]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:14:27.693]                 ...) 
  [22:14:27.693]             {
  [22:14:27.693]                 if (substitute) 
  [22:14:27.693]                   expr <- substitute(expr)
  [22:14:27.693]                 if (is.function(workers)) 
  [22:14:27.693]                   workers <- workers()
  [22:14:27.693]                 workers <- as.integer(workers)
  [22:14:27.693]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:14:27.693]                   workers >= 1)
  [22:14:27.693]                 if (workers == 1L) {
  [22:14:27.693]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:14:27.693]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:14:27.693]                     local = TRUE, label = label, ...))
  [22:14:27.693]                 }
  [22:14:27.693]                 workers <- ClusterRegistry("start", workers = workers)
  [22:14:27.693]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:14:27.693]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:14:27.693]                   globals = globals, persistent = persistent, 
  [22:14:27.693]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:14:27.693]                   label = label, ...)
  [22:14:27.693]                 if (!future$lazy) 
  [22:14:27.693]                   future <- run(future)
  [22:14:27.693]                 invisible(future)
  [22:14:27.693]             }), .cleanup = FALSE, .init = FALSE)
  [22:14:27.693]         }
  [22:14:27.693]         options(...future.oldOptions)
  [22:14:27.693]     })
  [22:14:27.693]     if (is.na(TRUE)) {
  [22:14:27.693]     }
  [22:14:27.693]     else {
  [22:14:27.693]         sink(type = "output", split = FALSE)
  [22:14:27.693]         if (TRUE) {
  [22:14:27.693]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [22:14:27.693]         }
  [22:14:27.693]         else {
  [22:14:27.693]             ...future.result["stdout"] <- list(NULL)
  [22:14:27.693]         }
  [22:14:27.693]         close(...future.stdout)
  [22:14:27.693]         ...future.stdout <- NULL
  [22:14:27.693]     }
  [22:14:27.693]     ...future.result$conditions <- ...future.conditions
  [22:14:27.693]     ...future.result
  [22:14:27.693] }
  [22:14:27.711] Exporting 3 global objects (1.31 KiB) to cluster node #1 ...
  [22:14:27.711] Exporting 'a' (56 bytes) to cluster node #1 ...
  [22:14:27.713] Exporting 'a' (56 bytes) to cluster node #1 ... DONE
  [22:14:27.713] Exporting 'FUN' (1.15 KiB) to cluster node #1 ...
  [22:14:27.714] Exporting 'FUN' (1.15 KiB) to cluster node #1 ... DONE
  [22:14:27.715] Exporting 'args' (112 bytes) to cluster node #1 ...
  [22:14:27.716] Exporting 'args' (112 bytes) to cluster node #1 ... DONE
  [22:14:27.716] Exporting 3 global objects (1.31 KiB) to cluster node #1 ... DONE
  [22:14:27.717] MultisessionFuture started
  [22:14:27.718] result() for ClusterFuture ...
  [22:14:27.718] - Validating connection of MultisessionFuture
  [22:14:27.763] - class(result): FutureResult
  [22:14:27.764] result() for ClusterFuture ...
  [22:14:27.764] - result already collected: FutureResult
  [22:14:27.764] result() for ClusterFuture ... done
  [22:14:27.765] result() for ClusterFuture ... done
  [22:14:27.765] result() for ClusterFuture ...
  [22:14:27.765] - result already collected: FutureResult
  [22:14:27.766] result() for ClusterFuture ... done
  List of 4
   $ globals: logi TRUE
   $ lazy   : logi TRUE
   $ v0     : num 90
   $ v3     : num 90
  Testing with 2 cores ... DONE
  > 
  > message("- futureCall() - mix of strategies, cores, lazy and globals ... DONE")
  - futureCall() - mix of strategies, cores, lazy and globals ... DONE
  > 
  > message("- futureCall() - bug fixes")
  - futureCall() - bug fixes
  > 
  > plan(sequential)
  [22:14:27.772] plan(): Setting new future strategy stack:
  [22:14:27.773] List of future strategies:
  [22:14:27.773] 1. sequential:
  [22:14:27.773]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:14:27.773]    - tweaked: FALSE
  [22:14:27.773]    - call: plan(sequential)
  [22:14:27.780] plan(): nbrOfWorkers() = 1
  > plan(cluster, workers = 1L)
  [22:14:27.781] plan(): Setting new future strategy stack:
  [22:14:27.781] List of future strategies:
  [22:14:27.781] 1. cluster:
  [22:14:27.781]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = 1L, user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:27.781]    - tweaked: TRUE
  [22:14:27.781]    - call: plan(cluster, workers = 1L)
  [22:14:27.782] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ...
  [22:14:27.782] cluster:
  [22:14:27.782] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = 1L, user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:14:27.782] - tweaked: TRUE
  [22:14:27.782] - call: plan(cluster, workers = 1L)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 11663
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c89857effd.pid"), silent = TRUE)' -e "file.exists('/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c89857effd.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureCall.R:gimli:hornik:23689' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c89857effd.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11663 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 11663 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11663 cannot be opened
  Killing worker process (PID 6689) if still alive
  [22:14:29.927] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(23689, signal = 0L)
  [1] TRUE
  Call: tools::pskill(23689, signal = 0L)
  [1] TRUE
  [22:14:29.928] - success
  [22:14:29.928] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 6689) 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 11663 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 11663 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureCall.R:gimli:hornik:23689' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpTzkSU6/working_dir/RtmpVqhkCA/future.parent=23689.5c89857effd.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11663 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 6689) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted