CRAN Package Check Results for Maintainer ‘Henrik Bengtsson <henrikb at braju.com>’

Last updated on 2019-09-15 15:47:52 CEST.

Package FAIL ERROR NOTE OK
ACNE 1 11
aroma.affymetrix 1 6 5
aroma.apd 1 11
aroma.cn 1 1 10
aroma.core 1 11
calmate 1 11
dChipIO 12
doFuture 12
future 2 10
future.apply 12
future.BatchJobs 4 8
future.batchtools 4 8
future.callr 12
globals 12
listenv 12
matrixStats 7 5
profmem 12
PSCBS 1 11
R.cache 12
R.devices 1 1 4 6
R.filesets 12
R.huge 12
R.matlab 12
R.methodsS3 12
R.oo 12
R.rsp 1 4 7
R.utils 12
startup 12

Package ACNE

Current CRAN status: ERROR: 1, OK: 11

Version: 0.8.1
Check: package dependencies
Result: ERROR
    Packages required but not available: 'aroma.affymetrix', 'aroma.core'
    
    Package suggested but not available for checking: ‘DNAcopy’
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-release-osx-x86_64

Package aroma.affymetrix

Current CRAN status: ERROR: 1, NOTE: 6, OK: 5

Version: 3.2.0
Check: installed package size
Result: NOTE
     installed size is 5.8Mb
     sub-directories of 1Mb or more:
     R 2.3Mb
     help 1.1Mb
     testScripts 1.3Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-ix86+x86_64, r-patched-solaris-x86, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: ERROR
    Package required but not available: ‘aroma.core’
    
    Packages suggested but not available for checking:
     'Biobase', 'BiocGenerics', 'affxparser', 'affy', 'affyPLM',
     'aroma.light', 'gcrma', 'limma', 'oligo', 'oligoClasses',
     'pdInfoBuilder', 'preprocessCore', 'AffymetrixDataTestFiles'
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-release-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘AffymetrixDataTestFiles’
Flavor: r-oldrel-osx-x86_64

Package aroma.apd

Current CRAN status: NOTE: 1, OK: 11

Version: 0.6.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘affxparser’
Flavor: r-release-osx-x86_64

Version: 0.6.0
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘affxparser’
Flavor: r-release-osx-x86_64

Package aroma.cn

Current CRAN status: ERROR: 1, NOTE: 1, OK: 10

Version: 1.6.1
Check: package dependencies
Result: ERROR
    Packages required but not available: 'aroma.core', 'PSCBS'
    
    Packages suggested but not available for checking:
     'aroma.light', 'DNAcopy', 'GLAD'
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-release-osx-x86_64

Version: 1.6.1
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘GLAD’
Flavor: r-oldrel-osx-x86_64

Package aroma.core

Current CRAN status: ERROR: 1, NOTE: 11

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-patched-linux-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64

Version: 3.2.0
Check: package dependencies
Result: ERROR
    Package required but not available: ‘PSCBS’
    
    Packages suggested but not available for checking:
     'EBImage', 'preprocessCore', 'aroma.light', 'DNAcopy', 'GLAD',
     'sfit', 'expectile', 'HaarSeg', 'mpcbs'
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-release-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit' 'expectile' 'HaarSeg' 'mpcbs'
Flavor: r-oldrel-windows-ix86+x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     ‘GLAD’ ‘sfit’ ‘expectile’ ‘HaarSeg’ ‘mpcbs’
Flavor: r-oldrel-osx-x86_64

Version: 3.2.0
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘GLAD’
Flavor: r-oldrel-osx-x86_64

Package calmate

Current CRAN status: ERROR: 1, OK: 11

Version: 0.12.1
Check: package dependencies
Result: ERROR
    Package required but not available: ‘aroma.core’
    
    Package suggested but not available for checking: ‘DNAcopy’
    
    See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
    manual.
Flavor: r-release-osx-x86_64

Package dChipIO

Current CRAN status: OK: 12

Package doFuture

Current CRAN status: OK: 12

Package future

Current CRAN status: ERROR: 2, OK: 10

Version: 1.14.0
Check: tests
Result: ERROR
     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] getGlobalsAn