Running ‘000.sessionDetails.R’ [10s/28s]
  Running ‘ClusterRegistry.R’ [4s/156s]
  Running ‘Future-class.R’ [2s/64s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘as.cluster.R’ [2s/49s]
  Running ‘availableCores.R’
  Running ‘availableWorkers.R’
  Running ‘backtrace.R’
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [2s/118s]
  Running ‘constant.R’
  Running ‘demo.R’ [12s/76s]
  Running ‘dotdotdot.R’ [2s/125s]
  Running ‘early-signaling.R’ [3s/158s]
  Running ‘future,labels.R’
  Running ‘future.R’
  Running ‘futureAssign.R’ [2s/126s]
  Running ‘futureAssign_OP.R’ [4s/71s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [6s/88s]
  Running ‘futureOf.R’
  Running ‘futureOf_with_environment.R’
  Running ‘futureOf_with_listenv.R’
  Running ‘futures.R’ [25s/486s]
  Running ‘globals,NSE.R’
  Running ‘globals,formulas.R’ [5s/68s]
  Running ‘globals,manual.R’
  Running ‘globals,resolve.R’ [2s/48s]
  Running ‘globals,subassignment.R’ [4s/54s]
  Running ‘globals,toolarge.R’ [2s/52s]
  Running ‘globals,tricky.R’ [9s/76s]
  Running ‘globals,tricky_recursive.R’
  Running ‘globalsOf,tweaks.R’
  Running ‘immediateCondition.R’
  Running ‘invalid-owner.R’ [2s/60s]
  Running ‘makeClusterPSOCK.R’ [1s/21s]
  Running ‘mandelbrot.R’
  Running ‘mpi.R’
  Running ‘multicore,multithreading.R’
  Running ‘multicore.R’
  Running ‘multiprocess.R’
  Running ‘multisession.R’ [5s/127s]
  Running ‘nbrOfWorkers.R’ [6s/143s]
  Running ‘nested_futures,mc.cores.R’ [7s/211s]
  Running ‘nested_futures.R’
  Running ‘non-exportable,connections.R’ [2s/33s]
  Running ‘objectSize.R’
  Running ‘plan.R’ [9s/23s]
  Running ‘relaying.R’
  Running ‘remote.R’ [2s/24s]
  Running ‘requestCore.R’
  Running ‘requestNode.R’ [2s/32s]
  Running ‘reserved-keyword-functions.R’
  Running ‘resolve.R’
  Running ‘resolved-non-blocking-test.R’ [3s/65s]
  Running ‘rng.R’ [12s/25s]
  Running ‘sequential.R’
  Running ‘sessionDetails.R’
  Running ‘startup.R’ [2s/23s]
  Running ‘stdout.R’ [2s/13s]
  Running ‘transparent.R’
  Running ‘tweak.R’
  Running ‘utils.R’
  Running ‘uuid.R’
  Running ‘whichIndex.R’
Running the tests in ‘tests/cluster.R’ failed.
Complete output:
  > source("incl/start.R")
  [10:38:06.646] plan(): Setting new future strategy stack:
  [10:38:06.652] List of future strategies:
  [10:38:06.652] 1. sequential:
  [10:38:06.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:38:06.652]    - tweaked: FALSE
  [10:38:06.652]    - call: future::plan("sequential")
  [10:38:06.655] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > options(future.debug = FALSE)
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: '/data/gannet/ripley/R/packages/tests-clang/future.Rcheck', '/data/gannet/ripley/R/test-clang', '/data/gannet/ripley/R/R-clang/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: '/data/gannet/ripley/R/packages/tests-clang/future.Rcheck/future'
  > 
  > types <- "PSOCK"
  > 
  > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  > if (isWin32) types <- NULL
  > 
  > if (supportsMulticore() && !on_solaris) types <- c(types, "FORK")
  > 
  > ## WORKAROUND: covr::package_coverage() -> merge_coverage() -> ... produces
  > ## "Error in readRDS(x) : error reading from connection" for type = "FORK".
  > ## Is this related to mcparallel() comments in help("package_coverage")?
  > ## /HB 2017-05-20
  > if (covr_testing) types <- setdiff(types, "FORK")
  > 
  > pid <- Sys.getpid()
  > message("Main PID (original): ", pid)
  Main PID (original): 43968
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   for (cores in 1:availCores) {
  +     message(sprintf("Testing with %d cores on type = %s ...",
  +                     cores, sQuote(type)))
  +     options(mc.cores = cores)
  +   
  +     ## Set up a cluster with <cores> nodes (explicitly)
  +     cl <- parallel::makeCluster(cores, type = type, timeout = 60)
  +     print(cl)
  +     
  +     plan(cluster, workers = cl)
  +   
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  + 
  + 
  +     ## Set up a cluster with <cores> nodes (implicitly)
  +     plan(cluster, workers = cores)
  +   
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  +   
  +   
  +     ## A global variable
  +     a <- 0
  +     f <- try(future({
  +       b <- 3
  +       c <- 2
  +       a * b * c
  +     }))
  +     print(f)
  +   
  +   
  +     ## A cluster future is evaluated in a separate
  +     ## R session process.  Changing the value of a global
  +     ## variable should not affect the result of the
  +     ## future.
  +     a <- 7  ## Make sure globals are frozen
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == 0)
  +   
  +   
  +     message("*** cluster() with globals and blocking")
  +     x <- listenv()
  +     for (ii in 1:3) {
  +       message(sprintf(" - Creating cluster future #%d ...", ii))
  +       x[[ii]] <- future({ ii })
  +     }
  +     message(sprintf(" - Resolving %d cluster futures", length(x)))
  +     v <- sapply(x, FUN = value)
  +     stopifnot(all(v == 1:3))
  +   
  +   
  +     message("*** cluster() and errors")
  +     f <- future({
  +       stop("Whoops!")
  +       1
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "simpleError"))
  +   
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Error is repeated
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Custom error class
  +     f <- future({
  +       stop(structure(list(message = "boom"),
  +                      class = c("MyError", "error", "condition")))
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "error"), inherits(v, "MyError"))
  +   
  +     ## Make sure error is signaled
  +     res <- tryCatch(value(f), error = identity)
  +     stopifnot(inherits(res, "error"), inherits(res, "MyError"))    
  +   
  +     message("*** cluster() - too large globals ...")
  +     ooptsT <- options(future.globals.maxSize = object.size(1:1014))
  +   
  +     limit <- getOption("future.globals.maxSize")
  +     cat(sprintf("Max total size of globals: %g bytes\n", limit))
  +   
  +     ## A large object
  +     a <- 1:1014
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     f <- future({ sum(a) })
  +     print(f)
  +     rm(list = "a")
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == yTruth)
  +   
  +   
  +     ## A too large object
  +     a <- 1:1015
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     res <- tryCatch(f <- future({ sum(a) }), error = identity)
  +     rm(list = "a")
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Undo options changed in this test
  +     options(ooptsT)
  +   
  +     message("*** cluster() - too large globals ... DONE")
  +   
  +     message("*** cluster() - installed libraries ...")
  +     f <- try(cluster({
  +       list(
  +         libPaths = .libPaths()
  +       )
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(paste(capture.output(str(v)), collapse = "\n"))
  +     message("*** cluster() - installed packages ... DONE")
  +   
  +   
  +     message("*** cluster() - assert covr workaround ...")
  +     f <- try(cluster({
  +       future:::hpaste(1:100)
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(v)
  +     stopifnot(v == hpaste(1:100))
  +     message("*** cluster() - assert covr workaround ... DONE")
  +   
  +     message(sprintf("Testing with %d cores on type = %s ... DONE",
  +                     cores, sQuote(type)))
  +   } ## for (cores ...)
  + 
  +   message("*** cluster() - exceptions ...")
  +   
  +   res <- tryCatch(cluster(42L, workers = NA), error = identity)
  +   print(res)
  +   stopifnot(inherits(res, "error"))
  +   
  +   message("*** cluster() - exceptions ... DONE")
  + 
  +   message("*** cluster() - assert registry behavior ...")
  +   
  +   ## Explicitly created clusters are *not* added to the registry
  +   cl <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   ## ... and therefore changing plans shouldn't change anything
  +   plan(sequential)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   message("*** cluster() - assert registry behavior ... DONE")
  + 
  +   ## Sanity checks
  +   pid2 <- Sys.getpid()
  +   message("Main PID (original): ", pid)
  +   message("Main PID: ", pid2)
  +   stopifnot(pid2 == pid)
  + 
  +   ## Cleanup
  +   print(cl)
  +   str(cl)
  +   parallel::stopCluster(cl)
  +   plan(sequential)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  +   f1 <- future(1)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  + 
  +   message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
  + } ## for (type ...)
  Test set #1 with cluster type 'PSOCK' ...
  Testing with 1 cores on type = 'PSOCK' ...
  socket cluster with 1 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 08333391-f30f-2519-79ff-f3ec15830e24
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  Error in unserialize(node$con) : error reading from connection
  [1] "Error in unserialize(node$con) : error reading from connection\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in unserialize(node$con): error reading from connection>
  Error: inherits(f, "ClusterFuture") is not TRUE
  Execution halted
Running the tests in ‘tests/dotdotdot.R’ failed.
Complete output:
  > source("incl/start.R")
  [10:41:23.375] plan(): Setting new future strategy stack:
  [10:41:23.376] List of future strategies:
  [10:41:23.376] 1. sequential:
  [10:41:23.376]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.376]    - tweaked: FALSE
  [10:41:23.376]    - call: future::plan("sequential")
  [10:41:23.388] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > 
  > 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)
  + 
  +   message("*** Global argument '...' ...")
  + 
  +   sum_fcns <- list()
  + 
  +   sum_fcns$A <- function(x, ...) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, ...) }
  +     y
  +   }
  + 
  + 
  +   sum_fcns$B <- function(x, ...) {
  +     sumt <- function(x) {
  +       message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +       y %<-% { sum(x, ...) }
  +       y
  +     }
  +     sumt(x)
  +   }
  + 
  +   sum_fcns$C <- function(x, y) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, y) }
  +     y
  +   }
  + 
  +   sum_fcns$D <- function(x, y) {
  +     message("Arguments '...' exists: ", exists("...", inherits = TRUE))
  +     y %<-% { sum(x, y, ...) }
  +     y
  +   }
  + 
  + 
  +   for (strategy in supportedStrategies(cores)) {
  +     message(sprintf("- plan('%s') ...", strategy))
  +     plan(strategy, substitute = FALSE)
  + 
  +     for (name in names(sum_fcns)) {
  +       message(sprintf("** Sum function '%s' with plan('%s') ...", name, strategy))
  +       sum_fcn <- sum_fcns[[name]]
  +       print(sum_fcn)
  +       y <- try(sum_fcn(1:2, 3))
  +       print(y)
  +       if (name %in% c("D")) {
  +         stopifnot(inherits(y, "try-error"))
  +       } else {
  +         stopifnot(y == 6)
  +       }
  +     }
  +   }
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  *** Global argument '...' ...
  - plan('sequential') ...
  [10:41:23.782] plan(): Setting new future strategy stack:
  [10:41:23.782] List of future strategies:
  [10:41:23.782] 1. sequential:
  [10:41:23.782]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.782]    - tweaked: FALSE
  [10:41:23.782]    - call: plan(strategy, substitute = FALSE)
  [10:41:23.830] plan(): nbrOfWorkers() = 1
  ** Sum function 'A' with plan('sequential') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x3aea988>
  Arguments '...' exists: TRUE
  [10:41:23.836] getGlobalsAndPackages() ...
  [10:41:23.837] Searching for globals...
  [10:41:23.868] - globals found: [4] '{', 'sum', 'x', '...'
  [10:41:23.869] Searching for globals ... DONE
  [10:41:23.870] Resolving globals: FALSE
  [10:41:23.870] Tweak future expression to call with '...' arguments ...
  [10:41:23.871] Tweak future expression to call with '...' arguments ... DONE
  [10:41:23.874] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:23.875] - globals: [2] 'x', 'future.call.arguments'
  [10:41:23.876] 
  [10:41:23.876] getGlobalsAndPackages() ... DONE
  [10:41:23.881] Packages needed by the future expression (n = 0): <none>
  [10:41:23.881] Packages needed by future strategies (n = 0): <none>
  [10:41:23.889] {
  [10:41:23.889]     {
  [10:41:23.889]         ...future.startTime <- base::Sys.time()
  [10:41:23.889]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:23.889]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:23.889]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [10:41:23.889]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:23.889]             future.resolve.recursive = NULL, width = 80L)
  [10:41:23.889]         {
  [10:41:23.889]             {
  [10:41:23.889]                 has_future <- base::requireNamespace("future", 
  [10:41:23.889]                   quietly = TRUE)
  [10:41:23.889]                 version <- if (has_future) 
  [10:41:23.889]                   utils::packageVersion("future")
  [10:41:23.889]                 else NULL
  [10:41:23.889]                 if (!has_future || version < "1.8.0") {
  [10:41:23.889]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:41:23.889]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:23.889]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:23.889]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:23.889]                       "release", "version")], collapse = " "), 
  [10:41:23.889]                     hostname = base::Sys.info()[["nodename"]])
  [10:41:23.889]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:23.889]                     info)
  [10:41:23.889]                   info <- base::paste(info, collapse = "; ")
  [10:41:23.889]                   if (!has_future) {
  [10:41:23.889]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:23.889]                       info)
  [10:41:23.889]                   }
  [10:41:23.889]                   else {
  [10:41:23.889]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:23.889]                       info, version)
  [10:41:23.889]                   }
  [10:41:23.889]                   base::stop(msg)
  [10:41:23.889]                 }
  [10:41:23.889]             }
  [10:41:23.889]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:23.889]         }
  [10:41:23.889]     }
  [10:41:23.889]     if (base::is.na(TRUE)) {
  [10:41:23.889]     }
  [10:41:23.889]     else {
  [10:41:23.889]         if (TRUE) {
  [10:41:23.889]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:23.889]                 open = "w")
  [10:41:23.889]         }
  [10:41:23.889]         else {
  [10:41:23.889]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:23.889]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:23.889]         }
  [10:41:23.889]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:23.889]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:23.889]             base::sink(type = "output", split = FALSE)
  [10:41:23.889]             base::close(...future.stdout)
  [10:41:23.889]         }, add = TRUE)
  [10:41:23.889]     }
  [10:41:23.889]     ...future.frame <- base::sys.nframe()
  [10:41:23.889]     ...future.conditions <- base::list()
  [10:41:23.889]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:23.889]     ...future.result <- base::tryCatch({
  [10:41:23.889]         base::withCallingHandlers({
  [10:41:23.889]             ...future.value <- base::withVisible(base::local({
  [10:41:23.889]                 sum(x, ...)
  [10:41:23.889]             }))
  [10:41:23.889]             future::FutureResult(value = ...future.value$value, 
  [10:41:23.889]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.889]                   ...future.rng), started = ...future.startTime, 
  [10:41:23.889]                 version = "1.8")
  [10:41:23.889]         }, condition = base::local({
  [10:41:23.889]             c <- base::c
  [10:41:23.889]             inherits <- base::inherits
  [10:41:23.889]             invokeRestart <- base::invokeRestart
  [10:41:23.889]             length <- base::length
  [10:41:23.889]             list <- base::list
  [10:41:23.889]             seq.int <- base::seq.int
  [10:41:23.889]             signalCondition <- base::signalCondition
  [10:41:23.889]             sys.calls <- base::sys.calls
  [10:41:23.889]             Sys.time <- base::Sys.time
  [10:41:23.889]             `[[` <- base::`[[`
  [10:41:23.889]             `+` <- base::`+`
  [10:41:23.889]             `<<-` <- base::`<<-`
  [10:41:23.889]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:23.889]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:23.889]                   3L)]
  [10:41:23.889]             }
  [10:41:23.889]             function(cond) {
  [10:41:23.889]                 if (inherits(cond, "error")) {
  [10:41:23.889]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.889]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:23.889]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:23.889]                   signalCondition(cond)
  [10:41:23.889]                 }
  [10:41:23.889]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:41:23.889]                 ))) {
  [10:41:23.889]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:41:23.889]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.889]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:23.889]                   if (!signal) {
  [10:41:23.889]                     muffleCondition <- function (cond) 
  [10:41:23.889]                     {
  [10:41:23.889]                       inherits <- base::inherits
  [10:41:23.889]                       invokeRestart <- base::invokeRestart
  [10:41:23.889]                       muffled <- FALSE
  [10:41:23.889]                       if (inherits(cond, "message")) {
  [10:41:23.889]                         invokeRestart("muffleMessage")
  [10:41:23.889]                         muffled <- TRUE
  [10:41:23.889]                       }
  [10:41:23.889]                       else if (inherits(cond, "warning")) {
  [10:41:23.889]                         invokeRestart("muffleWarning")
  [10:41:23.889]                         muffled <- TRUE
  [10:41:23.889]                       }
  [10:41:23.889]                       else if (inherits(cond, "condition")) {
  [10:41:23.889]                         computeRestarts <- base::computeRestarts
  [10:41:23.889]                         grepl <- base::grepl
  [10:41:23.889]                         is.null <- base::is.null
  [10:41:23.889]                         restarts <- computeRestarts(cond)
  [10:41:23.889]                         for (restart in restarts) {
  [10:41:23.889]                           name <- restart$name
  [10:41:23.889]                           if (is.null(name)) 
  [10:41:23.889]                             next
  [10:41:23.889]                           if (!grepl("^muffle", name)) 
  [10:41:23.889]                             next
  [10:41:23.889]                           invokeRestart(restart)
  [10:41:23.889]                           muffled <- TRUE
  [10:41:23.889]                           break
  [10:41:23.889]                         }
  [10:41:23.889]                       }
  [10:41:23.889]                       invisible(muffled)
  [10:41:23.889]                     }
  [10:41:23.889]                     muffleCondition(cond)
  [10:41:23.889]                   }
  [10:41:23.889]                 }
  [10:41:23.889]             }
  [10:41:23.889]         }))
  [10:41:23.889]     }, error = function(ex) {
  [10:41:23.889]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:23.889]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.889]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:23.889]     }, finally = {
  [10:41:23.889]         {
  [10:41:23.889]             NULL
  [10:41:23.889]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:23.889]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:23.889]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:41:23.889]                 label = NULL, ...) 
  [10:41:23.889]             {
  [10:41:23.889]                 if (substitute) 
  [10:41:23.889]                   expr <- substitute(expr)
  [10:41:23.889]                 local <- as.logical(local)
  [10:41:23.889]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:41:23.889]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:23.889]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:41:23.889]                   label = label, ...)
  [10:41:23.889]                 if (!future$lazy) 
  [10:41:23.889]                   future <- run(future)
  [10:41:23.889]                 invisible(future)
  [10:41:23.889]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:23.889]         }
  [10:41:23.889]         base::options(...future.oldOptions)
  [10:41:23.889]     })
  [10:41:23.889]     Sys.time
  [10:41:23.889]     if (base::is.na(TRUE)) {
  [10:41:23.889]     }
  [10:41:23.889]     else {
  [10:41:23.889]         base::sink(type = "output", split = FALSE)
  [10:41:23.889]         if (TRUE) {
  [10:41:23.889]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:23.889]         }
  [10:41:23.889]         else {
  [10:41:23.889]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:23.889]         }
  [10:41:23.889]         base::close(...future.stdout)
  [10:41:23.889]         ...future.stdout <- NULL
  [10:41:23.889]     }
  [10:41:23.889]     ...future.result$conditions <- ...future.conditions
  [10:41:23.889]     ...future.result
  [10:41:23.889] }
  [10:41:23.895] plan(): Setting new future strategy stack:
  [10:41:23.896] List of future strategies:
  [10:41:23.896] 1. sequential:
  [10:41:23.896]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.896]    - tweaked: FALSE
  [10:41:23.896]    - call: NULL
  [10:41:23.897] plan(): nbrOfWorkers() = 1
  [10:41:23.899] plan(): Setting new future strategy stack:
  [10:41:23.900] List of future strategies:
  [10:41:23.900] 1. sequential:
  [10:41:23.900]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.900]    - tweaked: FALSE
  [10:41:23.900]    - call: plan(strategy, substitute = FALSE)
  [10:41:23.901] plan(): nbrOfWorkers() = 1
  [10:41:23.902] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'B' with plan('sequential') ...
  function (x, ...) 
  {
      sumt <- function(x) {
          message("Arguments '...' exists: ", exists("...", inherits = TRUE))
          y %<-% {
              sum(x, ...)
          }
          y
      }
      sumt(x)
  }
  <bytecode: 0x251fb28>
  Arguments '...' exists: TRUE
  [10:41:23.906] getGlobalsAndPackages() ...
  [10:41:23.906] Searching for globals...
  [10:41:23.924] - globals found: [4] '{', 'sum', 'x', '...'
  [10:41:23.924] Searching for globals ... DONE
  [10:41:23.925] Resolving globals: FALSE
  [10:41:23.925] Tweak future expression to call with '...' arguments ...
  [10:41:23.926] Tweak future expression to call with '...' arguments ... DONE
  [10:41:23.928] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:23.929] - globals: [2] 'x', 'future.call.arguments'
  [10:41:23.929] 
  [10:41:23.930] getGlobalsAndPackages() ... DONE
  [10:41:23.932] Packages needed by the future expression (n = 0): <none>
  [10:41:23.933] Packages needed by future strategies (n = 0): <none>
  [10:41:23.939] {
  [10:41:23.939]     {
  [10:41:23.939]         ...future.startTime <- base::Sys.time()
  [10:41:23.939]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:23.939]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:23.939]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:41:23.939]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:23.939]             future.resolve.recursive = NULL, width = 80L)
  [10:41:23.939]         {
  [10:41:23.939]             {
  [10:41:23.939]                 has_future <- base::requireNamespace("future", 
  [10:41:23.939]                   quietly = TRUE)
  [10:41:23.939]                 version <- if (has_future) 
  [10:41:23.939]                   utils::packageVersion("future")
  [10:41:23.939]                 else NULL
  [10:41:23.939]                 if (!has_future || version < "1.8.0") {
  [10:41:23.939]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:41:23.939]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:23.939]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:23.939]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:23.939]                       "release", "version")], collapse = " "), 
  [10:41:23.939]                     hostname = base::Sys.info()[["nodename"]])
  [10:41:23.939]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:23.939]                     info)
  [10:41:23.939]                   info <- base::paste(info, collapse = "; ")
  [10:41:23.939]                   if (!has_future) {
  [10:41:23.939]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:23.939]                       info)
  [10:41:23.939]                   }
  [10:41:23.939]                   else {
  [10:41:23.939]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:23.939]                       info, version)
  [10:41:23.939]                   }
  [10:41:23.939]                   base::stop(msg)
  [10:41:23.939]                 }
  [10:41:23.939]             }
  [10:41:23.939]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:23.939]         }
  [10:41:23.939]     }
  [10:41:23.939]     if (base::is.na(TRUE)) {
  [10:41:23.939]     }
  [10:41:23.939]     else {
  [10:41:23.939]         if (TRUE) {
  [10:41:23.939]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:23.939]                 open = "w")
  [10:41:23.939]         }
  [10:41:23.939]         else {
  [10:41:23.939]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:23.939]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:23.939]         }
  [10:41:23.939]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:23.939]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:23.939]             base::sink(type = "output", split = FALSE)
  [10:41:23.939]             base::close(...future.stdout)
  [10:41:23.939]         }, add = TRUE)
  [10:41:23.939]     }
  [10:41:23.939]     ...future.frame <- base::sys.nframe()
  [10:41:23.939]     ...future.conditions <- base::list()
  [10:41:23.939]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:23.939]     ...future.result <- base::tryCatch({
  [10:41:23.939]         base::withCallingHandlers({
  [10:41:23.939]             ...future.value <- base::withVisible(base::local({
  [10:41:23.939]                 sum(x, ...)
  [10:41:23.939]             }))
  [10:41:23.939]             future::FutureResult(value = ...future.value$value, 
  [10:41:23.939]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.939]                   ...future.rng), started = ...future.startTime, 
  [10:41:23.939]                 version = "1.8")
  [10:41:23.939]         }, condition = base::local({
  [10:41:23.939]             c <- base::c
  [10:41:23.939]             inherits <- base::inherits
  [10:41:23.939]             invokeRestart <- base::invokeRestart
  [10:41:23.939]             length <- base::length
  [10:41:23.939]             list <- base::list
  [10:41:23.939]             seq.int <- base::seq.int
  [10:41:23.939]             signalCondition <- base::signalCondition
  [10:41:23.939]             sys.calls <- base::sys.calls
  [10:41:23.939]             Sys.time <- base::Sys.time
  [10:41:23.939]             `[[` <- base::`[[`
  [10:41:23.939]             `+` <- base::`+`
  [10:41:23.939]             `<<-` <- base::`<<-`
  [10:41:23.939]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:23.939]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:23.939]                   3L)]
  [10:41:23.939]             }
  [10:41:23.939]             function(cond) {
  [10:41:23.939]                 if (inherits(cond, "error")) {
  [10:41:23.939]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.939]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:23.939]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:23.939]                   signalCondition(cond)
  [10:41:23.939]                 }
  [10:41:23.939]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:41:23.939]                 ))) {
  [10:41:23.939]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:41:23.939]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.939]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:23.939]                   if (!signal) {
  [10:41:23.939]                     muffleCondition <- function (cond) 
  [10:41:23.939]                     {
  [10:41:23.939]                       inherits <- base::inherits
  [10:41:23.939]                       invokeRestart <- base::invokeRestart
  [10:41:23.939]                       muffled <- FALSE
  [10:41:23.939]                       if (inherits(cond, "message")) {
  [10:41:23.939]                         invokeRestart("muffleMessage")
  [10:41:23.939]                         muffled <- TRUE
  [10:41:23.939]                       }
  [10:41:23.939]                       else if (inherits(cond, "warning")) {
  [10:41:23.939]                         invokeRestart("muffleWarning")
  [10:41:23.939]                         muffled <- TRUE
  [10:41:23.939]                       }
  [10:41:23.939]                       else if (inherits(cond, "condition")) {
  [10:41:23.939]                         computeRestarts <- base::computeRestarts
  [10:41:23.939]                         grepl <- base::grepl
  [10:41:23.939]                         is.null <- base::is.null
  [10:41:23.939]                         restarts <- computeRestarts(cond)
  [10:41:23.939]                         for (restart in restarts) {
  [10:41:23.939]                           name <- restart$name
  [10:41:23.939]                           if (is.null(name)) 
  [10:41:23.939]                             next
  [10:41:23.939]                           if (!grepl("^muffle", name)) 
  [10:41:23.939]                             next
  [10:41:23.939]                           invokeRestart(restart)
  [10:41:23.939]                           muffled <- TRUE
  [10:41:23.939]                           break
  [10:41:23.939]                         }
  [10:41:23.939]                       }
  [10:41:23.939]                       invisible(muffled)
  [10:41:23.939]                     }
  [10:41:23.939]                     muffleCondition(cond)
  [10:41:23.939]                   }
  [10:41:23.939]                 }
  [10:41:23.939]             }
  [10:41:23.939]         }))
  [10:41:23.939]     }, error = function(ex) {
  [10:41:23.939]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:23.939]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.939]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:23.939]     }, finally = {
  [10:41:23.939]         {
  [10:41:23.939]             NULL
  [10:41:23.939]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:23.939]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:23.939]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:41:23.939]                 label = NULL, ...) 
  [10:41:23.939]             {
  [10:41:23.939]                 if (substitute) 
  [10:41:23.939]                   expr <- substitute(expr)
  [10:41:23.939]                 local <- as.logical(local)
  [10:41:23.939]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:41:23.939]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:23.939]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:41:23.939]                   label = label, ...)
  [10:41:23.939]                 if (!future$lazy) 
  [10:41:23.939]                   future <- run(future)
  [10:41:23.939]                 invisible(future)
  [10:41:23.939]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:23.939]         }
  [10:41:23.939]         base::options(...future.oldOptions)
  [10:41:23.939]     })
  [10:41:23.939]     Sys.time
  [10:41:23.939]     if (base::is.na(TRUE)) {
  [10:41:23.939]     }
  [10:41:23.939]     else {
  [10:41:23.939]         base::sink(type = "output", split = FALSE)
  [10:41:23.939]         if (TRUE) {
  [10:41:23.939]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:23.939]         }
  [10:41:23.939]         else {
  [10:41:23.939]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:23.939]         }
  [10:41:23.939]         base::close(...future.stdout)
  [10:41:23.939]         ...future.stdout <- NULL
  [10:41:23.939]     }
  [10:41:23.939]     ...future.result$conditions <- ...future.conditions
  [10:41:23.939]     ...future.result
  [10:41:23.939] }
  [10:41:23.946] plan(): Setting new future strategy stack:
  [10:41:23.946] List of future strategies:
  [10:41:23.946] 1. sequential:
  [10:41:23.946]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.946]    - tweaked: FALSE
  [10:41:23.946]    - call: NULL
  [10:41:23.948] plan(): nbrOfWorkers() = 1
  [10:41:23.949] plan(): Setting new future strategy stack:
  [10:41:23.950] List of future strategies:
  [10:41:23.950] 1. sequential:
  [10:41:23.950]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.950]    - tweaked: FALSE
  [10:41:23.950]    - call: plan(strategy, substitute = FALSE)
  [10:41:23.951] plan(): nbrOfWorkers() = 1
  [10:41:23.952] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'C' with plan('sequential') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y)
      }
      y
  }
  <bytecode: 0x1cbed60>
  Arguments '...' exists: FALSE
  [10:41:23.954] getGlobalsAndPackages() ...
  [10:41:23.955] Searching for globals...
  [10:41:23.958] - globals found: [4] '{', 'sum', 'x', 'y'
  [10:41:23.959] Searching for globals ... DONE
  [10:41:23.959] Resolving globals: FALSE
  [10:41:23.961] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:23.961] - globals: [2] 'x', 'y'
  [10:41:23.962] 
  [10:41:23.962] getGlobalsAndPackages() ... DONE
  [10:41:23.965] Packages needed by the future expression (n = 0): <none>
  [10:41:23.965] Packages needed by future strategies (n = 0): <none>
  [10:41:23.972] {
  [10:41:23.972]     {
  [10:41:23.972]         ...future.startTime <- base::Sys.time()
  [10:41:23.972]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:23.972]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:23.972]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:41:23.972]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:23.972]             future.resolve.recursive = NULL, width = 80L)
  [10:41:23.972]         {
  [10:41:23.972]             {
  [10:41:23.972]                 has_future <- base::requireNamespace("future", 
  [10:41:23.972]                   quietly = TRUE)
  [10:41:23.972]                 version <- if (has_future) 
  [10:41:23.972]                   utils::packageVersion("future")
  [10:41:23.972]                 else NULL
  [10:41:23.972]                 if (!has_future || version < "1.8.0") {
  [10:41:23.972]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:41:23.972]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:23.972]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:23.972]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:23.972]                       "release", "version")], collapse = " "), 
  [10:41:23.972]                     hostname = base::Sys.info()[["nodename"]])
  [10:41:23.972]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:23.972]                     info)
  [10:41:23.972]                   info <- base::paste(info, collapse = "; ")
  [10:41:23.972]                   if (!has_future) {
  [10:41:23.972]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:23.972]                       info)
  [10:41:23.972]                   }
  [10:41:23.972]                   else {
  [10:41:23.972]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:23.972]                       info, version)
  [10:41:23.972]                   }
  [10:41:23.972]                   base::stop(msg)
  [10:41:23.972]                 }
  [10:41:23.972]             }
  [10:41:23.972]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:23.972]         }
  [10:41:23.972]     }
  [10:41:23.972]     if (base::is.na(TRUE)) {
  [10:41:23.972]     }
  [10:41:23.972]     else {
  [10:41:23.972]         if (TRUE) {
  [10:41:23.972]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:23.972]                 open = "w")
  [10:41:23.972]         }
  [10:41:23.972]         else {
  [10:41:23.972]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:23.972]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:23.972]         }
  [10:41:23.972]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:23.972]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:23.972]             base::sink(type = "output", split = FALSE)
  [10:41:23.972]             base::close(...future.stdout)
  [10:41:23.972]         }, add = TRUE)
  [10:41:23.972]     }
  [10:41:23.972]     ...future.frame <- base::sys.nframe()
  [10:41:23.972]     ...future.conditions <- base::list()
  [10:41:23.972]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:23.972]     ...future.result <- base::tryCatch({
  [10:41:23.972]         base::withCallingHandlers({
  [10:41:23.972]             ...future.value <- base::withVisible(base::local({
  [10:41:23.972]                 sum(x, y)
  [10:41:23.972]             }))
  [10:41:23.972]             future::FutureResult(value = ...future.value$value, 
  [10:41:23.972]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.972]                   ...future.rng), started = ...future.startTime, 
  [10:41:23.972]                 version = "1.8")
  [10:41:23.972]         }, condition = base::local({
  [10:41:23.972]             c <- base::c
  [10:41:23.972]             inherits <- base::inherits
  [10:41:23.972]             invokeRestart <- base::invokeRestart
  [10:41:23.972]             length <- base::length
  [10:41:23.972]             list <- base::list
  [10:41:23.972]             seq.int <- base::seq.int
  [10:41:23.972]             signalCondition <- base::signalCondition
  [10:41:23.972]             sys.calls <- base::sys.calls
  [10:41:23.972]             Sys.time <- base::Sys.time
  [10:41:23.972]             `[[` <- base::`[[`
  [10:41:23.972]             `+` <- base::`+`
  [10:41:23.972]             `<<-` <- base::`<<-`
  [10:41:23.972]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:23.972]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:23.972]                   3L)]
  [10:41:23.972]             }
  [10:41:23.972]             function(cond) {
  [10:41:23.972]                 if (inherits(cond, "error")) {
  [10:41:23.972]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.972]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:23.972]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:23.972]                   signalCondition(cond)
  [10:41:23.972]                 }
  [10:41:23.972]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:41:23.972]                 ))) {
  [10:41:23.972]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:41:23.972]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:23.972]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:23.972]                   if (!signal) {
  [10:41:23.972]                     muffleCondition <- function (cond) 
  [10:41:23.972]                     {
  [10:41:23.972]                       inherits <- base::inherits
  [10:41:23.972]                       invokeRestart <- base::invokeRestart
  [10:41:23.972]                       muffled <- FALSE
  [10:41:23.972]                       if (inherits(cond, "message")) {
  [10:41:23.972]                         invokeRestart("muffleMessage")
  [10:41:23.972]                         muffled <- TRUE
  [10:41:23.972]                       }
  [10:41:23.972]                       else if (inherits(cond, "warning")) {
  [10:41:23.972]                         invokeRestart("muffleWarning")
  [10:41:23.972]                         muffled <- TRUE
  [10:41:23.972]                       }
  [10:41:23.972]                       else if (inherits(cond, "condition")) {
  [10:41:23.972]                         computeRestarts <- base::computeRestarts
  [10:41:23.972]                         grepl <- base::grepl
  [10:41:23.972]                         is.null <- base::is.null
  [10:41:23.972]                         restarts <- computeRestarts(cond)
  [10:41:23.972]                         for (restart in restarts) {
  [10:41:23.972]                           name <- restart$name
  [10:41:23.972]                           if (is.null(name)) 
  [10:41:23.972]                             next
  [10:41:23.972]                           if (!grepl("^muffle", name)) 
  [10:41:23.972]                             next
  [10:41:23.972]                           invokeRestart(restart)
  [10:41:23.972]                           muffled <- TRUE
  [10:41:23.972]                           break
  [10:41:23.972]                         }
  [10:41:23.972]                       }
  [10:41:23.972]                       invisible(muffled)
  [10:41:23.972]                     }
  [10:41:23.972]                     muffleCondition(cond)
  [10:41:23.972]                   }
  [10:41:23.972]                 }
  [10:41:23.972]             }
  [10:41:23.972]         }))
  [10:41:23.972]     }, error = function(ex) {
  [10:41:23.972]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:23.972]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:23.972]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:23.972]     }, finally = {
  [10:41:23.972]         {
  [10:41:23.972]             NULL
  [10:41:23.972]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:23.972]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:23.972]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:41:23.972]                 label = NULL, ...) 
  [10:41:23.972]             {
  [10:41:23.972]                 if (substitute) 
  [10:41:23.972]                   expr <- substitute(expr)
  [10:41:23.972]                 local <- as.logical(local)
  [10:41:23.972]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:41:23.972]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:23.972]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:41:23.972]                   label = label, ...)
  [10:41:23.972]                 if (!future$lazy) 
  [10:41:23.972]                   future <- run(future)
  [10:41:23.972]                 invisible(future)
  [10:41:23.972]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:23.972]         }
  [10:41:23.972]         base::options(...future.oldOptions)
  [10:41:23.972]     })
  [10:41:23.972]     Sys.time
  [10:41:23.972]     if (base::is.na(TRUE)) {
  [10:41:23.972]     }
  [10:41:23.972]     else {
  [10:41:23.972]         base::sink(type = "output", split = FALSE)
  [10:41:23.972]         if (TRUE) {
  [10:41:23.972]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:23.972]         }
  [10:41:23.972]         else {
  [10:41:23.972]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:23.972]         }
  [10:41:23.972]         base::close(...future.stdout)
  [10:41:23.972]         ...future.stdout <- NULL
  [10:41:23.972]     }
  [10:41:23.972]     ...future.result$conditions <- ...future.conditions
  [10:41:23.972]     ...future.result
  [10:41:23.972] }
  [10:41:23.986] plan(): Setting new future strategy stack:
  [10:41:23.986] List of future strategies:
  [10:41:23.986] 1. sequential:
  [10:41:23.986]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.986]    - tweaked: FALSE
  [10:41:23.986]    - call: NULL
  [10:41:23.988] plan(): nbrOfWorkers() = 1
  [10:41:23.989] plan(): Setting new future strategy stack:
  [10:41:23.990] List of future strategies:
  [10:41:23.990] 1. sequential:
  [10:41:23.990]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:23.990]    - tweaked: FALSE
  [10:41:23.990]    - call: plan(strategy, substitute = FALSE)
  [10:41:23.991] plan(): nbrOfWorkers() = 1
  [10:41:23.992] SequentialFuture started (and completed)
  [1] 6
  ** Sum function 'D' with plan('sequential') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y, ...)
      }
      y
  }
  <bytecode: 0x29549d8>
  Arguments '...' exists: FALSE
  [10:41:23.994] getGlobalsAndPackages() ...
  [10:41:23.995] Searching for globals...
  [10:41:24.004] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [10:41:24.005] Searching for globals ... DONE
  [10:41:24.005] Resolving globals: FALSE
  [10:41:24.006] Tweak future expression to call with '...' arguments ...
  [10:41:24.007] Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : 
    Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  [1] "Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : \n  Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,     globals = globals): Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }>
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** Global argument '...' ...
  - plan('multicore') ...
  [10:41:24.027] plan(): Setting new future strategy stack:
  [10:41:24.028] List of future strategies:
  [10:41:24.028] 1. multicore:
  [10:41:24.028]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:41:24.028]    - tweaked: FALSE
  [10:41:24.028]    - call: plan(strategy, substitute = FALSE)
  [10:41:24.030] plan(): nbrOfWorkers() = 2
  ** Sum function 'A' with plan('multicore') ...
  function (x, ...) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, ...)
      }
      y
  }
  <bytecode: 0x3aea988>
  Arguments '...' exists: TRUE
  [10:41:24.032] getGlobalsAndPackages() ...
  [10:41:24.033] Searching for globals...
  [10:41:24.037] - globals found: [4] '{', 'sum', 'x', '...'
  [10:41:24.038] Searching for globals ... DONE
  [10:41:24.038] Resolving globals: FALSE
  [10:41:24.039] Tweak future expression to call with '...' arguments ...
  [10:41:24.039] Tweak future expression to call with '...' arguments ... DONE
  [10:41:24.041] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:24.054] - globals: [2] 'x', 'future.call.arguments'
  [10:41:24.055] 
  [10:41:24.055] getGlobalsAndPackages() ... DONE
  [10:41:24.072] Packages needed by the future expression (n = 0): <none>
  [10:41:24.073] Packages needed by future strategies (n = 0): <none>
  [10:41:24.079] {
  [10:41:24.079]     {
  [10:41:24.079]         ...future.startTime <- base::Sys.time()
  [10:41:24.079]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:24.079]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:24.079]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:41:24.079]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:24.079]             future.resolve.recursive = NULL, width = 80L)
  [10:41:24.079]         {
  [10:41:24.079]             {
  [10:41:24.079]                 {
  [10:41:24.079]                   has_future <- base::requireNamespace("future", 
  [10:41:24.079]                     quietly = TRUE)
  [10:41:24.079]                   version <- if (has_future) 
  [10:41:24.079]                     utils::packageVersion("future")
  [10:41:24.079]                   else NULL
  [10:41:24.079]                   if (!has_future || version < "1.8.0") {
  [10:41:24.079]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:41:24.079]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:24.079]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:24.079]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:24.079]                         "release", "version")], collapse = " "), 
  [10:41:24.079]                       hostname = base::Sys.info()[["nodename"]])
  [10:41:24.079]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:24.079]                       info)
  [10:41:24.079]                     info <- base::paste(info, collapse = "; ")
  [10:41:24.079]                     if (!has_future) {
  [10:41:24.079]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:24.079]                         info)
  [10:41:24.079]                     }
  [10:41:24.079]                     else {
  [10:41:24.079]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:24.079]                         info, version)
  [10:41:24.079]                     }
  [10:41:24.079]                     base::stop(msg)
  [10:41:24.079]                   }
  [10:41:24.079]                 }
  [10:41:24.079]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:41:24.079]                 base::options(mc.cores = 1L)
  [10:41:24.079]             }
  [10:41:24.079]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:24.079]         }
  [10:41:24.079]     }
  [10:41:24.079]     if (base::is.na(TRUE)) {
  [10:41:24.079]     }
  [10:41:24.079]     else {
  [10:41:24.079]         if (TRUE) {
  [10:41:24.079]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:24.079]                 open = "w")
  [10:41:24.079]         }
  [10:41:24.079]         else {
  [10:41:24.079]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:24.079]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:24.079]         }
  [10:41:24.079]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:24.079]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:24.079]             base::sink(type = "output", split = FALSE)
  [10:41:24.079]             base::close(...future.stdout)
  [10:41:24.079]         }, add = TRUE)
  [10:41:24.079]     }
  [10:41:24.079]     ...future.frame <- base::sys.nframe()
  [10:41:24.079]     ...future.conditions <- base::list()
  [10:41:24.079]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:24.079]     ...future.result <- base::tryCatch({
  [10:41:24.079]         base::withCallingHandlers({
  [10:41:24.079]             ...future.value <- base::withVisible(base::local({
  [10:41:24.079]                 sum(x, ...)
  [10:41:24.079]             }))
  [10:41:24.079]             future::FutureResult(value = ...future.value$value, 
  [10:41:24.079]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.079]                   ...future.rng), started = ...future.startTime, 
  [10:41:24.079]                 version = "1.8")
  [10:41:24.079]         }, condition = base::local({
  [10:41:24.079]             c <- base::c
  [10:41:24.079]             inherits <- base::inherits
  [10:41:24.079]             invokeRestart <- base::invokeRestart
  [10:41:24.079]             length <- base::length
  [10:41:24.079]             list <- base::list
  [10:41:24.079]             seq.int <- base::seq.int
  [10:41:24.079]             signalCondition <- base::signalCondition
  [10:41:24.079]             sys.calls <- base::sys.calls
  [10:41:24.079]             Sys.time <- base::Sys.time
  [10:41:24.079]             `[[` <- base::`[[`
  [10:41:24.079]             `+` <- base::`+`
  [10:41:24.079]             `<<-` <- base::`<<-`
  [10:41:24.079]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:24.079]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:24.079]                   3L)]
  [10:41:24.079]             }
  [10:41:24.079]             function(cond) {
  [10:41:24.079]                 if (inherits(cond, "error")) {
  [10:41:24.079]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.079]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:24.079]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:24.079]                   signalCondition(cond)
  [10:41:24.079]                 }
  [10:41:24.079]                 else if (inherits(cond, "condition")) {
  [10:41:24.079]                   signal <- FALSE && inherits(cond, character(0))
  [10:41:24.079]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.079]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:24.079]                   if (!signal) {
  [10:41:24.079]                     muffleCondition <- function (cond) 
  [10:41:24.079]                     {
  [10:41:24.079]                       inherits <- base::inherits
  [10:41:24.079]                       invokeRestart <- base::invokeRestart
  [10:41:24.079]                       muffled <- FALSE
  [10:41:24.079]                       if (inherits(cond, "message")) {
  [10:41:24.079]                         invokeRestart("muffleMessage")
  [10:41:24.079]                         muffled <- TRUE
  [10:41:24.079]                       }
  [10:41:24.079]                       else if (inherits(cond, "warning")) {
  [10:41:24.079]                         invokeRestart("muffleWarning")
  [10:41:24.079]                         muffled <- TRUE
  [10:41:24.079]                       }
  [10:41:24.079]                       else if (inherits(cond, "condition")) {
  [10:41:24.079]                         computeRestarts <- base::computeRestarts
  [10:41:24.079]                         grepl <- base::grepl
  [10:41:24.079]                         is.null <- base::is.null
  [10:41:24.079]                         restarts <- computeRestarts(cond)
  [10:41:24.079]                         for (restart in restarts) {
  [10:41:24.079]                           name <- restart$name
  [10:41:24.079]                           if (is.null(name)) 
  [10:41:24.079]                             next
  [10:41:24.079]                           if (!grepl("^muffle", name)) 
  [10:41:24.079]                             next
  [10:41:24.079]                           invokeRestart(restart)
  [10:41:24.079]                           muffled <- TRUE
  [10:41:24.079]                           break
  [10:41:24.079]                         }
  [10:41:24.079]                       }
  [10:41:24.079]                       invisible(muffled)
  [10:41:24.079]                     }
  [10:41:24.079]                     muffleCondition(cond)
  [10:41:24.079]                   }
  [10:41:24.079]                 }
  [10:41:24.079]             }
  [10:41:24.079]         }))
  [10:41:24.079]     }, error = function(ex) {
  [10:41:24.079]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:24.079]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.079]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:24.079]     }, finally = {
  [10:41:24.079]         {
  [10:41:24.079]             {
  [10:41:24.079]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:41:24.079]             }
  [10:41:24.079]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:24.079]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:24.079]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:41:24.079]                 earlySignal = FALSE, label = NULL, ...) 
  [10:41:24.079]             {
  [10:41:24.079]                 if (substitute) 
  [10:41:24.079]                   expr <- substitute(expr)
  [10:41:24.079]                 if (is.function(workers)) 
  [10:41:24.079]                   workers <- workers()
  [10:41:24.079]                 workers <- as.integer(workers)
  [10:41:24.079]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:41:24.079]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:41:24.079]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:41:24.079]                     lazy = lazy, seed = seed, globals = globals, 
  [10:41:24.079]                     local = TRUE, label = label, ...))
  [10:41:24.079]                 }
  [10:41:24.079]                 oopts <- options(mc.cores = workers)
  [10:41:24.079]                 on.exit(options(oopts))
  [10:41:24.079]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:41:24.079]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:24.079]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:41:24.079]                   label = label, ...)
  [10:41:24.079]                 if (!future$lazy) 
  [10:41:24.079]                   future <- run(future)
  [10:41:24.079]                 invisible(future)
  [10:41:24.079]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:24.079]         }
  [10:41:24.079]         base::options(...future.oldOptions)
  [10:41:24.079]     })
  [10:41:24.079]     Sys.time
  [10:41:24.079]     if (base::is.na(TRUE)) {
  [10:41:24.079]     }
  [10:41:24.079]     else {
  [10:41:24.079]         base::sink(type = "output", split = FALSE)
  [10:41:24.079]         if (TRUE) {
  [10:41:24.079]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:24.079]         }
  [10:41:24.079]         else {
  [10:41:24.079]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:24.079]         }
  [10:41:24.079]         base::close(...future.stdout)
  [10:41:24.079]         ...future.stdout <- NULL
  [10:41:24.079]     }
  [10:41:24.079]     ...future.result$conditions <- ...future.conditions
  [10:41:24.079]     ...future.result
  [10:41:24.079] }
  [10:41:24.098] requestCore(): workers = 2
  [10:41:24.104] MulticoreFuture started
  [10:41:24.139] plan(): Setting new future strategy stack:
  [10:41:24.140] List of future strategies:
  [10:41:24.140] 1. sequential:
  [10:41:24.140]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:24.140]    - tweaked: FALSE
  [10:41:24.140]    - call: NULL
  [10:41:24.142] plan(): nbrOfWorkers() = 1
  [10:41:24.158] plan(): Setting new future strategy stack:
  [10:41:24.159] List of future strategies:
  [10:41:24.159] 1. multicore:
  [10:41:24.159]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:41:24.159]    - tweaked: FALSE
  [10:41:24.159]    - call: plan(strategy, substitute = FALSE)
  [10:41:24.162] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'B' with plan('multicore') ...
  function (x, ...) 
  {
      sumt <- function(x) {
          message("Arguments '...' exists: ", exists("...", inherits = TRUE))
          y %<-% {
              sum(x, ...)
          }
          y
      }
      sumt(x)
  }
  <bytecode: 0x251fb28>
  Arguments '...' exists: TRUE
  [10:41:24.190] getGlobalsAndPackages() ...
  [10:41:24.191] Searching for globals...
  [10:41:24.196] - globals found: [4] '{', 'sum', 'x', '...'
  [10:41:24.196] Searching for globals ... DONE
  [10:41:24.197] Resolving globals: FALSE
  [10:41:24.198] Tweak future expression to call with '...' arguments ...
  [10:41:24.198] Tweak future expression to call with '...' arguments ... DONE
  [10:41:24.200] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:24.201] - globals: [2] 'x', 'future.call.arguments'
  [10:41:24.202] 
  [10:41:24.202] getGlobalsAndPackages() ... DONE
  [10:41:24.206] Packages needed by the future expression (n = 0): <none>
  [10:41:24.220] Packages needed by future strategies (n = 0): <none>
  [10:41:24.227] {
  [10:41:24.227]     {
  [10:41:24.227]         ...future.startTime <- base::Sys.time()
  [10:41:24.227]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:24.227]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:24.227]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:41:24.227]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:24.227]             future.resolve.recursive = NULL, width = 80L)
  [10:41:24.227]         {
  [10:41:24.227]             {
  [10:41:24.227]                 {
  [10:41:24.227]                   has_future <- base::requireNamespace("future", 
  [10:41:24.227]                     quietly = TRUE)
  [10:41:24.227]                   version <- if (has_future) 
  [10:41:24.227]                     utils::packageVersion("future")
  [10:41:24.227]                   else NULL
  [10:41:24.227]                   if (!has_future || version < "1.8.0") {
  [10:41:24.227]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:41:24.227]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:24.227]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:24.227]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:24.227]                         "release", "version")], collapse = " "), 
  [10:41:24.227]                       hostname = base::Sys.info()[["nodename"]])
  [10:41:24.227]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:24.227]                       info)
  [10:41:24.227]                     info <- base::paste(info, collapse = "; ")
  [10:41:24.227]                     if (!has_future) {
  [10:41:24.227]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:24.227]                         info)
  [10:41:24.227]                     }
  [10:41:24.227]                     else {
  [10:41:24.227]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:24.227]                         info, version)
  [10:41:24.227]                     }
  [10:41:24.227]                     base::stop(msg)
  [10:41:24.227]                   }
  [10:41:24.227]                 }
  [10:41:24.227]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:41:24.227]                 base::options(mc.cores = 1L)
  [10:41:24.227]             }
  [10:41:24.227]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:24.227]         }
  [10:41:24.227]     }
  [10:41:24.227]     if (base::is.na(TRUE)) {
  [10:41:24.227]     }
  [10:41:24.227]     else {
  [10:41:24.227]         if (TRUE) {
  [10:41:24.227]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:24.227]                 open = "w")
  [10:41:24.227]         }
  [10:41:24.227]         else {
  [10:41:24.227]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:24.227]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:24.227]         }
  [10:41:24.227]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:24.227]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:24.227]             base::sink(type = "output", split = FALSE)
  [10:41:24.227]             base::close(...future.stdout)
  [10:41:24.227]         }, add = TRUE)
  [10:41:24.227]     }
  [10:41:24.227]     ...future.frame <- base::sys.nframe()
  [10:41:24.227]     ...future.conditions <- base::list()
  [10:41:24.227]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:24.227]     ...future.result <- base::tryCatch({
  [10:41:24.227]         base::withCallingHandlers({
  [10:41:24.227]             ...future.value <- base::withVisible(base::local({
  [10:41:24.227]                 sum(x, ...)
  [10:41:24.227]             }))
  [10:41:24.227]             future::FutureResult(value = ...future.value$value, 
  [10:41:24.227]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.227]                   ...future.rng), started = ...future.startTime, 
  [10:41:24.227]                 version = "1.8")
  [10:41:24.227]         }, condition = base::local({
  [10:41:24.227]             c <- base::c
  [10:41:24.227]             inherits <- base::inherits
  [10:41:24.227]             invokeRestart <- base::invokeRestart
  [10:41:24.227]             length <- base::length
  [10:41:24.227]             list <- base::list
  [10:41:24.227]             seq.int <- base::seq.int
  [10:41:24.227]             signalCondition <- base::signalCondition
  [10:41:24.227]             sys.calls <- base::sys.calls
  [10:41:24.227]             Sys.time <- base::Sys.time
  [10:41:24.227]             `[[` <- base::`[[`
  [10:41:24.227]             `+` <- base::`+`
  [10:41:24.227]             `<<-` <- base::`<<-`
  [10:41:24.227]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:24.227]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:24.227]                   3L)]
  [10:41:24.227]             }
  [10:41:24.227]             function(cond) {
  [10:41:24.227]                 if (inherits(cond, "error")) {
  [10:41:24.227]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.227]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:24.227]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:24.227]                   signalCondition(cond)
  [10:41:24.227]                 }
  [10:41:24.227]                 else if (inherits(cond, "condition")) {
  [10:41:24.227]                   signal <- FALSE && inherits(cond, character(0))
  [10:41:24.227]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.227]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:24.227]                   if (!signal) {
  [10:41:24.227]                     muffleCondition <- function (cond) 
  [10:41:24.227]                     {
  [10:41:24.227]                       inherits <- base::inherits
  [10:41:24.227]                       invokeRestart <- base::invokeRestart
  [10:41:24.227]                       muffled <- FALSE
  [10:41:24.227]                       if (inherits(cond, "message")) {
  [10:41:24.227]                         invokeRestart("muffleMessage")
  [10:41:24.227]                         muffled <- TRUE
  [10:41:24.227]                       }
  [10:41:24.227]                       else if (inherits(cond, "warning")) {
  [10:41:24.227]                         invokeRestart("muffleWarning")
  [10:41:24.227]                         muffled <- TRUE
  [10:41:24.227]                       }
  [10:41:24.227]                       else if (inherits(cond, "condition")) {
  [10:41:24.227]                         computeRestarts <- base::computeRestarts
  [10:41:24.227]                         grepl <- base::grepl
  [10:41:24.227]                         is.null <- base::is.null
  [10:41:24.227]                         restarts <- computeRestarts(cond)
  [10:41:24.227]                         for (restart in restarts) {
  [10:41:24.227]                           name <- restart$name
  [10:41:24.227]                           if (is.null(name)) 
  [10:41:24.227]                             next
  [10:41:24.227]                           if (!grepl("^muffle", name)) 
  [10:41:24.227]                             next
  [10:41:24.227]                           invokeRestart(restart)
  [10:41:24.227]                           muffled <- TRUE
  [10:41:24.227]                           break
  [10:41:24.227]                         }
  [10:41:24.227]                       }
  [10:41:24.227]                       invisible(muffled)
  [10:41:24.227]                     }
  [10:41:24.227]                     muffleCondition(cond)
  [10:41:24.227]                   }
  [10:41:24.227]                 }
  [10:41:24.227]             }
  [10:41:24.227]         }))
  [10:41:24.227]     }, error = function(ex) {
  [10:41:24.227]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:24.227]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.227]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:24.227]     }, finally = {
  [10:41:24.227]         {
  [10:41:24.227]             {
  [10:41:24.227]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:41:24.227]             }
  [10:41:24.227]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:24.227]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:24.227]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:41:24.227]                 earlySignal = FALSE, label = NULL, ...) 
  [10:41:24.227]             {
  [10:41:24.227]                 if (substitute) 
  [10:41:24.227]                   expr <- substitute(expr)
  [10:41:24.227]                 if (is.function(workers)) 
  [10:41:24.227]                   workers <- workers()
  [10:41:24.227]                 workers <- as.integer(workers)
  [10:41:24.227]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:41:24.227]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:41:24.227]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:41:24.227]                     lazy = lazy, seed = seed, globals = globals, 
  [10:41:24.227]                     local = TRUE, label = label, ...))
  [10:41:24.227]                 }
  [10:41:24.227]                 oopts <- options(mc.cores = workers)
  [10:41:24.227]                 on.exit(options(oopts))
  [10:41:24.227]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:41:24.227]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:24.227]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:41:24.227]                   label = label, ...)
  [10:41:24.227]                 if (!future$lazy) 
  [10:41:24.227]                   future <- run(future)
  [10:41:24.227]                 invisible(future)
  [10:41:24.227]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:24.227]         }
  [10:41:24.227]         base::options(...future.oldOptions)
  [10:41:24.227]     })
  [10:41:24.227]     Sys.time
  [10:41:24.227]     if (base::is.na(TRUE)) {
  [10:41:24.227]     }
  [10:41:24.227]     else {
  [10:41:24.227]         base::sink(type = "output", split = FALSE)
  [10:41:24.227]         if (TRUE) {
  [10:41:24.227]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:24.227]         }
  [10:41:24.227]         else {
  [10:41:24.227]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:24.227]         }
  [10:41:24.227]         base::close(...future.stdout)
  [10:41:24.227]         ...future.stdout <- NULL
  [10:41:24.227]     }
  [10:41:24.227]     ...future.result$conditions <- ...future.conditions
  [10:41:24.227]     ...future.result
  [10:41:24.227] }
  [10:41:24.246] requestCore(): workers = 2
  [10:41:24.251] MulticoreFuture started
  [10:41:24.269] plan(): Setting new future strategy stack:
  [10:41:24.271] List of future strategies:
  [10:41:24.271] 1. sequential:
  [10:41:24.271]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:24.271]    - tweaked: FALSE
  [10:41:24.271]    - call: NULL
  [10:41:24.273] plan(): nbrOfWorkers() = 1
  [10:41:24.301] plan(): Setting new future strategy stack:
  [10:41:24.325] List of future strategies:
  [10:41:24.325] 1. multicore:
  [10:41:24.325]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:41:24.325]    - tweaked: FALSE
  [10:41:24.325]    - call: plan(strategy, substitute = FALSE)
  [10:41:24.328] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'C' with plan('multicore') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y)
      }
      y
  }
  <bytecode: 0x1cbed60>
  Arguments '...' exists: FALSE
  [10:41:24.340] getGlobalsAndPackages() ...
  [10:41:24.340] Searching for globals...
  [10:41:24.350] - globals found: [4] '{', 'sum', 'x', 'y'
  [10:41:24.351] Searching for globals ... DONE
  [10:41:24.351] Resolving globals: FALSE
  [10:41:24.353] The total size of the 2 globals is 112 bytes (112 bytes)
  [10:41:24.353] - globals: [2] 'x', 'y'
  [10:41:24.354] 
  [10:41:24.355] getGlobalsAndPackages() ... DONE
  [10:41:24.358] Packages needed by the future expression (n = 0): <none>
  [10:41:24.359] Packages needed by future strategies (n = 0): <none>
  [10:41:24.379] {
  [10:41:24.379]     {
  [10:41:24.379]         ...future.startTime <- base::Sys.time()
  [10:41:24.379]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:41:24.379]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:41:24.379]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:41:24.379]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:41:24.379]             future.resolve.recursive = NULL, width = 80L)
  [10:41:24.379]         {
  [10:41:24.379]             {
  [10:41:24.379]                 {
  [10:41:24.379]                   has_future <- base::requireNamespace("future", 
  [10:41:24.379]                     quietly = TRUE)
  [10:41:24.379]                   version <- if (has_future) 
  [10:41:24.379]                     utils::packageVersion("future")
  [10:41:24.379]                   else NULL
  [10:41:24.379]                   if (!has_future || version < "1.8.0") {
  [10:41:24.379]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:41:24.379]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:41:24.379]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:41:24.379]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:41:24.379]                         "release", "version")], collapse = " "), 
  [10:41:24.379]                       hostname = base::Sys.info()[["nodename"]])
  [10:41:24.379]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:41:24.379]                       info)
  [10:41:24.379]                     info <- base::paste(info, collapse = "; ")
  [10:41:24.379]                     if (!has_future) {
  [10:41:24.379]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:41:24.379]                         info)
  [10:41:24.379]                     }
  [10:41:24.379]                     else {
  [10:41:24.379]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:41:24.379]                         info, version)
  [10:41:24.379]                     }
  [10:41:24.379]                     base::stop(msg)
  [10:41:24.379]                   }
  [10:41:24.379]                 }
  [10:41:24.379]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:41:24.379]                 base::options(mc.cores = 1L)
  [10:41:24.379]             }
  [10:41:24.379]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:41:24.379]         }
  [10:41:24.379]     }
  [10:41:24.379]     if (base::is.na(TRUE)) {
  [10:41:24.379]     }
  [10:41:24.379]     else {
  [10:41:24.379]         if (TRUE) {
  [10:41:24.379]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:41:24.379]                 open = "w")
  [10:41:24.379]         }
  [10:41:24.379]         else {
  [10:41:24.379]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:41:24.379]                 windows = "NUL", "/dev/null"), open = "w")
  [10:41:24.379]         }
  [10:41:24.379]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:41:24.379]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:41:24.379]             base::sink(type = "output", split = FALSE)
  [10:41:24.379]             base::close(...future.stdout)
  [10:41:24.379]         }, add = TRUE)
  [10:41:24.379]     }
  [10:41:24.379]     ...future.frame <- base::sys.nframe()
  [10:41:24.379]     ...future.conditions <- base::list()
  [10:41:24.379]     ...future.rng <- base::globalenv()$.Random.seed
  [10:41:24.379]     ...future.result <- base::tryCatch({
  [10:41:24.379]         base::withCallingHandlers({
  [10:41:24.379]             ...future.value <- base::withVisible(base::local({
  [10:41:24.379]                 sum(x, y)
  [10:41:24.379]             }))
  [10:41:24.379]             future::FutureResult(value = ...future.value$value, 
  [10:41:24.379]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.379]                   ...future.rng), started = ...future.startTime, 
  [10:41:24.379]                 version = "1.8")
  [10:41:24.379]         }, condition = base::local({
  [10:41:24.379]             c <- base::c
  [10:41:24.379]             inherits <- base::inherits
  [10:41:24.379]             invokeRestart <- base::invokeRestart
  [10:41:24.379]             length <- base::length
  [10:41:24.379]             list <- base::list
  [10:41:24.379]             seq.int <- base::seq.int
  [10:41:24.379]             signalCondition <- base::signalCondition
  [10:41:24.379]             sys.calls <- base::sys.calls
  [10:41:24.379]             Sys.time <- base::Sys.time
  [10:41:24.379]             `[[` <- base::`[[`
  [10:41:24.379]             `+` <- base::`+`
  [10:41:24.379]             `<<-` <- base::`<<-`
  [10:41:24.379]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:41:24.379]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:41:24.379]                   3L)]
  [10:41:24.379]             }
  [10:41:24.379]             function(cond) {
  [10:41:24.379]                 if (inherits(cond, "error")) {
  [10:41:24.379]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.379]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:41:24.379]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:41:24.379]                   signalCondition(cond)
  [10:41:24.379]                 }
  [10:41:24.379]                 else if (inherits(cond, "condition")) {
  [10:41:24.379]                   signal <- FALSE && inherits(cond, character(0))
  [10:41:24.379]                   ...future.conditions[[length(...future.conditions) + 
  [10:41:24.379]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:41:24.379]                   if (!signal) {
  [10:41:24.379]                     muffleCondition <- function (cond) 
  [10:41:24.379]                     {
  [10:41:24.379]                       inherits <- base::inherits
  [10:41:24.379]                       invokeRestart <- base::invokeRestart
  [10:41:24.379]                       muffled <- FALSE
  [10:41:24.379]                       if (inherits(cond, "message")) {
  [10:41:24.379]                         invokeRestart("muffleMessage")
  [10:41:24.379]                         muffled <- TRUE
  [10:41:24.379]                       }
  [10:41:24.379]                       else if (inherits(cond, "warning")) {
  [10:41:24.379]                         invokeRestart("muffleWarning")
  [10:41:24.379]                         muffled <- TRUE
  [10:41:24.379]                       }
  [10:41:24.379]                       else if (inherits(cond, "condition")) {
  [10:41:24.379]                         computeRestarts <- base::computeRestarts
  [10:41:24.379]                         grepl <- base::grepl
  [10:41:24.379]                         is.null <- base::is.null
  [10:41:24.379]                         restarts <- computeRestarts(cond)
  [10:41:24.379]                         for (restart in restarts) {
  [10:41:24.379]                           name <- restart$name
  [10:41:24.379]                           if (is.null(name)) 
  [10:41:24.379]                             next
  [10:41:24.379]                           if (!grepl("^muffle", name)) 
  [10:41:24.379]                             next
  [10:41:24.379]                           invokeRestart(restart)
  [10:41:24.379]                           muffled <- TRUE
  [10:41:24.379]                           break
  [10:41:24.379]                         }
  [10:41:24.379]                       }
  [10:41:24.379]                       invisible(muffled)
  [10:41:24.379]                     }
  [10:41:24.379]                     muffleCondition(cond)
  [10:41:24.379]                   }
  [10:41:24.379]                 }
  [10:41:24.379]             }
  [10:41:24.379]         }))
  [10:41:24.379]     }, error = function(ex) {
  [10:41:24.379]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:41:24.379]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:41:24.379]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:41:24.379]     }, finally = {
  [10:41:24.379]         {
  [10:41:24.379]             {
  [10:41:24.379]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:41:24.379]             }
  [10:41:24.379]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:41:24.379]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:41:24.379]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:41:24.379]                 earlySignal = FALSE, label = NULL, ...) 
  [10:41:24.379]             {
  [10:41:24.379]                 if (substitute) 
  [10:41:24.379]                   expr <- substitute(expr)
  [10:41:24.379]                 if (is.function(workers)) 
  [10:41:24.379]                   workers <- workers()
  [10:41:24.379]                 workers <- as.integer(workers)
  [10:41:24.379]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:41:24.379]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:41:24.379]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:41:24.379]                     lazy = lazy, seed = seed, globals = globals, 
  [10:41:24.379]                     local = TRUE, label = label, ...))
  [10:41:24.379]                 }
  [10:41:24.379]                 oopts <- options(mc.cores = workers)
  [10:41:24.379]                 on.exit(options(oopts))
  [10:41:24.379]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:41:24.379]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:41:24.379]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:41:24.379]                   label = label, ...)
  [10:41:24.379]                 if (!future$lazy) 
  [10:41:24.379]                   future <- run(future)
  [10:41:24.379]                 invisible(future)
  [10:41:24.379]             }), .cleanup = FALSE, .init = FALSE)
  [10:41:24.379]         }
  [10:41:24.379]         base::options(...future.oldOptions)
  [10:41:24.379]     })
  [10:41:24.379]     Sys.time
  [10:41:24.379]     if (base::is.na(TRUE)) {
  [10:41:24.379]     }
  [10:41:24.379]     else {
  [10:41:24.379]         base::sink(type = "output", split = FALSE)
  [10:41:24.379]         if (TRUE) {
  [10:41:24.379]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:41:24.379]         }
  [10:41:24.379]         else {
  [10:41:24.379]             ...future.result["stdout"] <- base::list(NULL)
  [10:41:24.379]         }
  [10:41:24.379]         base::close(...future.stdout)
  [10:41:24.379]         ...future.stdout <- NULL
  [10:41:24.379]     }
  [10:41:24.379]     ...future.result$conditions <- ...future.conditions
  [10:41:24.379]     ...future.result
  [10:41:24.379] }
  [10:41:24.385] requestCore(): workers = 2
  [10:41:24.402] MulticoreFuture started
  [10:41:24.426] plan(): Setting new future strategy stack:
  [10:41:24.427] List of future strategies:
  [10:41:24.427] 1. sequential:
  [10:41:24.427]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:41:24.427]    - tweaked: FALSE
  [10:41:24.427]    - call: NULL
  [10:41:24.429] plan(): nbrOfWorkers() = 1
  [10:41:24.432] plan(): Setting new future strategy stack:
  [10:41:24.446] List of future strategies:
  [10:41:24.446] 1. multicore:
  [10:41:24.446]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:41:24.446]    - tweaked: FALSE
  [10:41:24.446]    - call: plan(strategy, substitute = FALSE)
  [10:41:24.449] plan(): nbrOfWorkers() = 2
  [1] 6
  ** Sum function 'D' with plan('multicore') ...
  function (x, y) 
  {
      message("Arguments '...' exists: ", exists("...", inherits = TRUE))
      y %<-% {
          sum(x, y, ...)
      }
      y
  }
  <bytecode: 0x29549d8>
  Arguments '...' exists: FALSE
  [10:41:24.455] getGlobalsAndPackages() ...
  [10:41:24.456] Searching for globals...
  [10:41:24.462] - globals found: [5] '{', 'sum', 'x', 'y', '...'
  [10:41:24.463] Searching for globals ... DONE
  [10:41:24.468] Resolving globals: FALSE
  [10:41:24.468] Tweak future expression to call with '...' arguments ...
  [10:41:24.469] Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : 
    Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }
  [1] "Error in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  : \n  Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,     globals = globals): Did you mean to create the future within a function?  Invalid future expression tries to use global '...' variables that do not exist: {; sum(x, y, ...); }>
  - plan('multisession') ...
  [10:41:24.472] plan(): Setting new future strategy stack:
  [10:41:24.472] List of future strategies:
  [10:41:24.472] 1. multisession:
  [10:41:24.472]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [10:41:24.472]    - tweaked: FALSE
  [10:41:24.472]    - call: plan(strategy, substitute = FALSE)
  [10:41:24.474] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [10:41:24.474] multisession:
  [10:41:24.474] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [10:41:24.474] - tweaked: FALSE
  [10:41:24.474] - call: plan(strategy, substitute = FALSE)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 36059
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpsyKAwW/working_dir/RtmpoN3NOG/future.parent=9259.242b3e2ef139.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpsyKAwW/working_dir/RtmpoN3NOG/future.parent=9259.242b3e2ef139.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/dotdotdot.R:gannet.stats.ox.ac.uk:ripley:9259' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpsyKAwW/working_dir/RtmpoN3NOG/future.parent=9259.242b3e2ef139.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36059 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
  Error in unserialize(node$con) : error reading from connection
  Calls: plan ... FUN -> recvData -> recvData.SOCKnode -> unserialize
  Execution halted
Running the tests in ‘tests/futureAssign.R’ failed.
Complete output:
  > source("incl/start.R")
  [10:46:10.644] plan(): Setting new future strategy stack:
  [10:46:10.649] List of future strategies:
  [10:46:10.649] 1. sequential:
  [10:46:10.649]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:10.649]    - tweaked: FALSE
  [10:46:10.649]    - call: future::plan("sequential")
  [10:46:10.658] plan(): nbrOfWorkers() = 1
  > 
  > message("*** futureAssign() ...")
  *** futureAssign() ...
  > 
  > message("*** futureAssign() - sequential w/ lazy evaluation ...")
  *** futureAssign() - sequential w/ lazy evaluation ...
  > 
  > delayedAssign("a", {
  +   cat("Delayed assignment evaluated\n")
  +   1
  + })
  > 
  > futureAssign("b", {
  +   cat("Future assignment evaluated\n")
  +   2
  + }, lazy = TRUE)
  [10:46:10.726] getGlobalsAndPackages() ...
  [10:46:10.727] Searching for globals...
  [10:46:10.752] - globals found: [2] '{', 'cat'
  [10:46:10.753] Searching for globals ... DONE
  [10:46:10.753] Resolving globals: FALSE
  [10:46:10.770] 
  [10:46:10.771] 
  [10:46:10.771] getGlobalsAndPackages() ... DONE
  > 
  > ## Because "lazy future" is used, the expression/value
  > ## for 'b' will not be resolved at the point.  For other
  > ## types of futures, it may already have been resolved
  > cat(sprintf("b = %s\n", b))
  [10:46:10.777] Packages needed by the future expression (n = 0): <none>
  [10:46:10.778] Packages needed by future strategies (n = 0): <none>
  [10:46:10.792] {
  [10:46:10.792]     {
  [10:46:10.792]         ...future.startTime <- base::Sys.time()
  [10:46:10.792]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:10.792]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:10.792]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [10:46:10.792]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:10.792]             future.resolve.recursive = NULL, width = 80L)
  [10:46:10.792]         {
  [10:46:10.792]             {
  [10:46:10.792]                 has_future <- base::requireNamespace("future", 
  [10:46:10.792]                   quietly = TRUE)
  [10:46:10.792]                 version <- if (has_future) 
  [10:46:10.792]                   utils::packageVersion("future")
  [10:46:10.792]                 else NULL
  [10:46:10.792]                 if (!has_future || version < "1.8.0") {
  [10:46:10.792]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:10.792]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:10.792]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:10.792]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:10.792]                       "release", "version")], collapse = " "), 
  [10:46:10.792]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:10.792]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:10.792]                     info)
  [10:46:10.792]                   info <- base::paste(info, collapse = "; ")
  [10:46:10.792]                   if (!has_future) {
  [10:46:10.792]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:10.792]                       info)
  [10:46:10.792]                   }
  [10:46:10.792]                   else {
  [10:46:10.792]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:10.792]                       info, version)
  [10:46:10.792]                   }
  [10:46:10.792]                   base::stop(msg)
  [10:46:10.792]                 }
  [10:46:10.792]             }
  [10:46:10.792]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:10.792]         }
  [10:46:10.792]     }
  [10:46:10.792]     if (base::is.na(TRUE)) {
  [10:46:10.792]     }
  [10:46:10.792]     else {
  [10:46:10.792]         if (TRUE) {
  [10:46:10.792]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:10.792]                 open = "w")
  [10:46:10.792]         }
  [10:46:10.792]         else {
  [10:46:10.792]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:10.792]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:10.792]         }
  [10:46:10.792]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:10.792]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:10.792]             base::sink(type = "output", split = FALSE)
  [10:46:10.792]             base::close(...future.stdout)
  [10:46:10.792]         }, add = TRUE)
  [10:46:10.792]     }
  [10:46:10.792]     ...future.frame <- base::sys.nframe()
  [10:46:10.792]     ...future.conditions <- base::list()
  [10:46:10.792]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:10.792]     ...future.result <- base::tryCatch({
  [10:46:10.792]         base::withCallingHandlers({
  [10:46:10.792]             ...future.value <- base::withVisible(base::local({
  [10:46:10.792]                 cat("Future assignment evaluated\n")
  [10:46:10.792]                 2
  [10:46:10.792]             }))
  [10:46:10.792]             future::FutureResult(value = ...future.value$value, 
  [10:46:10.792]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:10.792]                   ...future.rng), started = ...future.startTime, 
  [10:46:10.792]                 version = "1.8")
  [10:46:10.792]         }, condition = base::local({
  [10:46:10.792]             c <- base::c
  [10:46:10.792]             inherits <- base::inherits
  [10:46:10.792]             invokeRestart <- base::invokeRestart
  [10:46:10.792]             length <- base::length
  [10:46:10.792]             list <- base::list
  [10:46:10.792]             seq.int <- base::seq.int
  [10:46:10.792]             signalCondition <- base::signalCondition
  [10:46:10.792]             sys.calls <- base::sys.calls
  [10:46:10.792]             Sys.time <- base::Sys.time
  [10:46:10.792]             `[[` <- base::`[[`
  [10:46:10.792]             `+` <- base::`+`
  [10:46:10.792]             `<<-` <- base::`<<-`
  [10:46:10.792]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:10.792]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:10.792]                   3L)]
  [10:46:10.792]             }
  [10:46:10.792]             function(cond) {
  [10:46:10.792]                 if (inherits(cond, "error")) {
  [10:46:10.792]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:10.792]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:10.792]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:10.792]                   signalCondition(cond)
  [10:46:10.792]                 }
  [10:46:10.792]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:10.792]                 ))) {
  [10:46:10.792]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:10.792]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:10.792]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:10.792]                   if (!signal) {
  [10:46:10.792]                     muffleCondition <- function (cond) 
  [10:46:10.792]                     {
  [10:46:10.792]                       inherits <- base::inherits
  [10:46:10.792]                       invokeRestart <- base::invokeRestart
  [10:46:10.792]                       muffled <- FALSE
  [10:46:10.792]                       if (inherits(cond, "message")) {
  [10:46:10.792]                         invokeRestart("muffleMessage")
  [10:46:10.792]                         muffled <- TRUE
  [10:46:10.792]                       }
  [10:46:10.792]                       else if (inherits(cond, "warning")) {
  [10:46:10.792]                         invokeRestart("muffleWarning")
  [10:46:10.792]                         muffled <- TRUE
  [10:46:10.792]                       }
  [10:46:10.792]                       else if (inherits(cond, "condition")) {
  [10:46:10.792]                         computeRestarts <- base::computeRestarts
  [10:46:10.792]                         grepl <- base::grepl
  [10:46:10.792]                         is.null <- base::is.null
  [10:46:10.792]                         restarts <- computeRestarts(cond)
  [10:46:10.792]                         for (restart in restarts) {
  [10:46:10.792]                           name <- restart$name
  [10:46:10.792]                           if (is.null(name)) 
  [10:46:10.792]                             next
  [10:46:10.792]                           if (!grepl("^muffle", name)) 
  [10:46:10.792]                             next
  [10:46:10.792]                           invokeRestart(restart)
  [10:46:10.792]                           muffled <- TRUE
  [10:46:10.792]                           break
  [10:46:10.792]                         }
  [10:46:10.792]                       }
  [10:46:10.792]                       invisible(muffled)
  [10:46:10.792]                     }
  [10:46:10.792]                     muffleCondition(cond)
  [10:46:10.792]                   }
  [10:46:10.792]                 }
  [10:46:10.792]             }
  [10:46:10.792]         }))
  [10:46:10.792]     }, error = function(ex) {
  [10:46:10.792]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:10.792]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:10.792]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:10.792]     }, finally = {
  [10:46:10.792]         {
  [10:46:10.792]             NULL
  [10:46:10.792]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:10.792]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:10.792]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:10.792]                 label = NULL, ...) 
  [10:46:10.792]             {
  [10:46:10.792]                 if (substitute) 
  [10:46:10.792]                   expr <- substitute(expr)
  [10:46:10.792]                 local <- as.logical(local)
  [10:46:10.792]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:10.792]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:10.792]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:10.792]                   label = label, ...)
  [10:46:10.792]                 if (!future$lazy) 
  [10:46:10.792]                   future <- run(future)
  [10:46:10.792]                 invisible(future)
  [10:46:10.792]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:10.792]         }
  [10:46:10.792]         base::options(...future.oldOptions)
  [10:46:10.792]     })
  [10:46:10.792]     Sys.time
  [10:46:10.792]     if (base::is.na(TRUE)) {
  [10:46:10.792]     }
  [10:46:10.792]     else {
  [10:46:10.792]         base::sink(type = "output", split = FALSE)
  [10:46:10.792]         if (TRUE) {
  [10:46:10.792]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:10.792]         }
  [10:46:10.792]         else {
  [10:46:10.792]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:10.792]         }
  [10:46:10.792]         base::close(...future.stdout)
  [10:46:10.792]         ...future.stdout <- NULL
  [10:46:10.792]     }
  [10:46:10.792]     ...future.result$conditions <- ...future.conditions
  [10:46:10.792]     ...future.result
  [10:46:10.792] }
  [10:46:10.803] plan(): Setting new future strategy stack:
  [10:46:10.804] List of future strategies:
  [10:46:10.804] 1. sequential:
  [10:46:10.804]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:10.804]    - tweaked: FALSE
  [10:46:10.804]    - call: NULL
  [10:46:10.809] plan(): nbrOfWorkers() = 1
  [10:46:10.819] plan(): Setting new future strategy stack:
  [10:46:10.820] List of future strategies:
  [10:46:10.820] 1. sequential:
  [10:46:10.820]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:10.820]    - tweaked: FALSE
  [10:46:10.820]    - call: future::plan("sequential")
  [10:46:10.826] plan(): nbrOfWorkers() = 1
  [10:46:10.827] SequentialFuture started (and completed)
  Future assignment evaluated
  b = 2
  > 
  > ## The expression/value of 'a' is resolved at this point,
  > ## because a delayed assignment (promise) was used.
  > cat(sprintf("a = %s\n", a))
  Delayed assignment evaluated
  a = 1
  > 
  > stopifnot(identical(a, 1))
  > stopifnot(identical(b, 2))
  > 
  > message("*** futureAssign() - sequential w/ lazy evaluation ... DONE")
  *** futureAssign() - sequential w/ lazy evaluation ... DONE
  > 
  > 
  > message("*** futureAssign() - lazy = TRUE / FALSE ...")
  *** futureAssign() - lazy = TRUE / FALSE ...
  > 
  > 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)
  + 
  +   for (strategy in supportedStrategies(cores)) {
  +     message(sprintf("*** futureAssign() with %s futures ...", sQuote(strategy)))
  +     plan(strategy)
  + 
  +     ## Potential task name clashes
  +     u <- new.env()
  +     v <- new.env()
  +     futureAssign("a", { 2 }, assign.env = u)
  +     futureAssign("a", { 4 }, assign.env = v)
  +     
  +     cat(sprintf("u$a = %s\n", u$a))
  +     cat(sprintf("v$a = %s\n", v$a))
  +     
  +     stopifnot(identical(u$a, 2))
  +     stopifnot(identical(v$a, 4))
  +     
  +     
  +     ## Global variables
  +     a <- 1
  +     futureAssign("b", { 2 * a })
  +     a <- 2
  +     stopifnot(b == 2)
  + 
  +     ## Explicit lazy evaluation
  +     for (lazy in c(FALSE, TRUE)) {
  +       a <- 1
  +       f <- futureAssign("b", { 2 * a }, lazy = lazy)
  +       a <- 2
  +       stopifnot(b == 2)
  +       stopifnot(f$lazy == lazy || (strategy %in% c("multisession", "multiprocess") && cores == 1L))
  +       
  +       ## Set 'lazy' via disposable option
  +       options(future.disposable = list(lazy = lazy))
  +       a <- 1
  +       f <- futureAssign("b", { 2 * a })
  +       a <- 2
  +       stopifnot(b == 2)
  +       stopifnot(f$lazy == lazy || (strategy %in% c("multisession", "multiprocess") && cores == 1L))
  +     }
  + 
  +     message(sprintf("*** futureAssign() with %s futures ... DONE", sQuote(strategy)))
  +   } # for (strategy in ...)
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  *** futureAssign() with 'sequential' futures ...
  [10:46:11.130] plan(): Setting new future strategy stack:
  [10:46:11.130] List of future strategies:
  [10:46:11.130] 1. sequential:
  [10:46:11.130]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.130]    - tweaked: FALSE
  [10:46:11.130]    - call: plan(strategy)
  [10:46:11.240] plan(): nbrOfWorkers() = 1
  [10:46:11.241] getGlobalsAndPackages() ...
  [10:46:11.241] Searching for globals...
  [10:46:11.243] - globals found: [1] '{'
  [10:46:11.243] Searching for globals ... DONE
  [10:46:11.244] Resolving globals: FALSE
  [10:46:11.245] 
  [10:46:11.245] 
  [10:46:11.246] getGlobalsAndPackages() ... DONE
  [10:46:11.249] Packages needed by the future expression (n = 0): <none>
  [10:46:11.249] Packages needed by future strategies (n = 0): <none>
  [10:46:11.280] {
  [10:46:11.280]     {
  [10:46:11.280]         ...future.startTime <- base::Sys.time()
  [10:46:11.280]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.280]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.280]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.280]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.280]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.280]         {
  [10:46:11.280]             {
  [10:46:11.280]                 has_future <- base::requireNamespace("future", 
  [10:46:11.280]                   quietly = TRUE)
  [10:46:11.280]                 version <- if (has_future) 
  [10:46:11.280]                   utils::packageVersion("future")
  [10:46:11.280]                 else NULL
  [10:46:11.280]                 if (!has_future || version < "1.8.0") {
  [10:46:11.280]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.280]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.280]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.280]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.280]                       "release", "version")], collapse = " "), 
  [10:46:11.280]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.280]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.280]                     info)
  [10:46:11.280]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.280]                   if (!has_future) {
  [10:46:11.280]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.280]                       info)
  [10:46:11.280]                   }
  [10:46:11.280]                   else {
  [10:46:11.280]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.280]                       info, version)
  [10:46:11.280]                   }
  [10:46:11.280]                   base::stop(msg)
  [10:46:11.280]                 }
  [10:46:11.280]             }
  [10:46:11.280]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.280]         }
  [10:46:11.280]     }
  [10:46:11.280]     if (base::is.na(TRUE)) {
  [10:46:11.280]     }
  [10:46:11.280]     else {
  [10:46:11.280]         if (TRUE) {
  [10:46:11.280]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.280]                 open = "w")
  [10:46:11.280]         }
  [10:46:11.280]         else {
  [10:46:11.280]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.280]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.280]         }
  [10:46:11.280]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.280]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.280]             base::sink(type = "output", split = FALSE)
  [10:46:11.280]             base::close(...future.stdout)
  [10:46:11.280]         }, add = TRUE)
  [10:46:11.280]     }
  [10:46:11.280]     ...future.frame <- base::sys.nframe()
  [10:46:11.280]     ...future.conditions <- base::list()
  [10:46:11.280]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.280]     ...future.result <- base::tryCatch({
  [10:46:11.280]         base::withCallingHandlers({
  [10:46:11.280]             ...future.value <- base::withVisible(base::local({
  [10:46:11.280]                 2
  [10:46:11.280]             }))
  [10:46:11.280]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.280]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.280]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.280]                 version = "1.8")
  [10:46:11.280]         }, condition = base::local({
  [10:46:11.280]             c <- base::c
  [10:46:11.280]             inherits <- base::inherits
  [10:46:11.280]             invokeRestart <- base::invokeRestart
  [10:46:11.280]             length <- base::length
  [10:46:11.280]             list <- base::list
  [10:46:11.280]             seq.int <- base::seq.int
  [10:46:11.280]             signalCondition <- base::signalCondition
  [10:46:11.280]             sys.calls <- base::sys.calls
  [10:46:11.280]             Sys.time <- base::Sys.time
  [10:46:11.280]             `[[` <- base::`[[`
  [10:46:11.280]             `+` <- base::`+`
  [10:46:11.280]             `<<-` <- base::`<<-`
  [10:46:11.280]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.280]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.280]                   3L)]
  [10:46:11.280]             }
  [10:46:11.280]             function(cond) {
  [10:46:11.280]                 if (inherits(cond, "error")) {
  [10:46:11.280]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.280]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.280]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.280]                   signalCondition(cond)
  [10:46:11.280]                 }
  [10:46:11.280]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.280]                 ))) {
  [10:46:11.280]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.280]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.280]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.280]                   if (!signal) {
  [10:46:11.280]                     muffleCondition <- function (cond) 
  [10:46:11.280]                     {
  [10:46:11.280]                       inherits <- base::inherits
  [10:46:11.280]                       invokeRestart <- base::invokeRestart
  [10:46:11.280]                       muffled <- FALSE
  [10:46:11.280]                       if (inherits(cond, "message")) {
  [10:46:11.280]                         invokeRestart("muffleMessage")
  [10:46:11.280]                         muffled <- TRUE
  [10:46:11.280]                       }
  [10:46:11.280]                       else if (inherits(cond, "warning")) {
  [10:46:11.280]                         invokeRestart("muffleWarning")
  [10:46:11.280]                         muffled <- TRUE
  [10:46:11.280]                       }
  [10:46:11.280]                       else if (inherits(cond, "condition")) {
  [10:46:11.280]                         computeRestarts <- base::computeRestarts
  [10:46:11.280]                         grepl <- base::grepl
  [10:46:11.280]                         is.null <- base::is.null
  [10:46:11.280]                         restarts <- computeRestarts(cond)
  [10:46:11.280]                         for (restart in restarts) {
  [10:46:11.280]                           name <- restart$name
  [10:46:11.280]                           if (is.null(name)) 
  [10:46:11.280]                             next
  [10:46:11.280]                           if (!grepl("^muffle", name)) 
  [10:46:11.280]                             next
  [10:46:11.280]                           invokeRestart(restart)
  [10:46:11.280]                           muffled <- TRUE
  [10:46:11.280]                           break
  [10:46:11.280]                         }
  [10:46:11.280]                       }
  [10:46:11.280]                       invisible(muffled)
  [10:46:11.280]                     }
  [10:46:11.280]                     muffleCondition(cond)
  [10:46:11.280]                   }
  [10:46:11.280]                 }
  [10:46:11.280]             }
  [10:46:11.280]         }))
  [10:46:11.280]     }, error = function(ex) {
  [10:46:11.280]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.280]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.280]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.280]     }, finally = {
  [10:46:11.280]         {
  [10:46:11.280]             NULL
  [10:46:11.280]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.280]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.280]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.280]                 label = NULL, ...) 
  [10:46:11.280]             {
  [10:46:11.280]                 if (substitute) 
  [10:46:11.280]                   expr <- substitute(expr)
  [10:46:11.280]                 local <- as.logical(local)
  [10:46:11.280]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.280]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.280]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.280]                   label = label, ...)
  [10:46:11.280]                 if (!future$lazy) 
  [10:46:11.280]                   future <- run(future)
  [10:46:11.280]                 invisible(future)
  [10:46:11.280]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.280]         }
  [10:46:11.280]         base::options(...future.oldOptions)
  [10:46:11.280]     })
  [10:46:11.280]     Sys.time
  [10:46:11.280]     if (base::is.na(TRUE)) {
  [10:46:11.280]     }
  [10:46:11.280]     else {
  [10:46:11.280]         base::sink(type = "output", split = FALSE)
  [10:46:11.280]         if (TRUE) {
  [10:46:11.280]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.280]         }
  [10:46:11.280]         else {
  [10:46:11.280]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.280]         }
  [10:46:11.280]         base::close(...future.stdout)
  [10:46:11.280]         ...future.stdout <- NULL
  [10:46:11.280]     }
  [10:46:11.280]     ...future.result$conditions <- ...future.conditions
  [10:46:11.280]     ...future.result
  [10:46:11.280] }
  [10:46:11.295] plan(): Setting new future strategy stack:
  [10:46:11.296] List of future strategies:
  [10:46:11.296] 1. sequential:
  [10:46:11.296]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.296]    - tweaked: FALSE
  [10:46:11.296]    - call: NULL
  [10:46:11.297] plan(): nbrOfWorkers() = 1
  [10:46:11.304] plan(): Setting new future strategy stack:
  [10:46:11.304] List of future strategies:
  [10:46:11.304] 1. sequential:
  [10:46:11.304]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.304]    - tweaked: FALSE
  [10:46:11.304]    - call: plan(strategy)
  [10:46:11.306] plan(): nbrOfWorkers() = 1
  [10:46:11.307] SequentialFuture started (and completed)
  [10:46:11.307] getGlobalsAndPackages() ...
  [10:46:11.318] Searching for globals...
  [10:46:11.320] - globals found: [1] '{'
  [10:46:11.321] Searching for globals ... DONE
  [10:46:11.321] Resolving globals: FALSE
  [10:46:11.322] 
  [10:46:11.322] 
  [10:46:11.330] getGlobalsAndPackages() ... DONE
  [10:46:11.339] Packages needed by the future expression (n = 0): <none>
  [10:46:11.339] Packages needed by future strategies (n = 0): <none>
  [10:46:11.383] {
  [10:46:11.383]     {
  [10:46:11.383]         ...future.startTime <- base::Sys.time()
  [10:46:11.383]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.383]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.383]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.383]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.383]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.383]         {
  [10:46:11.383]             {
  [10:46:11.383]                 has_future <- base::requireNamespace("future", 
  [10:46:11.383]                   quietly = TRUE)
  [10:46:11.383]                 version <- if (has_future) 
  [10:46:11.383]                   utils::packageVersion("future")
  [10:46:11.383]                 else NULL
  [10:46:11.383]                 if (!has_future || version < "1.8.0") {
  [10:46:11.383]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.383]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.383]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.383]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.383]                       "release", "version")], collapse = " "), 
  [10:46:11.383]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.383]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.383]                     info)
  [10:46:11.383]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.383]                   if (!has_future) {
  [10:46:11.383]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.383]                       info)
  [10:46:11.383]                   }
  [10:46:11.383]                   else {
  [10:46:11.383]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.383]                       info, version)
  [10:46:11.383]                   }
  [10:46:11.383]                   base::stop(msg)
  [10:46:11.383]                 }
  [10:46:11.383]             }
  [10:46:11.383]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.383]         }
  [10:46:11.383]     }
  [10:46:11.383]     if (base::is.na(TRUE)) {
  [10:46:11.383]     }
  [10:46:11.383]     else {
  [10:46:11.383]         if (TRUE) {
  [10:46:11.383]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.383]                 open = "w")
  [10:46:11.383]         }
  [10:46:11.383]         else {
  [10:46:11.383]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.383]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.383]         }
  [10:46:11.383]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.383]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.383]             base::sink(type = "output", split = FALSE)
  [10:46:11.383]             base::close(...future.stdout)
  [10:46:11.383]         }, add = TRUE)
  [10:46:11.383]     }
  [10:46:11.383]     ...future.frame <- base::sys.nframe()
  [10:46:11.383]     ...future.conditions <- base::list()
  [10:46:11.383]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.383]     ...future.result <- base::tryCatch({
  [10:46:11.383]         base::withCallingHandlers({
  [10:46:11.383]             ...future.value <- base::withVisible(base::local({
  [10:46:11.383]                 4
  [10:46:11.383]             }))
  [10:46:11.383]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.383]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.383]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.383]                 version = "1.8")
  [10:46:11.383]         }, condition = base::local({
  [10:46:11.383]             c <- base::c
  [10:46:11.383]             inherits <- base::inherits
  [10:46:11.383]             invokeRestart <- base::invokeRestart
  [10:46:11.383]             length <- base::length
  [10:46:11.383]             list <- base::list
  [10:46:11.383]             seq.int <- base::seq.int
  [10:46:11.383]             signalCondition <- base::signalCondition
  [10:46:11.383]             sys.calls <- base::sys.calls
  [10:46:11.383]             Sys.time <- base::Sys.time
  [10:46:11.383]             `[[` <- base::`[[`
  [10:46:11.383]             `+` <- base::`+`
  [10:46:11.383]             `<<-` <- base::`<<-`
  [10:46:11.383]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.383]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.383]                   3L)]
  [10:46:11.383]             }
  [10:46:11.383]             function(cond) {
  [10:46:11.383]                 if (inherits(cond, "error")) {
  [10:46:11.383]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.383]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.383]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.383]                   signalCondition(cond)
  [10:46:11.383]                 }
  [10:46:11.383]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.383]                 ))) {
  [10:46:11.383]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.383]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.383]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.383]                   if (!signal) {
  [10:46:11.383]                     muffleCondition <- function (cond) 
  [10:46:11.383]                     {
  [10:46:11.383]                       inherits <- base::inherits
  [10:46:11.383]                       invokeRestart <- base::invokeRestart
  [10:46:11.383]                       muffled <- FALSE
  [10:46:11.383]                       if (inherits(cond, "message")) {
  [10:46:11.383]                         invokeRestart("muffleMessage")
  [10:46:11.383]                         muffled <- TRUE
  [10:46:11.383]                       }
  [10:46:11.383]                       else if (inherits(cond, "warning")) {
  [10:46:11.383]                         invokeRestart("muffleWarning")
  [10:46:11.383]                         muffled <- TRUE
  [10:46:11.383]                       }
  [10:46:11.383]                       else if (inherits(cond, "condition")) {
  [10:46:11.383]                         computeRestarts <- base::computeRestarts
  [10:46:11.383]                         grepl <- base::grepl
  [10:46:11.383]                         is.null <- base::is.null
  [10:46:11.383]                         restarts <- computeRestarts(cond)
  [10:46:11.383]                         for (restart in restarts) {
  [10:46:11.383]                           name <- restart$name
  [10:46:11.383]                           if (is.null(name)) 
  [10:46:11.383]                             next
  [10:46:11.383]                           if (!grepl("^muffle", name)) 
  [10:46:11.383]                             next
  [10:46:11.383]                           invokeRestart(restart)
  [10:46:11.383]                           muffled <- TRUE
  [10:46:11.383]                           break
  [10:46:11.383]                         }
  [10:46:11.383]                       }
  [10:46:11.383]                       invisible(muffled)
  [10:46:11.383]                     }
  [10:46:11.383]                     muffleCondition(cond)
  [10:46:11.383]                   }
  [10:46:11.383]                 }
  [10:46:11.383]             }
  [10:46:11.383]         }))
  [10:46:11.383]     }, error = function(ex) {
  [10:46:11.383]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.383]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.383]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.383]     }, finally = {
  [10:46:11.383]         {
  [10:46:11.383]             NULL
  [10:46:11.383]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.383]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.383]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.383]                 label = NULL, ...) 
  [10:46:11.383]             {
  [10:46:11.383]                 if (substitute) 
  [10:46:11.383]                   expr <- substitute(expr)
  [10:46:11.383]                 local <- as.logical(local)
  [10:46:11.383]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.383]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.383]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.383]                   label = label, ...)
  [10:46:11.383]                 if (!future$lazy) 
  [10:46:11.383]                   future <- run(future)
  [10:46:11.383]                 invisible(future)
  [10:46:11.383]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.383]         }
  [10:46:11.383]         base::options(...future.oldOptions)
  [10:46:11.383]     })
  [10:46:11.383]     Sys.time
  [10:46:11.383]     if (base::is.na(TRUE)) {
  [10:46:11.383]     }
  [10:46:11.383]     else {
  [10:46:11.383]         base::sink(type = "output", split = FALSE)
  [10:46:11.383]         if (TRUE) {
  [10:46:11.383]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.383]         }
  [10:46:11.383]         else {
  [10:46:11.383]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.383]         }
  [10:46:11.383]         base::close(...future.stdout)
  [10:46:11.383]         ...future.stdout <- NULL
  [10:46:11.383]     }
  [10:46:11.383]     ...future.result$conditions <- ...future.conditions
  [10:46:11.383]     ...future.result
  [10:46:11.383] }
  [10:46:11.403] plan(): Setting new future strategy stack:
  [10:46:11.404] List of future strategies:
  [10:46:11.404] 1. sequential:
  [10:46:11.404]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.404]    - tweaked: FALSE
  [10:46:11.404]    - call: NULL
  [10:46:11.419] plan(): nbrOfWorkers() = 1
  [10:46:11.420] plan(): Setting new future strategy stack:
  [10:46:11.421] List of future strategies:
  [10:46:11.421] 1. sequential:
  [10:46:11.421]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.421]    - tweaked: FALSE
  [10:46:11.421]    - call: plan(strategy)
  [10:46:11.422] plan(): nbrOfWorkers() = 1
  [10:46:11.423] SequentialFuture started (and completed)
  u$a = 2
  v$a = 4
  [10:46:11.439] getGlobalsAndPackages() ...
  [10:46:11.439] Searching for globals...
  [10:46:11.442] - globals found: [3] '{', '*', 'a'
  [10:46:11.442] Searching for globals ... DONE
  [10:46:11.443] Resolving globals: FALSE
  [10:46:11.458] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:11.459] - globals: [1] 'a'
  [10:46:11.459] 
  [10:46:11.460] getGlobalsAndPackages() ... DONE
  [10:46:11.466] Packages needed by the future expression (n = 0): <none>
  [10:46:11.467] Packages needed by future strategies (n = 0): <none>
  [10:46:11.491] {
  [10:46:11.491]     {
  [10:46:11.491]         ...future.startTime <- base::Sys.time()
  [10:46:11.491]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.491]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.491]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.491]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.491]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.491]         {
  [10:46:11.491]             {
  [10:46:11.491]                 has_future <- base::requireNamespace("future", 
  [10:46:11.491]                   quietly = TRUE)
  [10:46:11.491]                 version <- if (has_future) 
  [10:46:11.491]                   utils::packageVersion("future")
  [10:46:11.491]                 else NULL
  [10:46:11.491]                 if (!has_future || version < "1.8.0") {
  [10:46:11.491]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.491]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.491]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.491]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.491]                       "release", "version")], collapse = " "), 
  [10:46:11.491]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.491]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.491]                     info)
  [10:46:11.491]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.491]                   if (!has_future) {
  [10:46:11.491]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.491]                       info)
  [10:46:11.491]                   }
  [10:46:11.491]                   else {
  [10:46:11.491]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.491]                       info, version)
  [10:46:11.491]                   }
  [10:46:11.491]                   base::stop(msg)
  [10:46:11.491]                 }
  [10:46:11.491]             }
  [10:46:11.491]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.491]         }
  [10:46:11.491]     }
  [10:46:11.491]     if (base::is.na(TRUE)) {
  [10:46:11.491]     }
  [10:46:11.491]     else {
  [10:46:11.491]         if (TRUE) {
  [10:46:11.491]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.491]                 open = "w")
  [10:46:11.491]         }
  [10:46:11.491]         else {
  [10:46:11.491]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.491]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.491]         }
  [10:46:11.491]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.491]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.491]             base::sink(type = "output", split = FALSE)
  [10:46:11.491]             base::close(...future.stdout)
  [10:46:11.491]         }, add = TRUE)
  [10:46:11.491]     }
  [10:46:11.491]     ...future.frame <- base::sys.nframe()
  [10:46:11.491]     ...future.conditions <- base::list()
  [10:46:11.491]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.491]     ...future.result <- base::tryCatch({
  [10:46:11.491]         base::withCallingHandlers({
  [10:46:11.491]             ...future.value <- base::withVisible(base::local({
  [10:46:11.491]                 2 * a
  [10:46:11.491]             }))
  [10:46:11.491]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.491]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.491]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.491]                 version = "1.8")
  [10:46:11.491]         }, condition = base::local({
  [10:46:11.491]             c <- base::c
  [10:46:11.491]             inherits <- base::inherits
  [10:46:11.491]             invokeRestart <- base::invokeRestart
  [10:46:11.491]             length <- base::length
  [10:46:11.491]             list <- base::list
  [10:46:11.491]             seq.int <- base::seq.int
  [10:46:11.491]             signalCondition <- base::signalCondition
  [10:46:11.491]             sys.calls <- base::sys.calls
  [10:46:11.491]             Sys.time <- base::Sys.time
  [10:46:11.491]             `[[` <- base::`[[`
  [10:46:11.491]             `+` <- base::`+`
  [10:46:11.491]             `<<-` <- base::`<<-`
  [10:46:11.491]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.491]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.491]                   3L)]
  [10:46:11.491]             }
  [10:46:11.491]             function(cond) {
  [10:46:11.491]                 if (inherits(cond, "error")) {
  [10:46:11.491]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.491]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.491]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.491]                   signalCondition(cond)
  [10:46:11.491]                 }
  [10:46:11.491]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.491]                 ))) {
  [10:46:11.491]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.491]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.491]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.491]                   if (!signal) {
  [10:46:11.491]                     muffleCondition <- function (cond) 
  [10:46:11.491]                     {
  [10:46:11.491]                       inherits <- base::inherits
  [10:46:11.491]                       invokeRestart <- base::invokeRestart
  [10:46:11.491]                       muffled <- FALSE
  [10:46:11.491]                       if (inherits(cond, "message")) {
  [10:46:11.491]                         invokeRestart("muffleMessage")
  [10:46:11.491]                         muffled <- TRUE
  [10:46:11.491]                       }
  [10:46:11.491]                       else if (inherits(cond, "warning")) {
  [10:46:11.491]                         invokeRestart("muffleWarning")
  [10:46:11.491]                         muffled <- TRUE
  [10:46:11.491]                       }
  [10:46:11.491]                       else if (inherits(cond, "condition")) {
  [10:46:11.491]                         computeRestarts <- base::computeRestarts
  [10:46:11.491]                         grepl <- base::grepl
  [10:46:11.491]                         is.null <- base::is.null
  [10:46:11.491]                         restarts <- computeRestarts(cond)
  [10:46:11.491]                         for (restart in restarts) {
  [10:46:11.491]                           name <- restart$name
  [10:46:11.491]                           if (is.null(name)) 
  [10:46:11.491]                             next
  [10:46:11.491]                           if (!grepl("^muffle", name)) 
  [10:46:11.491]                             next
  [10:46:11.491]                           invokeRestart(restart)
  [10:46:11.491]                           muffled <- TRUE
  [10:46:11.491]                           break
  [10:46:11.491]                         }
  [10:46:11.491]                       }
  [10:46:11.491]                       invisible(muffled)
  [10:46:11.491]                     }
  [10:46:11.491]                     muffleCondition(cond)
  [10:46:11.491]                   }
  [10:46:11.491]                 }
  [10:46:11.491]             }
  [10:46:11.491]         }))
  [10:46:11.491]     }, error = function(ex) {
  [10:46:11.491]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.491]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.491]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.491]     }, finally = {
  [10:46:11.491]         {
  [10:46:11.491]             NULL
  [10:46:11.491]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.491]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.491]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.491]                 label = NULL, ...) 
  [10:46:11.491]             {
  [10:46:11.491]                 if (substitute) 
  [10:46:11.491]                   expr <- substitute(expr)
  [10:46:11.491]                 local <- as.logical(local)
  [10:46:11.491]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.491]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.491]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.491]                   label = label, ...)
  [10:46:11.491]                 if (!future$lazy) 
  [10:46:11.491]                   future <- run(future)
  [10:46:11.491]                 invisible(future)
  [10:46:11.491]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.491]         }
  [10:46:11.491]         base::options(...future.oldOptions)
  [10:46:11.491]     })
  [10:46:11.491]     Sys.time
  [10:46:11.491]     if (base::is.na(TRUE)) {
  [10:46:11.491]     }
  [10:46:11.491]     else {
  [10:46:11.491]         base::sink(type = "output", split = FALSE)
  [10:46:11.491]         if (TRUE) {
  [10:46:11.491]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.491]         }
  [10:46:11.491]         else {
  [10:46:11.491]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.491]         }
  [10:46:11.491]         base::close(...future.stdout)
  [10:46:11.491]         ...future.stdout <- NULL
  [10:46:11.491]     }
  [10:46:11.491]     ...future.result$conditions <- ...future.conditions
  [10:46:11.491]     ...future.result
  [10:46:11.491] }
  [10:46:11.501] plan(): Setting new future strategy stack:
  [10:46:11.507] List of future strategies:
  [10:46:11.507] 1. sequential:
  [10:46:11.507]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.507]    - tweaked: FALSE
  [10:46:11.507]    - call: NULL
  [10:46:11.509] plan(): nbrOfWorkers() = 1
  [10:46:11.510] plan(): Setting new future strategy stack:
  [10:46:11.516] List of future strategies:
  [10:46:11.516] 1. sequential:
  [10:46:11.516]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.516]    - tweaked: FALSE
  [10:46:11.516]    - call: plan(strategy)
  [10:46:11.517] plan(): nbrOfWorkers() = 1
  [10:46:11.518] SequentialFuture started (and completed)
  [10:46:11.519] getGlobalsAndPackages() ...
  [10:46:11.525] Searching for globals...
  [10:46:11.527] - globals found: [3] '{', '*', 'a'
  [10:46:11.528] Searching for globals ... DONE
  [10:46:11.528] Resolving globals: FALSE
  [10:46:11.534] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:11.535] - globals: [1] 'a'
  [10:46:11.535] 
  [10:46:11.536] getGlobalsAndPackages() ... DONE
  [10:46:11.543] Packages needed by the future expression (n = 0): <none>
  [10:46:11.544] Packages needed by future strategies (n = 0): <none>
  [10:46:11.561] {
  [10:46:11.561]     {
  [10:46:11.561]         ...future.startTime <- base::Sys.time()
  [10:46:11.561]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.561]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.561]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.561]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.561]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.561]         {
  [10:46:11.561]             {
  [10:46:11.561]                 has_future <- base::requireNamespace("future", 
  [10:46:11.561]                   quietly = TRUE)
  [10:46:11.561]                 version <- if (has_future) 
  [10:46:11.561]                   utils::packageVersion("future")
  [10:46:11.561]                 else NULL
  [10:46:11.561]                 if (!has_future || version < "1.8.0") {
  [10:46:11.561]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.561]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.561]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.561]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.561]                       "release", "version")], collapse = " "), 
  [10:46:11.561]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.561]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.561]                     info)
  [10:46:11.561]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.561]                   if (!has_future) {
  [10:46:11.561]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.561]                       info)
  [10:46:11.561]                   }
  [10:46:11.561]                   else {
  [10:46:11.561]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.561]                       info, version)
  [10:46:11.561]                   }
  [10:46:11.561]                   base::stop(msg)
  [10:46:11.561]                 }
  [10:46:11.561]             }
  [10:46:11.561]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.561]         }
  [10:46:11.561]     }
  [10:46:11.561]     if (base::is.na(TRUE)) {
  [10:46:11.561]     }
  [10:46:11.561]     else {
  [10:46:11.561]         if (TRUE) {
  [10:46:11.561]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.561]                 open = "w")
  [10:46:11.561]         }
  [10:46:11.561]         else {
  [10:46:11.561]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.561]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.561]         }
  [10:46:11.561]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.561]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.561]             base::sink(type = "output", split = FALSE)
  [10:46:11.561]             base::close(...future.stdout)
  [10:46:11.561]         }, add = TRUE)
  [10:46:11.561]     }
  [10:46:11.561]     ...future.frame <- base::sys.nframe()
  [10:46:11.561]     ...future.conditions <- base::list()
  [10:46:11.561]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.561]     ...future.result <- base::tryCatch({
  [10:46:11.561]         base::withCallingHandlers({
  [10:46:11.561]             ...future.value <- base::withVisible(base::local({
  [10:46:11.561]                 2 * a
  [10:46:11.561]             }))
  [10:46:11.561]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.561]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.561]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.561]                 version = "1.8")
  [10:46:11.561]         }, condition = base::local({
  [10:46:11.561]             c <- base::c
  [10:46:11.561]             inherits <- base::inherits
  [10:46:11.561]             invokeRestart <- base::invokeRestart
  [10:46:11.561]             length <- base::length
  [10:46:11.561]             list <- base::list
  [10:46:11.561]             seq.int <- base::seq.int
  [10:46:11.561]             signalCondition <- base::signalCondition
  [10:46:11.561]             sys.calls <- base::sys.calls
  [10:46:11.561]             Sys.time <- base::Sys.time
  [10:46:11.561]             `[[` <- base::`[[`
  [10:46:11.561]             `+` <- base::`+`
  [10:46:11.561]             `<<-` <- base::`<<-`
  [10:46:11.561]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.561]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.561]                   3L)]
  [10:46:11.561]             }
  [10:46:11.561]             function(cond) {
  [10:46:11.561]                 if (inherits(cond, "error")) {
  [10:46:11.561]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.561]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.561]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.561]                   signalCondition(cond)
  [10:46:11.561]                 }
  [10:46:11.561]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.561]                 ))) {
  [10:46:11.561]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.561]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.561]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.561]                   if (!signal) {
  [10:46:11.561]                     muffleCondition <- function (cond) 
  [10:46:11.561]                     {
  [10:46:11.561]                       inherits <- base::inherits
  [10:46:11.561]                       invokeRestart <- base::invokeRestart
  [10:46:11.561]                       muffled <- FALSE
  [10:46:11.561]                       if (inherits(cond, "message")) {
  [10:46:11.561]                         invokeRestart("muffleMessage")
  [10:46:11.561]                         muffled <- TRUE
  [10:46:11.561]                       }
  [10:46:11.561]                       else if (inherits(cond, "warning")) {
  [10:46:11.561]                         invokeRestart("muffleWarning")
  [10:46:11.561]                         muffled <- TRUE
  [10:46:11.561]                       }
  [10:46:11.561]                       else if (inherits(cond, "condition")) {
  [10:46:11.561]                         computeRestarts <- base::computeRestarts
  [10:46:11.561]                         grepl <- base::grepl
  [10:46:11.561]                         is.null <- base::is.null
  [10:46:11.561]                         restarts <- computeRestarts(cond)
  [10:46:11.561]                         for (restart in restarts) {
  [10:46:11.561]                           name <- restart$name
  [10:46:11.561]                           if (is.null(name)) 
  [10:46:11.561]                             next
  [10:46:11.561]                           if (!grepl("^muffle", name)) 
  [10:46:11.561]                             next
  [10:46:11.561]                           invokeRestart(restart)
  [10:46:11.561]                           muffled <- TRUE
  [10:46:11.561]                           break
  [10:46:11.561]                         }
  [10:46:11.561]                       }
  [10:46:11.561]                       invisible(muffled)
  [10:46:11.561]                     }
  [10:46:11.561]                     muffleCondition(cond)
  [10:46:11.561]                   }
  [10:46:11.561]                 }
  [10:46:11.561]             }
  [10:46:11.561]         }))
  [10:46:11.561]     }, error = function(ex) {
  [10:46:11.561]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.561]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.561]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.561]     }, finally = {
  [10:46:11.561]         {
  [10:46:11.561]             NULL
  [10:46:11.561]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.561]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.561]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.561]                 label = NULL, ...) 
  [10:46:11.561]             {
  [10:46:11.561]                 if (substitute) 
  [10:46:11.561]                   expr <- substitute(expr)
  [10:46:11.561]                 local <- as.logical(local)
  [10:46:11.561]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.561]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.561]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.561]                   label = label, ...)
  [10:46:11.561]                 if (!future$lazy) 
  [10:46:11.561]                   future <- run(future)
  [10:46:11.561]                 invisible(future)
  [10:46:11.561]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.561]         }
  [10:46:11.561]         base::options(...future.oldOptions)
  [10:46:11.561]     })
  [10:46:11.561]     Sys.time
  [10:46:11.561]     if (base::is.na(TRUE)) {
  [10:46:11.561]     }
  [10:46:11.561]     else {
  [10:46:11.561]         base::sink(type = "output", split = FALSE)
  [10:46:11.561]         if (TRUE) {
  [10:46:11.561]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.561]         }
  [10:46:11.561]         else {
  [10:46:11.561]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.561]         }
  [10:46:11.561]         base::close(...future.stdout)
  [10:46:11.561]         ...future.stdout <- NULL
  [10:46:11.561]     }
  [10:46:11.561]     ...future.result$conditions <- ...future.conditions
  [10:46:11.561]     ...future.result
  [10:46:11.561] }
  [10:46:11.572] plan(): Setting new future strategy stack:
  [10:46:11.578] List of future strategies:
  [10:46:11.578] 1. sequential:
  [10:46:11.578]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.578]    - tweaked: FALSE
  [10:46:11.578]    - call: NULL
  [10:46:11.580] plan(): nbrOfWorkers() = 1
  [10:46:11.581] plan(): Setting new future strategy stack:
  [10:46:11.587] List of future strategies:
  [10:46:11.587] 1. sequential:
  [10:46:11.587]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.587]    - tweaked: FALSE
  [10:46:11.587]    - call: plan(strategy)
  [10:46:11.588] plan(): nbrOfWorkers() = 1
  [10:46:11.589] SequentialFuture started (and completed)
  [10:46:11.590] getGlobalsAndPackages() ...
  [10:46:11.591] Searching for globals...
  [10:46:11.598] - globals found: [3] '{', '*', 'a'
  [10:46:11.599] Searching for globals ... DONE
  [10:46:11.599] Resolving globals: FALSE
  [10:46:11.605] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:11.606] - globals: [1] 'a'
  [10:46:11.607] 
  [10:46:11.607] getGlobalsAndPackages() ... DONE
  [10:46:11.614] Packages needed by the future expression (n = 0): <none>
  [10:46:11.615] Packages needed by future strategies (n = 0): <none>
  [10:46:11.626] {
  [10:46:11.626]     {
  [10:46:11.626]         ...future.startTime <- base::Sys.time()
  [10:46:11.626]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.626]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.626]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.626]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.626]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.626]         {
  [10:46:11.626]             {
  [10:46:11.626]                 has_future <- base::requireNamespace("future", 
  [10:46:11.626]                   quietly = TRUE)
  [10:46:11.626]                 version <- if (has_future) 
  [10:46:11.626]                   utils::packageVersion("future")
  [10:46:11.626]                 else NULL
  [10:46:11.626]                 if (!has_future || version < "1.8.0") {
  [10:46:11.626]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.626]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.626]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.626]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.626]                       "release", "version")], collapse = " "), 
  [10:46:11.626]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.626]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.626]                     info)
  [10:46:11.626]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.626]                   if (!has_future) {
  [10:46:11.626]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.626]                       info)
  [10:46:11.626]                   }
  [10:46:11.626]                   else {
  [10:46:11.626]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.626]                       info, version)
  [10:46:11.626]                   }
  [10:46:11.626]                   base::stop(msg)
  [10:46:11.626]                 }
  [10:46:11.626]             }
  [10:46:11.626]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.626]         }
  [10:46:11.626]     }
  [10:46:11.626]     if (base::is.na(TRUE)) {
  [10:46:11.626]     }
  [10:46:11.626]     else {
  [10:46:11.626]         if (TRUE) {
  [10:46:11.626]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.626]                 open = "w")
  [10:46:11.626]         }
  [10:46:11.626]         else {
  [10:46:11.626]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.626]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.626]         }
  [10:46:11.626]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.626]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.626]             base::sink(type = "output", split = FALSE)
  [10:46:11.626]             base::close(...future.stdout)
  [10:46:11.626]         }, add = TRUE)
  [10:46:11.626]     }
  [10:46:11.626]     ...future.frame <- base::sys.nframe()
  [10:46:11.626]     ...future.conditions <- base::list()
  [10:46:11.626]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.626]     ...future.result <- base::tryCatch({
  [10:46:11.626]         base::withCallingHandlers({
  [10:46:11.626]             ...future.value <- base::withVisible(base::local({
  [10:46:11.626]                 2 * a
  [10:46:11.626]             }))
  [10:46:11.626]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.626]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.626]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.626]                 version = "1.8")
  [10:46:11.626]         }, condition = base::local({
  [10:46:11.626]             c <- base::c
  [10:46:11.626]             inherits <- base::inherits
  [10:46:11.626]             invokeRestart <- base::invokeRestart
  [10:46:11.626]             length <- base::length
  [10:46:11.626]             list <- base::list
  [10:46:11.626]             seq.int <- base::seq.int
  [10:46:11.626]             signalCondition <- base::signalCondition
  [10:46:11.626]             sys.calls <- base::sys.calls
  [10:46:11.626]             Sys.time <- base::Sys.time
  [10:46:11.626]             `[[` <- base::`[[`
  [10:46:11.626]             `+` <- base::`+`
  [10:46:11.626]             `<<-` <- base::`<<-`
  [10:46:11.626]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.626]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.626]                   3L)]
  [10:46:11.626]             }
  [10:46:11.626]             function(cond) {
  [10:46:11.626]                 if (inherits(cond, "error")) {
  [10:46:11.626]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.626]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.626]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.626]                   signalCondition(cond)
  [10:46:11.626]                 }
  [10:46:11.626]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.626]                 ))) {
  [10:46:11.626]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.626]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.626]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.626]                   if (!signal) {
  [10:46:11.626]                     muffleCondition <- function (cond) 
  [10:46:11.626]                     {
  [10:46:11.626]                       inherits <- base::inherits
  [10:46:11.626]                       invokeRestart <- base::invokeRestart
  [10:46:11.626]                       muffled <- FALSE
  [10:46:11.626]                       if (inherits(cond, "message")) {
  [10:46:11.626]                         invokeRestart("muffleMessage")
  [10:46:11.626]                         muffled <- TRUE
  [10:46:11.626]                       }
  [10:46:11.626]                       else if (inherits(cond, "warning")) {
  [10:46:11.626]                         invokeRestart("muffleWarning")
  [10:46:11.626]                         muffled <- TRUE
  [10:46:11.626]                       }
  [10:46:11.626]                       else if (inherits(cond, "condition")) {
  [10:46:11.626]                         computeRestarts <- base::computeRestarts
  [10:46:11.626]                         grepl <- base::grepl
  [10:46:11.626]                         is.null <- base::is.null
  [10:46:11.626]                         restarts <- computeRestarts(cond)
  [10:46:11.626]                         for (restart in restarts) {
  [10:46:11.626]                           name <- restart$name
  [10:46:11.626]                           if (is.null(name)) 
  [10:46:11.626]                             next
  [10:46:11.626]                           if (!grepl("^muffle", name)) 
  [10:46:11.626]                             next
  [10:46:11.626]                           invokeRestart(restart)
  [10:46:11.626]                           muffled <- TRUE
  [10:46:11.626]                           break
  [10:46:11.626]                         }
  [10:46:11.626]                       }
  [10:46:11.626]                       invisible(muffled)
  [10:46:11.626]                     }
  [10:46:11.626]                     muffleCondition(cond)
  [10:46:11.626]                   }
  [10:46:11.626]                 }
  [10:46:11.626]             }
  [10:46:11.626]         }))
  [10:46:11.626]     }, error = function(ex) {
  [10:46:11.626]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.626]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.626]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.626]     }, finally = {
  [10:46:11.626]         {
  [10:46:11.626]             NULL
  [10:46:11.626]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.626]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.626]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.626]                 label = NULL, ...) 
  [10:46:11.626]             {
  [10:46:11.626]                 if (substitute) 
  [10:46:11.626]                   expr <- substitute(expr)
  [10:46:11.626]                 local <- as.logical(local)
  [10:46:11.626]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.626]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.626]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.626]                   label = label, ...)
  [10:46:11.626]                 if (!future$lazy) 
  [10:46:11.626]                   future <- run(future)
  [10:46:11.626]                 invisible(future)
  [10:46:11.626]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.626]         }
  [10:46:11.626]         base::options(...future.oldOptions)
  [10:46:11.626]     })
  [10:46:11.626]     Sys.time
  [10:46:11.626]     if (base::is.na(TRUE)) {
  [10:46:11.626]     }
  [10:46:11.626]     else {
  [10:46:11.626]         base::sink(type = "output", split = FALSE)
  [10:46:11.626]         if (TRUE) {
  [10:46:11.626]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.626]         }
  [10:46:11.626]         else {
  [10:46:11.626]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.626]         }
  [10:46:11.626]         base::close(...future.stdout)
  [10:46:11.626]         ...future.stdout <- NULL
  [10:46:11.626]     }
  [10:46:11.626]     ...future.result$conditions <- ...future.conditions
  [10:46:11.626]     ...future.result
  [10:46:11.626] }
  [10:46:11.642] plan(): Setting new future strategy stack:
  [10:46:11.643] List of future strategies:
  [10:46:11.643] 1. sequential:
  [10:46:11.643]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.643]    - tweaked: FALSE
  [10:46:11.643]    - call: NULL
  [10:46:11.644] plan(): nbrOfWorkers() = 1
  [10:46:11.660] plan(): Setting new future strategy stack:
  [10:46:11.661] List of future strategies:
  [10:46:11.661] 1. sequential:
  [10:46:11.661]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.661]    - tweaked: FALSE
  [10:46:11.661]    - call: plan(strategy)
  [10:46:11.662] plan(): nbrOfWorkers() = 1
  [10:46:11.663] SequentialFuture started (and completed)
  [10:46:11.676] getGlobalsAndPackages() ...
  [10:46:11.677] Searching for globals...
  [10:46:11.679] - globals found: [3] '{', '*', 'a'
  [10:46:11.680] Searching for globals ... DONE
  [10:46:11.680] Resolving globals: FALSE
  [10:46:11.695] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:11.696] - globals: [1] 'a'
  [10:46:11.696] 
  [10:46:11.697] getGlobalsAndPackages() ... DONE
  [10:46:11.699] Packages needed by the future expression (n = 0): <none>
  [10:46:11.715] Packages needed by future strategies (n = 0): <none>
  [10:46:11.737] {
  [10:46:11.737]     {
  [10:46:11.737]         ...future.startTime <- base::Sys.time()
  [10:46:11.737]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.737]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.737]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.737]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.737]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.737]         {
  [10:46:11.737]             {
  [10:46:11.737]                 has_future <- base::requireNamespace("future", 
  [10:46:11.737]                   quietly = TRUE)
  [10:46:11.737]                 version <- if (has_future) 
  [10:46:11.737]                   utils::packageVersion("future")
  [10:46:11.737]                 else NULL
  [10:46:11.737]                 if (!has_future || version < "1.8.0") {
  [10:46:11.737]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.737]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.737]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.737]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.737]                       "release", "version")], collapse = " "), 
  [10:46:11.737]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.737]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.737]                     info)
  [10:46:11.737]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.737]                   if (!has_future) {
  [10:46:11.737]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.737]                       info)
  [10:46:11.737]                   }
  [10:46:11.737]                   else {
  [10:46:11.737]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.737]                       info, version)
  [10:46:11.737]                   }
  [10:46:11.737]                   base::stop(msg)
  [10:46:11.737]                 }
  [10:46:11.737]             }
  [10:46:11.737]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.737]         }
  [10:46:11.737]     }
  [10:46:11.737]     if (base::is.na(TRUE)) {
  [10:46:11.737]     }
  [10:46:11.737]     else {
  [10:46:11.737]         if (TRUE) {
  [10:46:11.737]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.737]                 open = "w")
  [10:46:11.737]         }
  [10:46:11.737]         else {
  [10:46:11.737]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.737]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.737]         }
  [10:46:11.737]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.737]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.737]             base::sink(type = "output", split = FALSE)
  [10:46:11.737]             base::close(...future.stdout)
  [10:46:11.737]         }, add = TRUE)
  [10:46:11.737]     }
  [10:46:11.737]     ...future.frame <- base::sys.nframe()
  [10:46:11.737]     ...future.conditions <- base::list()
  [10:46:11.737]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.737]     ...future.result <- base::tryCatch({
  [10:46:11.737]         base::withCallingHandlers({
  [10:46:11.737]             ...future.value <- base::withVisible(base::local({
  [10:46:11.737]                 2 * a
  [10:46:11.737]             }))
  [10:46:11.737]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.737]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.737]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.737]                 version = "1.8")
  [10:46:11.737]         }, condition = base::local({
  [10:46:11.737]             c <- base::c
  [10:46:11.737]             inherits <- base::inherits
  [10:46:11.737]             invokeRestart <- base::invokeRestart
  [10:46:11.737]             length <- base::length
  [10:46:11.737]             list <- base::list
  [10:46:11.737]             seq.int <- base::seq.int
  [10:46:11.737]             signalCondition <- base::signalCondition
  [10:46:11.737]             sys.calls <- base::sys.calls
  [10:46:11.737]             Sys.time <- base::Sys.time
  [10:46:11.737]             `[[` <- base::`[[`
  [10:46:11.737]             `+` <- base::`+`
  [10:46:11.737]             `<<-` <- base::`<<-`
  [10:46:11.737]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.737]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.737]                   3L)]
  [10:46:11.737]             }
  [10:46:11.737]             function(cond) {
  [10:46:11.737]                 if (inherits(cond, "error")) {
  [10:46:11.737]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.737]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.737]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.737]                   signalCondition(cond)
  [10:46:11.737]                 }
  [10:46:11.737]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.737]                 ))) {
  [10:46:11.737]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.737]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.737]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.737]                   if (!signal) {
  [10:46:11.737]                     muffleCondition <- function (cond) 
  [10:46:11.737]                     {
  [10:46:11.737]                       inherits <- base::inherits
  [10:46:11.737]                       invokeRestart <- base::invokeRestart
  [10:46:11.737]                       muffled <- FALSE
  [10:46:11.737]                       if (inherits(cond, "message")) {
  [10:46:11.737]                         invokeRestart("muffleMessage")
  [10:46:11.737]                         muffled <- TRUE
  [10:46:11.737]                       }
  [10:46:11.737]                       else if (inherits(cond, "warning")) {
  [10:46:11.737]                         invokeRestart("muffleWarning")
  [10:46:11.737]                         muffled <- TRUE
  [10:46:11.737]                       }
  [10:46:11.737]                       else if (inherits(cond, "condition")) {
  [10:46:11.737]                         computeRestarts <- base::computeRestarts
  [10:46:11.737]                         grepl <- base::grepl
  [10:46:11.737]                         is.null <- base::is.null
  [10:46:11.737]                         restarts <- computeRestarts(cond)
  [10:46:11.737]                         for (restart in restarts) {
  [10:46:11.737]                           name <- restart$name
  [10:46:11.737]                           if (is.null(name)) 
  [10:46:11.737]                             next
  [10:46:11.737]                           if (!grepl("^muffle", name)) 
  [10:46:11.737]                             next
  [10:46:11.737]                           invokeRestart(restart)
  [10:46:11.737]                           muffled <- TRUE
  [10:46:11.737]                           break
  [10:46:11.737]                         }
  [10:46:11.737]                       }
  [10:46:11.737]                       invisible(muffled)
  [10:46:11.737]                     }
  [10:46:11.737]                     muffleCondition(cond)
  [10:46:11.737]                   }
  [10:46:11.737]                 }
  [10:46:11.737]             }
  [10:46:11.737]         }))
  [10:46:11.737]     }, error = function(ex) {
  [10:46:11.737]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.737]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.737]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.737]     }, finally = {
  [10:46:11.737]         {
  [10:46:11.737]             NULL
  [10:46:11.737]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.737]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.737]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.737]                 label = NULL, ...) 
  [10:46:11.737]             {
  [10:46:11.737]                 if (substitute) 
  [10:46:11.737]                   expr <- substitute(expr)
  [10:46:11.737]                 local <- as.logical(local)
  [10:46:11.737]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.737]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.737]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.737]                   label = label, ...)
  [10:46:11.737]                 if (!future$lazy) 
  [10:46:11.737]                   future <- run(future)
  [10:46:11.737]                 invisible(future)
  [10:46:11.737]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.737]         }
  [10:46:11.737]         base::options(...future.oldOptions)
  [10:46:11.737]     })
  [10:46:11.737]     Sys.time
  [10:46:11.737]     if (base::is.na(TRUE)) {
  [10:46:11.737]     }
  [10:46:11.737]     else {
  [10:46:11.737]         base::sink(type = "output", split = FALSE)
  [10:46:11.737]         if (TRUE) {
  [10:46:11.737]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.737]         }
  [10:46:11.737]         else {
  [10:46:11.737]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.737]         }
  [10:46:11.737]         base::close(...future.stdout)
  [10:46:11.737]         ...future.stdout <- NULL
  [10:46:11.737]     }
  [10:46:11.737]     ...future.result$conditions <- ...future.conditions
  [10:46:11.737]     ...future.result
  [10:46:11.737] }
  [10:46:11.759] plan(): Setting new future strategy stack:
  [10:46:11.759] List of future strategies:
  [10:46:11.759] 1. sequential:
  [10:46:11.759]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.759]    - tweaked: FALSE
  [10:46:11.759]    - call: NULL
  [10:46:11.761] plan(): nbrOfWorkers() = 1
  [10:46:11.763] plan(): Setting new future strategy stack:
  [10:46:11.763] List of future strategies:
  [10:46:11.763] 1. sequential:
  [10:46:11.763]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.763]    - tweaked: FALSE
  [10:46:11.763]    - call: plan(strategy)
  [10:46:11.785] plan(): nbrOfWorkers() = 1
  [10:46:11.786] SequentialFuture started (and completed)
  [10:46:11.787] getGlobalsAndPackages() ...
  [10:46:11.787] Searching for globals...
  [10:46:11.795] - globals found: [3] '{', '*', 'a'
  [10:46:11.795] Searching for globals ... DONE
  [10:46:11.796] Resolving globals: FALSE
  [10:46:11.797] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:11.803] - globals: [1] 'a'
  [10:46:11.803] 
  [10:46:11.804] getGlobalsAndPackages() ... DONE
  [10:46:11.812] Packages needed by the future expression (n = 0): <none>
  [10:46:11.812] Packages needed by future strategies (n = 0): <none>
  [10:46:11.831] {
  [10:46:11.831]     {
  [10:46:11.831]         ...future.startTime <- base::Sys.time()
  [10:46:11.831]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.831]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.831]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.831]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.831]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.831]         {
  [10:46:11.831]             {
  [10:46:11.831]                 has_future <- base::requireNamespace("future", 
  [10:46:11.831]                   quietly = TRUE)
  [10:46:11.831]                 version <- if (has_future) 
  [10:46:11.831]                   utils::packageVersion("future")
  [10:46:11.831]                 else NULL
  [10:46:11.831]                 if (!has_future || version < "1.8.0") {
  [10:46:11.831]                   info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.831]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.831]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.831]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.831]                       "release", "version")], collapse = " "), 
  [10:46:11.831]                     hostname = base::Sys.info()[["nodename"]])
  [10:46:11.831]                   info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.831]                     info)
  [10:46:11.831]                   info <- base::paste(info, collapse = "; ")
  [10:46:11.831]                   if (!has_future) {
  [10:46:11.831]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.831]                       info)
  [10:46:11.831]                   }
  [10:46:11.831]                   else {
  [10:46:11.831]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.831]                       info, version)
  [10:46:11.831]                   }
  [10:46:11.831]                   base::stop(msg)
  [10:46:11.831]                 }
  [10:46:11.831]             }
  [10:46:11.831]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.831]         }
  [10:46:11.831]     }
  [10:46:11.831]     if (base::is.na(TRUE)) {
  [10:46:11.831]     }
  [10:46:11.831]     else {
  [10:46:11.831]         if (TRUE) {
  [10:46:11.831]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.831]                 open = "w")
  [10:46:11.831]         }
  [10:46:11.831]         else {
  [10:46:11.831]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.831]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.831]         }
  [10:46:11.831]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.831]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.831]             base::sink(type = "output", split = FALSE)
  [10:46:11.831]             base::close(...future.stdout)
  [10:46:11.831]         }, add = TRUE)
  [10:46:11.831]     }
  [10:46:11.831]     ...future.frame <- base::sys.nframe()
  [10:46:11.831]     ...future.conditions <- base::list()
  [10:46:11.831]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.831]     ...future.result <- base::tryCatch({
  [10:46:11.831]         base::withCallingHandlers({
  [10:46:11.831]             ...future.value <- base::withVisible(base::local({
  [10:46:11.831]                 2 * a
  [10:46:11.831]             }))
  [10:46:11.831]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.831]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.831]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.831]                 version = "1.8")
  [10:46:11.831]         }, condition = base::local({
  [10:46:11.831]             c <- base::c
  [10:46:11.831]             inherits <- base::inherits
  [10:46:11.831]             invokeRestart <- base::invokeRestart
  [10:46:11.831]             length <- base::length
  [10:46:11.831]             list <- base::list
  [10:46:11.831]             seq.int <- base::seq.int
  [10:46:11.831]             signalCondition <- base::signalCondition
  [10:46:11.831]             sys.calls <- base::sys.calls
  [10:46:11.831]             Sys.time <- base::Sys.time
  [10:46:11.831]             `[[` <- base::`[[`
  [10:46:11.831]             `+` <- base::`+`
  [10:46:11.831]             `<<-` <- base::`<<-`
  [10:46:11.831]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.831]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.831]                   3L)]
  [10:46:11.831]             }
  [10:46:11.831]             function(cond) {
  [10:46:11.831]                 if (inherits(cond, "error")) {
  [10:46:11.831]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.831]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.831]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.831]                   signalCondition(cond)
  [10:46:11.831]                 }
  [10:46:11.831]                 else if (inherits(cond, c("condition", "immediateCondition"
  [10:46:11.831]                 ))) {
  [10:46:11.831]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [10:46:11.831]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.831]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.831]                   if (!signal) {
  [10:46:11.831]                     muffleCondition <- function (cond) 
  [10:46:11.831]                     {
  [10:46:11.831]                       inherits <- base::inherits
  [10:46:11.831]                       invokeRestart <- base::invokeRestart
  [10:46:11.831]                       muffled <- FALSE
  [10:46:11.831]                       if (inherits(cond, "message")) {
  [10:46:11.831]                         invokeRestart("muffleMessage")
  [10:46:11.831]                         muffled <- TRUE
  [10:46:11.831]                       }
  [10:46:11.831]                       else if (inherits(cond, "warning")) {
  [10:46:11.831]                         invokeRestart("muffleWarning")
  [10:46:11.831]                         muffled <- TRUE
  [10:46:11.831]                       }
  [10:46:11.831]                       else if (inherits(cond, "condition")) {
  [10:46:11.831]                         computeRestarts <- base::computeRestarts
  [10:46:11.831]                         grepl <- base::grepl
  [10:46:11.831]                         is.null <- base::is.null
  [10:46:11.831]                         restarts <- computeRestarts(cond)
  [10:46:11.831]                         for (restart in restarts) {
  [10:46:11.831]                           name <- restart$name
  [10:46:11.831]                           if (is.null(name)) 
  [10:46:11.831]                             next
  [10:46:11.831]                           if (!grepl("^muffle", name)) 
  [10:46:11.831]                             next
  [10:46:11.831]                           invokeRestart(restart)
  [10:46:11.831]                           muffled <- TRUE
  [10:46:11.831]                           break
  [10:46:11.831]                         }
  [10:46:11.831]                       }
  [10:46:11.831]                       invisible(muffled)
  [10:46:11.831]                     }
  [10:46:11.831]                     muffleCondition(cond)
  [10:46:11.831]                   }
  [10:46:11.831]                 }
  [10:46:11.831]             }
  [10:46:11.831]         }))
  [10:46:11.831]     }, error = function(ex) {
  [10:46:11.831]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.831]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.831]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.831]     }, finally = {
  [10:46:11.831]         {
  [10:46:11.831]             NULL
  [10:46:11.831]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.831]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.831]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [10:46:11.831]                 label = NULL, ...) 
  [10:46:11.831]             {
  [10:46:11.831]                 if (substitute) 
  [10:46:11.831]                   expr <- substitute(expr)
  [10:46:11.831]                 local <- as.logical(local)
  [10:46:11.831]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [10:46:11.831]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.831]                   globals = globals, local = local, earlySignal = earlySignal, 
  [10:46:11.831]                   label = label, ...)
  [10:46:11.831]                 if (!future$lazy) 
  [10:46:11.831]                   future <- run(future)
  [10:46:11.831]                 invisible(future)
  [10:46:11.831]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.831]         }
  [10:46:11.831]         base::options(...future.oldOptions)
  [10:46:11.831]     })
  [10:46:11.831]     Sys.time
  [10:46:11.831]     if (base::is.na(TRUE)) {
  [10:46:11.831]     }
  [10:46:11.831]     else {
  [10:46:11.831]         base::sink(type = "output", split = FALSE)
  [10:46:11.831]         if (TRUE) {
  [10:46:11.831]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.831]         }
  [10:46:11.831]         else {
  [10:46:11.831]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.831]         }
  [10:46:11.831]         base::close(...future.stdout)
  [10:46:11.831]         ...future.stdout <- NULL
  [10:46:11.831]     }
  [10:46:11.831]     ...future.result$conditions <- ...future.conditions
  [10:46:11.831]     ...future.result
  [10:46:11.831] }
  [10:46:11.845] plan(): Setting new future strategy stack:
  [10:46:11.845] List of future strategies:
  [10:46:11.845] 1. sequential:
  [10:46:11.845]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.845]    - tweaked: FALSE
  [10:46:11.845]    - call: NULL
  [10:46:11.847] plan(): nbrOfWorkers() = 1
  [10:46:11.848] plan(): Setting new future strategy stack:
  [10:46:11.849] List of future strategies:
  [10:46:11.849] 1. sequential:
  [10:46:11.849]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.849]    - tweaked: FALSE
  [10:46:11.849]    - call: plan(strategy)
  [10:46:11.850] plan(): nbrOfWorkers() = 1
  [10:46:11.851] SequentialFuture started (and completed)
  *** futureAssign() with 'sequential' futures ... DONE
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  *** futureAssign() with 'multicore' futures ...
  [10:46:11.872] plan(): Setting new future strategy stack:
  [10:46:11.873] List of future strategies:
  [10:46:11.873] 1. multicore:
  [10:46:11.873]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:11.873]    - tweaked: FALSE
  [10:46:11.873]    - call: plan(strategy)
  [10:46:11.876] plan(): nbrOfWorkers() = 2
  [10:46:11.878] getGlobalsAndPackages() ...
  [10:46:11.879] Searching for globals...
  [10:46:11.880] - globals found: [1] '{'
  [10:46:11.881] Searching for globals ... DONE
  [10:46:11.881] Resolving globals: FALSE
  [10:46:11.882] 
  [10:46:11.883] 
  [10:46:11.883] getGlobalsAndPackages() ... DONE
  [10:46:11.887] Packages needed by the future expression (n = 0): <none>
  [10:46:11.887] Packages needed by future strategies (n = 0): <none>
  [10:46:11.894] {
  [10:46:11.894]     {
  [10:46:11.894]         ...future.startTime <- base::Sys.time()
  [10:46:11.894]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.894]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.894]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.894]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.894]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.894]         {
  [10:46:11.894]             {
  [10:46:11.894]                 {
  [10:46:11.894]                   has_future <- base::requireNamespace("future", 
  [10:46:11.894]                     quietly = TRUE)
  [10:46:11.894]                   version <- if (has_future) 
  [10:46:11.894]                     utils::packageVersion("future")
  [10:46:11.894]                   else NULL
  [10:46:11.894]                   if (!has_future || version < "1.8.0") {
  [10:46:11.894]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.894]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.894]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.894]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.894]                         "release", "version")], collapse = " "), 
  [10:46:11.894]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:11.894]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.894]                       info)
  [10:46:11.894]                     info <- base::paste(info, collapse = "; ")
  [10:46:11.894]                     if (!has_future) {
  [10:46:11.894]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.894]                         info)
  [10:46:11.894]                     }
  [10:46:11.894]                     else {
  [10:46:11.894]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.894]                         info, version)
  [10:46:11.894]                     }
  [10:46:11.894]                     base::stop(msg)
  [10:46:11.894]                   }
  [10:46:11.894]                 }
  [10:46:11.894]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:11.894]                 base::options(mc.cores = 1L)
  [10:46:11.894]             }
  [10:46:11.894]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.894]         }
  [10:46:11.894]     }
  [10:46:11.894]     if (base::is.na(TRUE)) {
  [10:46:11.894]     }
  [10:46:11.894]     else {
  [10:46:11.894]         if (TRUE) {
  [10:46:11.894]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.894]                 open = "w")
  [10:46:11.894]         }
  [10:46:11.894]         else {
  [10:46:11.894]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.894]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.894]         }
  [10:46:11.894]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.894]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.894]             base::sink(type = "output", split = FALSE)
  [10:46:11.894]             base::close(...future.stdout)
  [10:46:11.894]         }, add = TRUE)
  [10:46:11.894]     }
  [10:46:11.894]     ...future.frame <- base::sys.nframe()
  [10:46:11.894]     ...future.conditions <- base::list()
  [10:46:11.894]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.894]     ...future.result <- base::tryCatch({
  [10:46:11.894]         base::withCallingHandlers({
  [10:46:11.894]             ...future.value <- base::withVisible(base::local({
  [10:46:11.894]                 2
  [10:46:11.894]             }))
  [10:46:11.894]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.894]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.894]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.894]                 version = "1.8")
  [10:46:11.894]         }, condition = base::local({
  [10:46:11.894]             c <- base::c
  [10:46:11.894]             inherits <- base::inherits
  [10:46:11.894]             invokeRestart <- base::invokeRestart
  [10:46:11.894]             length <- base::length
  [10:46:11.894]             list <- base::list
  [10:46:11.894]             seq.int <- base::seq.int
  [10:46:11.894]             signalCondition <- base::signalCondition
  [10:46:11.894]             sys.calls <- base::sys.calls
  [10:46:11.894]             Sys.time <- base::Sys.time
  [10:46:11.894]             `[[` <- base::`[[`
  [10:46:11.894]             `+` <- base::`+`
  [10:46:11.894]             `<<-` <- base::`<<-`
  [10:46:11.894]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.894]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.894]                   3L)]
  [10:46:11.894]             }
  [10:46:11.894]             function(cond) {
  [10:46:11.894]                 if (inherits(cond, "error")) {
  [10:46:11.894]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.894]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.894]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.894]                   signalCondition(cond)
  [10:46:11.894]                 }
  [10:46:11.894]                 else if (inherits(cond, "condition")) {
  [10:46:11.894]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:11.894]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.894]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.894]                   if (!signal) {
  [10:46:11.894]                     muffleCondition <- function (cond) 
  [10:46:11.894]                     {
  [10:46:11.894]                       inherits <- base::inherits
  [10:46:11.894]                       invokeRestart <- base::invokeRestart
  [10:46:11.894]                       muffled <- FALSE
  [10:46:11.894]                       if (inherits(cond, "message")) {
  [10:46:11.894]                         invokeRestart("muffleMessage")
  [10:46:11.894]                         muffled <- TRUE
  [10:46:11.894]                       }
  [10:46:11.894]                       else if (inherits(cond, "warning")) {
  [10:46:11.894]                         invokeRestart("muffleWarning")
  [10:46:11.894]                         muffled <- TRUE
  [10:46:11.894]                       }
  [10:46:11.894]                       else if (inherits(cond, "condition")) {
  [10:46:11.894]                         computeRestarts <- base::computeRestarts
  [10:46:11.894]                         grepl <- base::grepl
  [10:46:11.894]                         is.null <- base::is.null
  [10:46:11.894]                         restarts <- computeRestarts(cond)
  [10:46:11.894]                         for (restart in restarts) {
  [10:46:11.894]                           name <- restart$name
  [10:46:11.894]                           if (is.null(name)) 
  [10:46:11.894]                             next
  [10:46:11.894]                           if (!grepl("^muffle", name)) 
  [10:46:11.894]                             next
  [10:46:11.894]                           invokeRestart(restart)
  [10:46:11.894]                           muffled <- TRUE
  [10:46:11.894]                           break
  [10:46:11.894]                         }
  [10:46:11.894]                       }
  [10:46:11.894]                       invisible(muffled)
  [10:46:11.894]                     }
  [10:46:11.894]                     muffleCondition(cond)
  [10:46:11.894]                   }
  [10:46:11.894]                 }
  [10:46:11.894]             }
  [10:46:11.894]         }))
  [10:46:11.894]     }, error = function(ex) {
  [10:46:11.894]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.894]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.894]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.894]     }, finally = {
  [10:46:11.894]         {
  [10:46:11.894]             {
  [10:46:11.894]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:11.894]             }
  [10:46:11.894]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.894]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.894]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:11.894]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:11.894]             {
  [10:46:11.894]                 if (substitute) 
  [10:46:11.894]                   expr <- substitute(expr)
  [10:46:11.894]                 if (is.function(workers)) 
  [10:46:11.894]                   workers <- workers()
  [10:46:11.894]                 workers <- as.integer(workers)
  [10:46:11.894]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:11.894]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:11.894]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:11.894]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:11.894]                     local = TRUE, label = label, ...))
  [10:46:11.894]                 }
  [10:46:11.894]                 oopts <- options(mc.cores = workers)
  [10:46:11.894]                 on.exit(options(oopts))
  [10:46:11.894]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:11.894]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.894]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:11.894]                   label = label, ...)
  [10:46:11.894]                 if (!future$lazy) 
  [10:46:11.894]                   future <- run(future)
  [10:46:11.894]                 invisible(future)
  [10:46:11.894]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.894]         }
  [10:46:11.894]         base::options(...future.oldOptions)
  [10:46:11.894]     })
  [10:46:11.894]     Sys.time
  [10:46:11.894]     if (base::is.na(TRUE)) {
  [10:46:11.894]     }
  [10:46:11.894]     else {
  [10:46:11.894]         base::sink(type = "output", split = FALSE)
  [10:46:11.894]         if (TRUE) {
  [10:46:11.894]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.894]         }
  [10:46:11.894]         else {
  [10:46:11.894]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.894]         }
  [10:46:11.894]         base::close(...future.stdout)
  [10:46:11.894]         ...future.stdout <- NULL
  [10:46:11.894]     }
  [10:46:11.894]     ...future.result$conditions <- ...future.conditions
  [10:46:11.894]     ...future.result
  [10:46:11.894] }
  [10:46:11.899] requestCore(): workers = 2
  [10:46:11.906] MulticoreFuture started
  [10:46:11.909] getGlobalsAndPackages() ...
  [10:46:11.910] Searching for globals...
  [10:46:11.913] - globals found: [1] '{'
  [10:46:11.914] Searching for globals ... DONE
  [10:46:11.915] Resolving globals: FALSE
  [10:46:11.916] 
  [10:46:11.917] 
  [10:46:11.917] getGlobalsAndPackages() ... DONE
  [10:46:11.921] Packages needed by the future expression (n = 0): <none>
  [10:46:11.922] Packages needed by future strategies (n = 0): <none>
  [10:46:11.928] plan(): Setting new future strategy stack:
  [10:46:11.929] List of future strategies:
  [10:46:11.929] 1. sequential:
  [10:46:11.929]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:11.929]    - tweaked: FALSE
  [10:46:11.929]    - call: NULL
  [10:46:11.932] plan(): nbrOfWorkers() = 1
  [10:46:11.934] plan(): Setting new future strategy stack:
  [10:46:11.935] List of future strategies:
  [10:46:11.935] 1. multicore:
  [10:46:11.935]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:11.935]    - tweaked: FALSE
  [10:46:11.935]    - call: plan(strategy)
  [10:46:11.947] plan(): nbrOfWorkers() = 2
  [10:46:11.944] {
  [10:46:11.944]     {
  [10:46:11.944]         ...future.startTime <- base::Sys.time()
  [10:46:11.944]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:11.944]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:11.944]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:11.944]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:11.944]             future.resolve.recursive = NULL, width = 80L)
  [10:46:11.944]         {
  [10:46:11.944]             {
  [10:46:11.944]                 {
  [10:46:11.944]                   has_future <- base::requireNamespace("future", 
  [10:46:11.944]                     quietly = TRUE)
  [10:46:11.944]                   version <- if (has_future) 
  [10:46:11.944]                     utils::packageVersion("future")
  [10:46:11.944]                   else NULL
  [10:46:11.944]                   if (!has_future || version < "1.8.0") {
  [10:46:11.944]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:11.944]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:11.944]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:11.944]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:11.944]                         "release", "version")], collapse = " "), 
  [10:46:11.944]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:11.944]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:11.944]                       info)
  [10:46:11.944]                     info <- base::paste(info, collapse = "; ")
  [10:46:11.944]                     if (!has_future) {
  [10:46:11.944]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:11.944]                         info)
  [10:46:11.944]                     }
  [10:46:11.944]                     else {
  [10:46:11.944]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:11.944]                         info, version)
  [10:46:11.944]                     }
  [10:46:11.944]                     base::stop(msg)
  [10:46:11.944]                   }
  [10:46:11.944]                 }
  [10:46:11.944]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:11.944]                 base::options(mc.cores = 1L)
  [10:46:11.944]             }
  [10:46:11.944]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:11.944]         }
  [10:46:11.944]     }
  [10:46:11.944]     if (base::is.na(TRUE)) {
  [10:46:11.944]     }
  [10:46:11.944]     else {
  [10:46:11.944]         if (TRUE) {
  [10:46:11.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:11.944]                 open = "w")
  [10:46:11.944]         }
  [10:46:11.944]         else {
  [10:46:11.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:11.944]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:11.944]         }
  [10:46:11.944]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:11.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:11.944]             base::sink(type = "output", split = FALSE)
  [10:46:11.944]             base::close(...future.stdout)
  [10:46:11.944]         }, add = TRUE)
  [10:46:11.944]     }
  [10:46:11.944]     ...future.frame <- base::sys.nframe()
  [10:46:11.944]     ...future.conditions <- base::list()
  [10:46:11.944]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:11.944]     ...future.result <- base::tryCatch({
  [10:46:11.944]         base::withCallingHandlers({
  [10:46:11.944]             ...future.value <- base::withVisible(base::local({
  [10:46:11.944]                 4
  [10:46:11.944]             }))
  [10:46:11.944]             future::FutureResult(value = ...future.value$value, 
  [10:46:11.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.944]                   ...future.rng), started = ...future.startTime, 
  [10:46:11.944]                 version = "1.8")
  [10:46:11.944]         }, condition = base::local({
  [10:46:11.944]             c <- base::c
  [10:46:11.944]             inherits <- base::inherits
  [10:46:11.944]             invokeRestart <- base::invokeRestart
  [10:46:11.944]             length <- base::length
  [10:46:11.944]             list <- base::list
  [10:46:11.944]             seq.int <- base::seq.int
  [10:46:11.944]             signalCondition <- base::signalCondition
  [10:46:11.944]             sys.calls <- base::sys.calls
  [10:46:11.944]             Sys.time <- base::Sys.time
  [10:46:11.944]             `[[` <- base::`[[`
  [10:46:11.944]             `+` <- base::`+`
  [10:46:11.944]             `<<-` <- base::`<<-`
  [10:46:11.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:11.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:11.944]                   3L)]
  [10:46:11.944]             }
  [10:46:11.944]             function(cond) {
  [10:46:11.944]                 if (inherits(cond, "error")) {
  [10:46:11.944]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:11.944]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:11.944]                   signalCondition(cond)
  [10:46:11.944]                 }
  [10:46:11.944]                 else if (inherits(cond, "condition")) {
  [10:46:11.944]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:11.944]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:11.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:11.944]                   if (!signal) {
  [10:46:11.944]                     muffleCondition <- function (cond) 
  [10:46:11.944]                     {
  [10:46:11.944]                       inherits <- base::inherits
  [10:46:11.944]                       invokeRestart <- base::invokeRestart
  [10:46:11.944]                       muffled <- FALSE
  [10:46:11.944]                       if (inherits(cond, "message")) {
  [10:46:11.944]                         invokeRestart("muffleMessage")
  [10:46:11.944]                         muffled <- TRUE
  [10:46:11.944]                       }
  [10:46:11.944]                       else if (inherits(cond, "warning")) {
  [10:46:11.944]                         invokeRestart("muffleWarning")
  [10:46:11.944]                         muffled <- TRUE
  [10:46:11.944]                       }
  [10:46:11.944]                       else if (inherits(cond, "condition")) {
  [10:46:11.944]                         computeRestarts <- base::computeRestarts
  [10:46:11.944]                         grepl <- base::grepl
  [10:46:11.944]                         is.null <- base::is.null
  [10:46:11.944]                         restarts <- computeRestarts(cond)
  [10:46:11.944]                         for (restart in restarts) {
  [10:46:11.944]                           name <- restart$name
  [10:46:11.944]                           if (is.null(name)) 
  [10:46:11.944]                             next
  [10:46:11.944]                           if (!grepl("^muffle", name)) 
  [10:46:11.944]                             next
  [10:46:11.944]                           invokeRestart(restart)
  [10:46:11.944]                           muffled <- TRUE
  [10:46:11.944]                           break
  [10:46:11.944]                         }
  [10:46:11.944]                       }
  [10:46:11.944]                       invisible(muffled)
  [10:46:11.944]                     }
  [10:46:11.944]                     muffleCondition(cond)
  [10:46:11.944]                   }
  [10:46:11.944]                 }
  [10:46:11.944]             }
  [10:46:11.944]         }))
  [10:46:11.944]     }, error = function(ex) {
  [10:46:11.944]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:11.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:11.944]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:11.944]     }, finally = {
  [10:46:11.944]         {
  [10:46:11.944]             {
  [10:46:11.944]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:11.944]             }
  [10:46:11.944]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:11.944]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:11.944]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:11.944]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:11.944]             {
  [10:46:11.944]                 if (substitute) 
  [10:46:11.944]                   expr <- substitute(expr)
  [10:46:11.944]                 if (is.function(workers)) 
  [10:46:11.944]                   workers <- workers()
  [10:46:11.944]                 workers <- as.integer(workers)
  [10:46:11.944]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:11.944]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:11.944]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:11.944]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:11.944]                     local = TRUE, label = label, ...))
  [10:46:11.944]                 }
  [10:46:11.944]                 oopts <- options(mc.cores = workers)
  [10:46:11.944]                 on.exit(options(oopts))
  [10:46:11.944]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:11.944]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:11.944]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:11.944]                   label = label, ...)
  [10:46:11.944]                 if (!future$lazy) 
  [10:46:11.944]                   future <- run(future)
  [10:46:11.944]                 invisible(future)
  [10:46:11.944]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:11.944]         }
  [10:46:11.944]         base::options(...future.oldOptions)
  [10:46:11.944]     })
  [10:46:11.944]     Sys.time
  [10:46:11.944]     if (base::is.na(TRUE)) {
  [10:46:11.944]     }
  [10:46:11.944]     else {
  [10:46:11.944]         base::sink(type = "output", split = FALSE)
  [10:46:11.944]         if (TRUE) {
  [10:46:11.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:11.944]         }
  [10:46:11.944]         else {
  [10:46:11.944]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:11.944]         }
  [10:46:11.944]         base::close(...future.stdout)
  [10:46:11.944]         ...future.stdout <- NULL
  [10:46:11.944]     }
  [10:46:11.944]     ...future.result$conditions <- ...future.conditions
  [10:46:11.944]     ...future.result
  [10:46:11.944] }
  [10:46:11.954] requestCore(): workers = 2
  [10:46:12.011] MulticoreFuture started
  [10:46:12.032] plan(): Setting new future strategy stack:
  [10:46:12.033] List of future strategies:
  [10:46:12.033] 1. sequential:
  [10:46:12.033]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.033]    - tweaked: FALSE
  [10:46:12.033]    - call: NULL
  [10:46:12.036] plan(): nbrOfWorkers() = 1
  u$a = 2
  [10:46:12.059] plan(): Setting new future strategy stack:
  [10:46:12.060] List of future strategies:
  [10:46:12.060] 1. multicore:
  [10:46:12.060]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.060]    - tweaked: FALSE
  [10:46:12.060]    - call: plan(strategy)
  [10:46:12.063] plan(): nbrOfWorkers() = 2
  v$a = 4
  [10:46:12.068] getGlobalsAndPackages() ...
  [10:46:12.069] Searching for globals...
  [10:46:12.073] - globals found: [3] '{', '*', 'a'
  [10:46:12.073] Searching for globals ... DONE
  [10:46:12.074] Resolving globals: FALSE
  [10:46:12.076] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:12.077] - globals: [1] 'a'
  [10:46:12.077] 
  [10:46:12.091] getGlobalsAndPackages() ... DONE
  [10:46:12.095] Packages needed by the future expression (n = 0): <none>
  [10:46:12.096] Packages needed by future strategies (n = 0): <none>
  [10:46:12.103] {
  [10:46:12.103]     {
  [10:46:12.103]         ...future.startTime <- base::Sys.time()
  [10:46:12.103]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:12.103]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:12.103]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:12.103]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:12.103]             future.resolve.recursive = NULL, width = 80L)
  [10:46:12.103]         {
  [10:46:12.103]             {
  [10:46:12.103]                 {
  [10:46:12.103]                   has_future <- base::requireNamespace("future", 
  [10:46:12.103]                     quietly = TRUE)
  [10:46:12.103]                   version <- if (has_future) 
  [10:46:12.103]                     utils::packageVersion("future")
  [10:46:12.103]                   else NULL
  [10:46:12.103]                   if (!has_future || version < "1.8.0") {
  [10:46:12.103]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:12.103]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:12.103]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:12.103]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:12.103]                         "release", "version")], collapse = " "), 
  [10:46:12.103]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:12.103]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:12.103]                       info)
  [10:46:12.103]                     info <- base::paste(info, collapse = "; ")
  [10:46:12.103]                     if (!has_future) {
  [10:46:12.103]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:12.103]                         info)
  [10:46:12.103]                     }
  [10:46:12.103]                     else {
  [10:46:12.103]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:12.103]                         info, version)
  [10:46:12.103]                     }
  [10:46:12.103]                     base::stop(msg)
  [10:46:12.103]                   }
  [10:46:12.103]                 }
  [10:46:12.103]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:12.103]                 base::options(mc.cores = 1L)
  [10:46:12.103]             }
  [10:46:12.103]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:12.103]         }
  [10:46:12.103]     }
  [10:46:12.103]     if (base::is.na(TRUE)) {
  [10:46:12.103]     }
  [10:46:12.103]     else {
  [10:46:12.103]         if (TRUE) {
  [10:46:12.103]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:12.103]                 open = "w")
  [10:46:12.103]         }
  [10:46:12.103]         else {
  [10:46:12.103]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:12.103]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:12.103]         }
  [10:46:12.103]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:12.103]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:12.103]             base::sink(type = "output", split = FALSE)
  [10:46:12.103]             base::close(...future.stdout)
  [10:46:12.103]         }, add = TRUE)
  [10:46:12.103]     }
  [10:46:12.103]     ...future.frame <- base::sys.nframe()
  [10:46:12.103]     ...future.conditions <- base::list()
  [10:46:12.103]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:12.103]     ...future.result <- base::tryCatch({
  [10:46:12.103]         base::withCallingHandlers({
  [10:46:12.103]             ...future.value <- base::withVisible(base::local({
  [10:46:12.103]                 2 * a
  [10:46:12.103]             }))
  [10:46:12.103]             future::FutureResult(value = ...future.value$value, 
  [10:46:12.103]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.103]                   ...future.rng), started = ...future.startTime, 
  [10:46:12.103]                 version = "1.8")
  [10:46:12.103]         }, condition = base::local({
  [10:46:12.103]             c <- base::c
  [10:46:12.103]             inherits <- base::inherits
  [10:46:12.103]             invokeRestart <- base::invokeRestart
  [10:46:12.103]             length <- base::length
  [10:46:12.103]             list <- base::list
  [10:46:12.103]             seq.int <- base::seq.int
  [10:46:12.103]             signalCondition <- base::signalCondition
  [10:46:12.103]             sys.calls <- base::sys.calls
  [10:46:12.103]             Sys.time <- base::Sys.time
  [10:46:12.103]             `[[` <- base::`[[`
  [10:46:12.103]             `+` <- base::`+`
  [10:46:12.103]             `<<-` <- base::`<<-`
  [10:46:12.103]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:12.103]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:12.103]                   3L)]
  [10:46:12.103]             }
  [10:46:12.103]             function(cond) {
  [10:46:12.103]                 if (inherits(cond, "error")) {
  [10:46:12.103]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.103]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:12.103]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:12.103]                   signalCondition(cond)
  [10:46:12.103]                 }
  [10:46:12.103]                 else if (inherits(cond, "condition")) {
  [10:46:12.103]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:12.103]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.103]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:12.103]                   if (!signal) {
  [10:46:12.103]                     muffleCondition <- function (cond) 
  [10:46:12.103]                     {
  [10:46:12.103]                       inherits <- base::inherits
  [10:46:12.103]                       invokeRestart <- base::invokeRestart
  [10:46:12.103]                       muffled <- FALSE
  [10:46:12.103]                       if (inherits(cond, "message")) {
  [10:46:12.103]                         invokeRestart("muffleMessage")
  [10:46:12.103]                         muffled <- TRUE
  [10:46:12.103]                       }
  [10:46:12.103]                       else if (inherits(cond, "warning")) {
  [10:46:12.103]                         invokeRestart("muffleWarning")
  [10:46:12.103]                         muffled <- TRUE
  [10:46:12.103]                       }
  [10:46:12.103]                       else if (inherits(cond, "condition")) {
  [10:46:12.103]                         computeRestarts <- base::computeRestarts
  [10:46:12.103]                         grepl <- base::grepl
  [10:46:12.103]                         is.null <- base::is.null
  [10:46:12.103]                         restarts <- computeRestarts(cond)
  [10:46:12.103]                         for (restart in restarts) {
  [10:46:12.103]                           name <- restart$name
  [10:46:12.103]                           if (is.null(name)) 
  [10:46:12.103]                             next
  [10:46:12.103]                           if (!grepl("^muffle", name)) 
  [10:46:12.103]                             next
  [10:46:12.103]                           invokeRestart(restart)
  [10:46:12.103]                           muffled <- TRUE
  [10:46:12.103]                           break
  [10:46:12.103]                         }
  [10:46:12.103]                       }
  [10:46:12.103]                       invisible(muffled)
  [10:46:12.103]                     }
  [10:46:12.103]                     muffleCondition(cond)
  [10:46:12.103]                   }
  [10:46:12.103]                 }
  [10:46:12.103]             }
  [10:46:12.103]         }))
  [10:46:12.103]     }, error = function(ex) {
  [10:46:12.103]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:12.103]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.103]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:12.103]     }, finally = {
  [10:46:12.103]         {
  [10:46:12.103]             {
  [10:46:12.103]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:12.103]             }
  [10:46:12.103]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:12.103]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:12.103]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:12.103]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:12.103]             {
  [10:46:12.103]                 if (substitute) 
  [10:46:12.103]                   expr <- substitute(expr)
  [10:46:12.103]                 if (is.function(workers)) 
  [10:46:12.103]                   workers <- workers()
  [10:46:12.103]                 workers <- as.integer(workers)
  [10:46:12.103]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:12.103]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:12.103]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:12.103]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:12.103]                     local = TRUE, label = label, ...))
  [10:46:12.103]                 }
  [10:46:12.103]                 oopts <- options(mc.cores = workers)
  [10:46:12.103]                 on.exit(options(oopts))
  [10:46:12.103]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:12.103]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:12.103]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:12.103]                   label = label, ...)
  [10:46:12.103]                 if (!future$lazy) 
  [10:46:12.103]                   future <- run(future)
  [10:46:12.103]                 invisible(future)
  [10:46:12.103]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:12.103]         }
  [10:46:12.103]         base::options(...future.oldOptions)
  [10:46:12.103]     })
  [10:46:12.103]     Sys.time
  [10:46:12.103]     if (base::is.na(TRUE)) {
  [10:46:12.103]     }
  [10:46:12.103]     else {
  [10:46:12.103]         base::sink(type = "output", split = FALSE)
  [10:46:12.103]         if (TRUE) {
  [10:46:12.103]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:12.103]         }
  [10:46:12.103]         else {
  [10:46:12.103]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:12.103]         }
  [10:46:12.103]         base::close(...future.stdout)
  [10:46:12.103]         ...future.stdout <- NULL
  [10:46:12.103]     }
  [10:46:12.103]     ...future.result$conditions <- ...future.conditions
  [10:46:12.103]     ...future.result
  [10:46:12.103] }
  [10:46:12.122] requestCore(): workers = 2
  [10:46:12.127] MulticoreFuture started
  [10:46:12.149] plan(): Setting new future strategy stack:
  [10:46:12.150] List of future strategies:
  [10:46:12.150] 1. sequential:
  [10:46:12.150]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.150]    - tweaked: FALSE
  [10:46:12.150]    - call: NULL
  [10:46:12.153] plan(): nbrOfWorkers() = 1
  [10:46:12.155] plan(): Setting new future strategy stack:
  [10:46:12.156] List of future strategies:
  [10:46:12.156] 1. multicore:
  [10:46:12.156]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.156]    - tweaked: FALSE
  [10:46:12.156]    - call: plan(strategy)
  [10:46:12.178] plan(): nbrOfWorkers() = 2
  [10:46:12.190] getGlobalsAndPackages() ...
  [10:46:12.191] Searching for globals...
  [10:46:12.195] - globals found: [3] '{', '*', 'a'
  [10:46:12.196] Searching for globals ... DONE
  [10:46:12.196] Resolving globals: FALSE
  [10:46:12.199] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:12.199] - globals: [1] 'a'
  [10:46:12.200] 
  [10:46:12.205] getGlobalsAndPackages() ... DONE
  [10:46:12.209] Packages needed by the future expression (n = 0): <none>
  [10:46:12.210] Packages needed by future strategies (n = 0): <none>
  [10:46:12.234] {
  [10:46:12.234]     {
  [10:46:12.234]         ...future.startTime <- base::Sys.time()
  [10:46:12.234]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:12.234]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:12.234]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:12.234]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:12.234]             future.resolve.recursive = NULL, width = 80L)
  [10:46:12.234]         {
  [10:46:12.234]             {
  [10:46:12.234]                 {
  [10:46:12.234]                   has_future <- base::requireNamespace("future", 
  [10:46:12.234]                     quietly = TRUE)
  [10:46:12.234]                   version <- if (has_future) 
  [10:46:12.234]                     utils::packageVersion("future")
  [10:46:12.234]                   else NULL
  [10:46:12.234]                   if (!has_future || version < "1.8.0") {
  [10:46:12.234]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:12.234]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:12.234]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:12.234]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:12.234]                         "release", "version")], collapse = " "), 
  [10:46:12.234]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:12.234]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:12.234]                       info)
  [10:46:12.234]                     info <- base::paste(info, collapse = "; ")
  [10:46:12.234]                     if (!has_future) {
  [10:46:12.234]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:12.234]                         info)
  [10:46:12.234]                     }
  [10:46:12.234]                     else {
  [10:46:12.234]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:12.234]                         info, version)
  [10:46:12.234]                     }
  [10:46:12.234]                     base::stop(msg)
  [10:46:12.234]                   }
  [10:46:12.234]                 }
  [10:46:12.234]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:12.234]                 base::options(mc.cores = 1L)
  [10:46:12.234]             }
  [10:46:12.234]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:12.234]         }
  [10:46:12.234]     }
  [10:46:12.234]     if (base::is.na(TRUE)) {
  [10:46:12.234]     }
  [10:46:12.234]     else {
  [10:46:12.234]         if (TRUE) {
  [10:46:12.234]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:12.234]                 open = "w")
  [10:46:12.234]         }
  [10:46:12.234]         else {
  [10:46:12.234]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:12.234]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:12.234]         }
  [10:46:12.234]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:12.234]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:12.234]             base::sink(type = "output", split = FALSE)
  [10:46:12.234]             base::close(...future.stdout)
  [10:46:12.234]         }, add = TRUE)
  [10:46:12.234]     }
  [10:46:12.234]     ...future.frame <- base::sys.nframe()
  [10:46:12.234]     ...future.conditions <- base::list()
  [10:46:12.234]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:12.234]     ...future.result <- base::tryCatch({
  [10:46:12.234]         base::withCallingHandlers({
  [10:46:12.234]             ...future.value <- base::withVisible(base::local({
  [10:46:12.234]                 2 * a
  [10:46:12.234]             }))
  [10:46:12.234]             future::FutureResult(value = ...future.value$value, 
  [10:46:12.234]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.234]                   ...future.rng), started = ...future.startTime, 
  [10:46:12.234]                 version = "1.8")
  [10:46:12.234]         }, condition = base::local({
  [10:46:12.234]             c <- base::c
  [10:46:12.234]             inherits <- base::inherits
  [10:46:12.234]             invokeRestart <- base::invokeRestart
  [10:46:12.234]             length <- base::length
  [10:46:12.234]             list <- base::list
  [10:46:12.234]             seq.int <- base::seq.int
  [10:46:12.234]             signalCondition <- base::signalCondition
  [10:46:12.234]             sys.calls <- base::sys.calls
  [10:46:12.234]             Sys.time <- base::Sys.time
  [10:46:12.234]             `[[` <- base::`[[`
  [10:46:12.234]             `+` <- base::`+`
  [10:46:12.234]             `<<-` <- base::`<<-`
  [10:46:12.234]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:12.234]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:12.234]                   3L)]
  [10:46:12.234]             }
  [10:46:12.234]             function(cond) {
  [10:46:12.234]                 if (inherits(cond, "error")) {
  [10:46:12.234]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.234]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:12.234]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:12.234]                   signalCondition(cond)
  [10:46:12.234]                 }
  [10:46:12.234]                 else if (inherits(cond, "condition")) {
  [10:46:12.234]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:12.234]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.234]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:12.234]                   if (!signal) {
  [10:46:12.234]                     muffleCondition <- function (cond) 
  [10:46:12.234]                     {
  [10:46:12.234]                       inherits <- base::inherits
  [10:46:12.234]                       invokeRestart <- base::invokeRestart
  [10:46:12.234]                       muffled <- FALSE
  [10:46:12.234]                       if (inherits(cond, "message")) {
  [10:46:12.234]                         invokeRestart("muffleMessage")
  [10:46:12.234]                         muffled <- TRUE
  [10:46:12.234]                       }
  [10:46:12.234]                       else if (inherits(cond, "warning")) {
  [10:46:12.234]                         invokeRestart("muffleWarning")
  [10:46:12.234]                         muffled <- TRUE
  [10:46:12.234]                       }
  [10:46:12.234]                       else if (inherits(cond, "condition")) {
  [10:46:12.234]                         computeRestarts <- base::computeRestarts
  [10:46:12.234]                         grepl <- base::grepl
  [10:46:12.234]                         is.null <- base::is.null
  [10:46:12.234]                         restarts <- computeRestarts(cond)
  [10:46:12.234]                         for (restart in restarts) {
  [10:46:12.234]                           name <- restart$name
  [10:46:12.234]                           if (is.null(name)) 
  [10:46:12.234]                             next
  [10:46:12.234]                           if (!grepl("^muffle", name)) 
  [10:46:12.234]                             next
  [10:46:12.234]                           invokeRestart(restart)
  [10:46:12.234]                           muffled <- TRUE
  [10:46:12.234]                           break
  [10:46:12.234]                         }
  [10:46:12.234]                       }
  [10:46:12.234]                       invisible(muffled)
  [10:46:12.234]                     }
  [10:46:12.234]                     muffleCondition(cond)
  [10:46:12.234]                   }
  [10:46:12.234]                 }
  [10:46:12.234]             }
  [10:46:12.234]         }))
  [10:46:12.234]     }, error = function(ex) {
  [10:46:12.234]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:12.234]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.234]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:12.234]     }, finally = {
  [10:46:12.234]         {
  [10:46:12.234]             {
  [10:46:12.234]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:12.234]             }
  [10:46:12.234]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:12.234]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:12.234]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:12.234]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:12.234]             {
  [10:46:12.234]                 if (substitute) 
  [10:46:12.234]                   expr <- substitute(expr)
  [10:46:12.234]                 if (is.function(workers)) 
  [10:46:12.234]                   workers <- workers()
  [10:46:12.234]                 workers <- as.integer(workers)
  [10:46:12.234]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:12.234]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:12.234]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:12.234]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:12.234]                     local = TRUE, label = label, ...))
  [10:46:12.234]                 }
  [10:46:12.234]                 oopts <- options(mc.cores = workers)
  [10:46:12.234]                 on.exit(options(oopts))
  [10:46:12.234]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:12.234]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:12.234]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:12.234]                   label = label, ...)
  [10:46:12.234]                 if (!future$lazy) 
  [10:46:12.234]                   future <- run(future)
  [10:46:12.234]                 invisible(future)
  [10:46:12.234]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:12.234]         }
  [10:46:12.234]         base::options(...future.oldOptions)
  [10:46:12.234]     })
  [10:46:12.234]     Sys.time
  [10:46:12.234]     if (base::is.na(TRUE)) {
  [10:46:12.234]     }
  [10:46:12.234]     else {
  [10:46:12.234]         base::sink(type = "output", split = FALSE)
  [10:46:12.234]         if (TRUE) {
  [10:46:12.234]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:12.234]         }
  [10:46:12.234]         else {
  [10:46:12.234]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:12.234]         }
  [10:46:12.234]         base::close(...future.stdout)
  [10:46:12.234]         ...future.stdout <- NULL
  [10:46:12.234]     }
  [10:46:12.234]     ...future.result$conditions <- ...future.conditions
  [10:46:12.234]     ...future.result
  [10:46:12.234] }
  [10:46:12.250] requestCore(): workers = 2
  [10:46:12.258] MulticoreFuture started
  [10:46:12.265] plan(): Setting new future strategy stack:
  [10:46:12.266] List of future strategies:
  [10:46:12.266] 1. sequential:
  [10:46:12.266]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.266]    - tweaked: FALSE
  [10:46:12.266]    - call: NULL
  [10:46:12.273] plan(): nbrOfWorkers() = 1
  [10:46:12.281] plan(): Setting new future strategy stack:
  [10:46:12.282] List of future strategies:
  [10:46:12.282] 1. multicore:
  [10:46:12.282]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.282]    - tweaked: FALSE
  [10:46:12.282]    - call: plan(strategy)
  [10:46:12.290] plan(): nbrOfWorkers() = 2
  [10:46:12.294] getGlobalsAndPackages() ...
  [10:46:12.295] Searching for globals...
  [10:46:12.304] - globals found: [3] '{', '*', 'a'
  [10:46:12.305] Searching for globals ... DONE
  [10:46:12.305] Resolving globals: FALSE
  [10:46:12.312] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:12.312] - globals: [1] 'a'
  [10:46:12.313] 
  [10:46:12.313] getGlobalsAndPackages() ... DONE
  [10:46:12.323] Packages needed by the future expression (n = 0): <none>
  [10:46:12.324] Packages needed by future strategies (n = 0): <none>
  [10:46:12.342] {
  [10:46:12.342]     {
  [10:46:12.342]         ...future.startTime <- base::Sys.time()
  [10:46:12.342]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:12.342]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:12.342]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:12.342]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:12.342]             future.resolve.recursive = NULL, width = 80L)
  [10:46:12.342]         {
  [10:46:12.342]             {
  [10:46:12.342]                 {
  [10:46:12.342]                   has_future <- base::requireNamespace("future", 
  [10:46:12.342]                     quietly = TRUE)
  [10:46:12.342]                   version <- if (has_future) 
  [10:46:12.342]                     utils::packageVersion("future")
  [10:46:12.342]                   else NULL
  [10:46:12.342]                   if (!has_future || version < "1.8.0") {
  [10:46:12.342]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:12.342]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:12.342]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:12.342]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:12.342]                         "release", "version")], collapse = " "), 
  [10:46:12.342]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:12.342]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:12.342]                       info)
  [10:46:12.342]                     info <- base::paste(info, collapse = "; ")
  [10:46:12.342]                     if (!has_future) {
  [10:46:12.342]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:12.342]                         info)
  [10:46:12.342]                     }
  [10:46:12.342]                     else {
  [10:46:12.342]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:12.342]                         info, version)
  [10:46:12.342]                     }
  [10:46:12.342]                     base::stop(msg)
  [10:46:12.342]                   }
  [10:46:12.342]                 }
  [10:46:12.342]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:12.342]                 base::options(mc.cores = 1L)
  [10:46:12.342]             }
  [10:46:12.342]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:12.342]         }
  [10:46:12.342]     }
  [10:46:12.342]     if (base::is.na(TRUE)) {
  [10:46:12.342]     }
  [10:46:12.342]     else {
  [10:46:12.342]         if (TRUE) {
  [10:46:12.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:12.342]                 open = "w")
  [10:46:12.342]         }
  [10:46:12.342]         else {
  [10:46:12.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:12.342]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:12.342]         }
  [10:46:12.342]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:12.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:12.342]             base::sink(type = "output", split = FALSE)
  [10:46:12.342]             base::close(...future.stdout)
  [10:46:12.342]         }, add = TRUE)
  [10:46:12.342]     }
  [10:46:12.342]     ...future.frame <- base::sys.nframe()
  [10:46:12.342]     ...future.conditions <- base::list()
  [10:46:12.342]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:12.342]     ...future.result <- base::tryCatch({
  [10:46:12.342]         base::withCallingHandlers({
  [10:46:12.342]             ...future.value <- base::withVisible(base::local({
  [10:46:12.342]                 2 * a
  [10:46:12.342]             }))
  [10:46:12.342]             future::FutureResult(value = ...future.value$value, 
  [10:46:12.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.342]                   ...future.rng), started = ...future.startTime, 
  [10:46:12.342]                 version = "1.8")
  [10:46:12.342]         }, condition = base::local({
  [10:46:12.342]             c <- base::c
  [10:46:12.342]             inherits <- base::inherits
  [10:46:12.342]             invokeRestart <- base::invokeRestart
  [10:46:12.342]             length <- base::length
  [10:46:12.342]             list <- base::list
  [10:46:12.342]             seq.int <- base::seq.int
  [10:46:12.342]             signalCondition <- base::signalCondition
  [10:46:12.342]             sys.calls <- base::sys.calls
  [10:46:12.342]             Sys.time <- base::Sys.time
  [10:46:12.342]             `[[` <- base::`[[`
  [10:46:12.342]             `+` <- base::`+`
  [10:46:12.342]             `<<-` <- base::`<<-`
  [10:46:12.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:12.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:12.342]                   3L)]
  [10:46:12.342]             }
  [10:46:12.342]             function(cond) {
  [10:46:12.342]                 if (inherits(cond, "error")) {
  [10:46:12.342]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:12.342]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:12.342]                   signalCondition(cond)
  [10:46:12.342]                 }
  [10:46:12.342]                 else if (inherits(cond, "condition")) {
  [10:46:12.342]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:12.342]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:12.342]                   if (!signal) {
  [10:46:12.342]                     muffleCondition <- function (cond) 
  [10:46:12.342]                     {
  [10:46:12.342]                       inherits <- base::inherits
  [10:46:12.342]                       invokeRestart <- base::invokeRestart
  [10:46:12.342]                       muffled <- FALSE
  [10:46:12.342]                       if (inherits(cond, "message")) {
  [10:46:12.342]                         invokeRestart("muffleMessage")
  [10:46:12.342]                         muffled <- TRUE
  [10:46:12.342]                       }
  [10:46:12.342]                       else if (inherits(cond, "warning")) {
  [10:46:12.342]                         invokeRestart("muffleWarning")
  [10:46:12.342]                         muffled <- TRUE
  [10:46:12.342]                       }
  [10:46:12.342]                       else if (inherits(cond, "condition")) {
  [10:46:12.342]                         computeRestarts <- base::computeRestarts
  [10:46:12.342]                         grepl <- base::grepl
  [10:46:12.342]                         is.null <- base::is.null
  [10:46:12.342]                         restarts <- computeRestarts(cond)
  [10:46:12.342]                         for (restart in restarts) {
  [10:46:12.342]                           name <- restart$name
  [10:46:12.342]                           if (is.null(name)) 
  [10:46:12.342]                             next
  [10:46:12.342]                           if (!grepl("^muffle", name)) 
  [10:46:12.342]                             next
  [10:46:12.342]                           invokeRestart(restart)
  [10:46:12.342]                           muffled <- TRUE
  [10:46:12.342]                           break
  [10:46:12.342]                         }
  [10:46:12.342]                       }
  [10:46:12.342]                       invisible(muffled)
  [10:46:12.342]                     }
  [10:46:12.342]                     muffleCondition(cond)
  [10:46:12.342]                   }
  [10:46:12.342]                 }
  [10:46:12.342]             }
  [10:46:12.342]         }))
  [10:46:12.342]     }, error = function(ex) {
  [10:46:12.342]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:12.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.342]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:12.342]     }, finally = {
  [10:46:12.342]         {
  [10:46:12.342]             {
  [10:46:12.342]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:12.342]             }
  [10:46:12.342]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:12.342]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:12.342]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:12.342]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:12.342]             {
  [10:46:12.342]                 if (substitute) 
  [10:46:12.342]                   expr <- substitute(expr)
  [10:46:12.342]                 if (is.function(workers)) 
  [10:46:12.342]                   workers <- workers()
  [10:46:12.342]                 workers <- as.integer(workers)
  [10:46:12.342]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:12.342]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:12.342]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:12.342]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:12.342]                     local = TRUE, label = label, ...))
  [10:46:12.342]                 }
  [10:46:12.342]                 oopts <- options(mc.cores = workers)
  [10:46:12.342]                 on.exit(options(oopts))
  [10:46:12.342]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:12.342]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:12.342]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:12.342]                   label = label, ...)
  [10:46:12.342]                 if (!future$lazy) 
  [10:46:12.342]                   future <- run(future)
  [10:46:12.342]                 invisible(future)
  [10:46:12.342]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:12.342]         }
  [10:46:12.342]         base::options(...future.oldOptions)
  [10:46:12.342]     })
  [10:46:12.342]     Sys.time
  [10:46:12.342]     if (base::is.na(TRUE)) {
  [10:46:12.342]     }
  [10:46:12.342]     else {
  [10:46:12.342]         base::sink(type = "output", split = FALSE)
  [10:46:12.342]         if (TRUE) {
  [10:46:12.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:12.342]         }
  [10:46:12.342]         else {
  [10:46:12.342]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:12.342]         }
  [10:46:12.342]         base::close(...future.stdout)
  [10:46:12.342]         ...future.stdout <- NULL
  [10:46:12.342]     }
  [10:46:12.342]     ...future.result$conditions <- ...future.conditions
  [10:46:12.342]     ...future.result
  [10:46:12.342] }
  [10:46:12.359] requestCore(): workers = 2
  [10:46:12.369] MulticoreFuture started
  [10:46:12.379] plan(): Setting new future strategy stack:
  [10:46:12.380] List of future strategies:
  [10:46:12.380] 1. sequential:
  [10:46:12.380]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.380]    - tweaked: FALSE
  [10:46:12.380]    - call: NULL
  [10:46:12.388] plan(): nbrOfWorkers() = 1
  [10:46:12.390] plan(): Setting new future strategy stack:
  [10:46:12.397] List of future strategies:
  [10:46:12.397] 1. multicore:
  [10:46:12.397]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.397]    - tweaked: FALSE
  [10:46:12.397]    - call: plan(strategy)
  [10:46:12.400] plan(): nbrOfWorkers() = 2
  [10:46:12.414] getGlobalsAndPackages() ...
  [10:46:12.415] Searching for globals...
  [10:46:12.423] - globals found: [3] '{', '*', 'a'
  [10:46:12.424] Searching for globals ... DONE
  [10:46:12.424] Resolving globals: FALSE
  [10:46:12.432] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:12.432] - globals: [1] 'a'
  [10:46:12.433] 
  [10:46:12.433] getGlobalsAndPackages() ... DONE
  [10:46:12.441] Packages needed by the future expression (n = 0): <none>
  [10:46:12.442] Packages needed by future strategies (n = 0): <none>
  [10:46:12.487] {
  [10:46:12.487]     {
  [10:46:12.487]         ...future.startTime <- base::Sys.time()
  [10:46:12.487]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:12.487]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:12.487]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:12.487]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:12.487]             future.resolve.recursive = NULL, width = 80L)
  [10:46:12.487]         {
  [10:46:12.487]             {
  [10:46:12.487]                 {
  [10:46:12.487]                   has_future <- base::requireNamespace("future", 
  [10:46:12.487]                     quietly = TRUE)
  [10:46:12.487]                   version <- if (has_future) 
  [10:46:12.487]                     utils::packageVersion("future")
  [10:46:12.487]                   else NULL
  [10:46:12.487]                   if (!has_future || version < "1.8.0") {
  [10:46:12.487]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:12.487]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:12.487]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:12.487]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:12.487]                         "release", "version")], collapse = " "), 
  [10:46:12.487]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:12.487]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:12.487]                       info)
  [10:46:12.487]                     info <- base::paste(info, collapse = "; ")
  [10:46:12.487]                     if (!has_future) {
  [10:46:12.487]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:12.487]                         info)
  [10:46:12.487]                     }
  [10:46:12.487]                     else {
  [10:46:12.487]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:12.487]                         info, version)
  [10:46:12.487]                     }
  [10:46:12.487]                     base::stop(msg)
  [10:46:12.487]                   }
  [10:46:12.487]                 }
  [10:46:12.487]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:12.487]                 base::options(mc.cores = 1L)
  [10:46:12.487]             }
  [10:46:12.487]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:12.487]         }
  [10:46:12.487]     }
  [10:46:12.487]     if (base::is.na(TRUE)) {
  [10:46:12.487]     }
  [10:46:12.487]     else {
  [10:46:12.487]         if (TRUE) {
  [10:46:12.487]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:12.487]                 open = "w")
  [10:46:12.487]         }
  [10:46:12.487]         else {
  [10:46:12.487]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:12.487]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:12.487]         }
  [10:46:12.487]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:12.487]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:12.487]             base::sink(type = "output", split = FALSE)
  [10:46:12.487]             base::close(...future.stdout)
  [10:46:12.487]         }, add = TRUE)
  [10:46:12.487]     }
  [10:46:12.487]     ...future.frame <- base::sys.nframe()
  [10:46:12.487]     ...future.conditions <- base::list()
  [10:46:12.487]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:12.487]     ...future.result <- base::tryCatch({
  [10:46:12.487]         base::withCallingHandlers({
  [10:46:12.487]             ...future.value <- base::withVisible(base::local({
  [10:46:12.487]                 2 * a
  [10:46:12.487]             }))
  [10:46:12.487]             future::FutureResult(value = ...future.value$value, 
  [10:46:12.487]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.487]                   ...future.rng), started = ...future.startTime, 
  [10:46:12.487]                 version = "1.8")
  [10:46:12.487]         }, condition = base::local({
  [10:46:12.487]             c <- base::c
  [10:46:12.487]             inherits <- base::inherits
  [10:46:12.487]             invokeRestart <- base::invokeRestart
  [10:46:12.487]             length <- base::length
  [10:46:12.487]             list <- base::list
  [10:46:12.487]             seq.int <- base::seq.int
  [10:46:12.487]             signalCondition <- base::signalCondition
  [10:46:12.487]             sys.calls <- base::sys.calls
  [10:46:12.487]             Sys.time <- base::Sys.time
  [10:46:12.487]             `[[` <- base::`[[`
  [10:46:12.487]             `+` <- base::`+`
  [10:46:12.487]             `<<-` <- base::`<<-`
  [10:46:12.487]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:12.487]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:12.487]                   3L)]
  [10:46:12.487]             }
  [10:46:12.487]             function(cond) {
  [10:46:12.487]                 if (inherits(cond, "error")) {
  [10:46:12.487]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.487]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:12.487]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:12.487]                   signalCondition(cond)
  [10:46:12.487]                 }
  [10:46:12.487]                 else if (inherits(cond, "condition")) {
  [10:46:12.487]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:12.487]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.487]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:12.487]                   if (!signal) {
  [10:46:12.487]                     muffleCondition <- function (cond) 
  [10:46:12.487]                     {
  [10:46:12.487]                       inherits <- base::inherits
  [10:46:12.487]                       invokeRestart <- base::invokeRestart
  [10:46:12.487]                       muffled <- FALSE
  [10:46:12.487]                       if (inherits(cond, "message")) {
  [10:46:12.487]                         invokeRestart("muffleMessage")
  [10:46:12.487]                         muffled <- TRUE
  [10:46:12.487]                       }
  [10:46:12.487]                       else if (inherits(cond, "warning")) {
  [10:46:12.487]                         invokeRestart("muffleWarning")
  [10:46:12.487]                         muffled <- TRUE
  [10:46:12.487]                       }
  [10:46:12.487]                       else if (inherits(cond, "condition")) {
  [10:46:12.487]                         computeRestarts <- base::computeRestarts
  [10:46:12.487]                         grepl <- base::grepl
  [10:46:12.487]                         is.null <- base::is.null
  [10:46:12.487]                         restarts <- computeRestarts(cond)
  [10:46:12.487]                         for (restart in restarts) {
  [10:46:12.487]                           name <- restart$name
  [10:46:12.487]                           if (is.null(name)) 
  [10:46:12.487]                             next
  [10:46:12.487]                           if (!grepl("^muffle", name)) 
  [10:46:12.487]                             next
  [10:46:12.487]                           invokeRestart(restart)
  [10:46:12.487]                           muffled <- TRUE
  [10:46:12.487]                           break
  [10:46:12.487]                         }
  [10:46:12.487]                       }
  [10:46:12.487]                       invisible(muffled)
  [10:46:12.487]                     }
  [10:46:12.487]                     muffleCondition(cond)
  [10:46:12.487]                   }
  [10:46:12.487]                 }
  [10:46:12.487]             }
  [10:46:12.487]         }))
  [10:46:12.487]     }, error = function(ex) {
  [10:46:12.487]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:12.487]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.487]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:12.487]     }, finally = {
  [10:46:12.487]         {
  [10:46:12.487]             {
  [10:46:12.487]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:12.487]             }
  [10:46:12.487]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:12.487]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:12.487]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:12.487]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:12.487]             {
  [10:46:12.487]                 if (substitute) 
  [10:46:12.487]                   expr <- substitute(expr)
  [10:46:12.487]                 if (is.function(workers)) 
  [10:46:12.487]                   workers <- workers()
  [10:46:12.487]                 workers <- as.integer(workers)
  [10:46:12.487]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:12.487]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:12.487]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:12.487]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:12.487]                     local = TRUE, label = label, ...))
  [10:46:12.487]                 }
  [10:46:12.487]                 oopts <- options(mc.cores = workers)
  [10:46:12.487]                 on.exit(options(oopts))
  [10:46:12.487]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:12.487]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:12.487]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:12.487]                   label = label, ...)
  [10:46:12.487]                 if (!future$lazy) 
  [10:46:12.487]                   future <- run(future)
  [10:46:12.487]                 invisible(future)
  [10:46:12.487]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:12.487]         }
  [10:46:12.487]         base::options(...future.oldOptions)
  [10:46:12.487]     })
  [10:46:12.487]     Sys.time
  [10:46:12.487]     if (base::is.na(TRUE)) {
  [10:46:12.487]     }
  [10:46:12.487]     else {
  [10:46:12.487]         base::sink(type = "output", split = FALSE)
  [10:46:12.487]         if (TRUE) {
  [10:46:12.487]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:12.487]         }
  [10:46:12.487]         else {
  [10:46:12.487]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:12.487]         }
  [10:46:12.487]         base::close(...future.stdout)
  [10:46:12.487]         ...future.stdout <- NULL
  [10:46:12.487]     }
  [10:46:12.487]     ...future.result$conditions <- ...future.conditions
  [10:46:12.487]     ...future.result
  [10:46:12.487] }
  [10:46:12.498] requestCore(): workers = 2
  [10:46:12.512] MulticoreFuture started
  [10:46:12.520] plan(): Setting new future strategy stack:
  [10:46:12.521] List of future strategies:
  [10:46:12.521] 1. sequential:
  [10:46:12.521]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.521]    - tweaked: FALSE
  [10:46:12.521]    - call: NULL
  [10:46:12.528] plan(): nbrOfWorkers() = 1
  [10:46:12.538] plan(): Setting new future strategy stack:
  [10:46:12.539] List of future strategies:
  [10:46:12.539] 1. multicore:
  [10:46:12.539]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.539]    - tweaked: FALSE
  [10:46:12.539]    - call: plan(strategy)
  [10:46:12.547] plan(): nbrOfWorkers() = 2
  [10:46:12.551] getGlobalsAndPackages() ...
  [10:46:12.552] Searching for globals...
  [10:46:12.561] - globals found: [3] '{', '*', 'a'
  [10:46:12.562] Searching for globals ... DONE
  [10:46:12.568] Resolving globals: FALSE
  [10:46:12.570] The total size of the 1 globals is 56 bytes (56 bytes)
  [10:46:12.570] - globals: [1] 'a'
  [10:46:12.571] 
  [10:46:12.571] getGlobalsAndPackages() ... DONE
  [10:46:12.580] Packages needed by the future expression (n = 0): <none>
  [10:46:12.586] Packages needed by future strategies (n = 0): <none>
  [10:46:12.603] {
  [10:46:12.603]     {
  [10:46:12.603]         ...future.startTime <- base::Sys.time()
  [10:46:12.603]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [10:46:12.603]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [10:46:12.603]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [10:46:12.603]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [10:46:12.603]             future.resolve.recursive = NULL, width = 80L)
  [10:46:12.603]         {
  [10:46:12.603]             {
  [10:46:12.603]                 {
  [10:46:12.603]                   has_future <- base::requireNamespace("future", 
  [10:46:12.603]                     quietly = TRUE)
  [10:46:12.603]                   version <- if (has_future) 
  [10:46:12.603]                     utils::packageVersion("future")
  [10:46:12.603]                   else NULL
  [10:46:12.603]                   if (!has_future || version < "1.8.0") {
  [10:46:12.603]                     info <- base::c(r_version = base::gsub("R version ", 
  [10:46:12.603]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [10:46:12.603]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [10:46:12.603]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [10:46:12.603]                         "release", "version")], collapse = " "), 
  [10:46:12.603]                       hostname = base::Sys.info()[["nodename"]])
  [10:46:12.603]                     info <- base::sprintf("%s: %s", base::names(info), 
  [10:46:12.603]                       info)
  [10:46:12.603]                     info <- base::paste(info, collapse = "; ")
  [10:46:12.603]                     if (!has_future) {
  [10:46:12.603]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [10:46:12.603]                         info)
  [10:46:12.603]                     }
  [10:46:12.603]                     else {
  [10:46:12.603]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [10:46:12.603]                         info, version)
  [10:46:12.603]                     }
  [10:46:12.603]                     base::stop(msg)
  [10:46:12.603]                   }
  [10:46:12.603]                 }
  [10:46:12.603]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [10:46:12.603]                 base::options(mc.cores = 1L)
  [10:46:12.603]             }
  [10:46:12.603]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [10:46:12.603]         }
  [10:46:12.603]     }
  [10:46:12.603]     if (base::is.na(TRUE)) {
  [10:46:12.603]     }
  [10:46:12.603]     else {
  [10:46:12.603]         if (TRUE) {
  [10:46:12.603]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [10:46:12.603]                 open = "w")
  [10:46:12.603]         }
  [10:46:12.603]         else {
  [10:46:12.603]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [10:46:12.603]                 windows = "NUL", "/dev/null"), open = "w")
  [10:46:12.603]         }
  [10:46:12.603]         base::sink(...future.stdout, type = "output", split = FALSE)
  [10:46:12.603]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [10:46:12.603]             base::sink(type = "output", split = FALSE)
  [10:46:12.603]             base::close(...future.stdout)
  [10:46:12.603]         }, add = TRUE)
  [10:46:12.603]     }
  [10:46:12.603]     ...future.frame <- base::sys.nframe()
  [10:46:12.603]     ...future.conditions <- base::list()
  [10:46:12.603]     ...future.rng <- base::globalenv()$.Random.seed
  [10:46:12.603]     ...future.result <- base::tryCatch({
  [10:46:12.603]         base::withCallingHandlers({
  [10:46:12.603]             ...future.value <- base::withVisible(base::local({
  [10:46:12.603]                 2 * a
  [10:46:12.603]             }))
  [10:46:12.603]             future::FutureResult(value = ...future.value$value, 
  [10:46:12.603]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.603]                   ...future.rng), started = ...future.startTime, 
  [10:46:12.603]                 version = "1.8")
  [10:46:12.603]         }, condition = base::local({
  [10:46:12.603]             c <- base::c
  [10:46:12.603]             inherits <- base::inherits
  [10:46:12.603]             invokeRestart <- base::invokeRestart
  [10:46:12.603]             length <- base::length
  [10:46:12.603]             list <- base::list
  [10:46:12.603]             seq.int <- base::seq.int
  [10:46:12.603]             signalCondition <- base::signalCondition
  [10:46:12.603]             sys.calls <- base::sys.calls
  [10:46:12.603]             Sys.time <- base::Sys.time
  [10:46:12.603]             `[[` <- base::`[[`
  [10:46:12.603]             `+` <- base::`+`
  [10:46:12.603]             `<<-` <- base::`<<-`
  [10:46:12.603]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [10:46:12.603]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [10:46:12.603]                   3L)]
  [10:46:12.603]             }
  [10:46:12.603]             function(cond) {
  [10:46:12.603]                 if (inherits(cond, "error")) {
  [10:46:12.603]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.603]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [10:46:12.603]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [10:46:12.603]                   signalCondition(cond)
  [10:46:12.603]                 }
  [10:46:12.603]                 else if (inherits(cond, "condition")) {
  [10:46:12.603]                   signal <- FALSE && inherits(cond, character(0))
  [10:46:12.603]                   ...future.conditions[[length(...future.conditions) + 
  [10:46:12.603]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [10:46:12.603]                   if (!signal) {
  [10:46:12.603]                     muffleCondition <- function (cond) 
  [10:46:12.603]                     {
  [10:46:12.603]                       inherits <- base::inherits
  [10:46:12.603]                       invokeRestart <- base::invokeRestart
  [10:46:12.603]                       muffled <- FALSE
  [10:46:12.603]                       if (inherits(cond, "message")) {
  [10:46:12.603]                         invokeRestart("muffleMessage")
  [10:46:12.603]                         muffled <- TRUE
  [10:46:12.603]                       }
  [10:46:12.603]                       else if (inherits(cond, "warning")) {
  [10:46:12.603]                         invokeRestart("muffleWarning")
  [10:46:12.603]                         muffled <- TRUE
  [10:46:12.603]                       }
  [10:46:12.603]                       else if (inherits(cond, "condition")) {
  [10:46:12.603]                         computeRestarts <- base::computeRestarts
  [10:46:12.603]                         grepl <- base::grepl
  [10:46:12.603]                         is.null <- base::is.null
  [10:46:12.603]                         restarts <- computeRestarts(cond)
  [10:46:12.603]                         for (restart in restarts) {
  [10:46:12.603]                           name <- restart$name
  [10:46:12.603]                           if (is.null(name)) 
  [10:46:12.603]                             next
  [10:46:12.603]                           if (!grepl("^muffle", name)) 
  [10:46:12.603]                             next
  [10:46:12.603]                           invokeRestart(restart)
  [10:46:12.603]                           muffled <- TRUE
  [10:46:12.603]                           break
  [10:46:12.603]                         }
  [10:46:12.603]                       }
  [10:46:12.603]                       invisible(muffled)
  [10:46:12.603]                     }
  [10:46:12.603]                     muffleCondition(cond)
  [10:46:12.603]                   }
  [10:46:12.603]                 }
  [10:46:12.603]             }
  [10:46:12.603]         }))
  [10:46:12.603]     }, error = function(ex) {
  [10:46:12.603]         base::structure(base::list(value = NULL, visible = NULL, 
  [10:46:12.603]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [10:46:12.603]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [10:46:12.603]     }, finally = {
  [10:46:12.603]         {
  [10:46:12.603]             {
  [10:46:12.603]                 base::options(mc.cores = ...future.mc.cores.old)
  [10:46:12.603]             }
  [10:46:12.603]             future::plan(list(function (expr, envir = parent.frame(), 
  [10:46:12.603]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [10:46:12.603]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [10:46:12.603]                 earlySignal = FALSE, label = NULL, ...) 
  [10:46:12.603]             {
  [10:46:12.603]                 if (substitute) 
  [10:46:12.603]                   expr <- substitute(expr)
  [10:46:12.603]                 if (is.function(workers)) 
  [10:46:12.603]                   workers <- workers()
  [10:46:12.603]                 workers <- as.integer(workers)
  [10:46:12.603]                 stop_if_not(is.finite(workers), workers >= 1L)
  [10:46:12.603]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [10:46:12.603]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [10:46:12.603]                     lazy = lazy, seed = seed, globals = globals, 
  [10:46:12.603]                     local = TRUE, label = label, ...))
  [10:46:12.603]                 }
  [10:46:12.603]                 oopts <- options(mc.cores = workers)
  [10:46:12.603]                 on.exit(options(oopts))
  [10:46:12.603]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [10:46:12.603]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [10:46:12.603]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [10:46:12.603]                   label = label, ...)
  [10:46:12.603]                 if (!future$lazy) 
  [10:46:12.603]                   future <- run(future)
  [10:46:12.603]                 invisible(future)
  [10:46:12.603]             }), .cleanup = FALSE, .init = FALSE)
  [10:46:12.603]         }
  [10:46:12.603]         base::options(...future.oldOptions)
  [10:46:12.603]     })
  [10:46:12.603]     Sys.time
  [10:46:12.603]     if (base::is.na(TRUE)) {
  [10:46:12.603]     }
  [10:46:12.603]     else {
  [10:46:12.603]         base::sink(type = "output", split = FALSE)
  [10:46:12.603]         if (TRUE) {
  [10:46:12.603]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [10:46:12.603]         }
  [10:46:12.603]         else {
  [10:46:12.603]             ...future.result["stdout"] <- base::list(NULL)
  [10:46:12.603]         }
  [10:46:12.603]         base::close(...future.stdout)
  [10:46:12.603]         ...future.stdout <- NULL
  [10:46:12.603]     }
  [10:46:12.603]     ...future.result$conditions <- ...future.conditions
  [10:46:12.603]     ...future.result
  [10:46:12.603] }
  [10:46:12.615] requestCore(): workers = 2
  [10:46:12.633] MulticoreFuture started
  [10:46:12.646] plan(): Setting new future strategy stack:
  [10:46:12.647] List of future strategies:
  [10:46:12.647] 1. sequential:
  [10:46:12.647]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.647]    - tweaked: FALSE
  [10:46:12.647]    - call: NULL
  [10:46:12.654] plan(): nbrOfWorkers() = 1
  [10:46:12.661] plan(): Setting new future strategy stack:
  [10:46:12.662] List of future strategies:
  [10:46:12.662] 1. multicore:
  [10:46:12.662]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [10:46:12.662]    - tweaked: FALSE
  [10:46:12.662]    - call: plan(strategy)
  [10:46:12.669] plan(): nbrOfWorkers() = 2
  *** futureAssign() with 'multicore' futures ... DONE
  *** futureAssign() with 'multisession' futures ...
  [10:46:12.674] plan(): Setting new future strategy stack:
  [10:46:12.674] List of future strategies:
  [10:46:12.674] 1. multisession:
  [10:46:12.674]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.674]    - tweaked: FALSE
  [10:46:12.674]    - call: plan(strategy)
  [10:46:12.676] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [10:46:12.677] multisession:
  [10:46:12.677] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [10:46:12.677] - tweaked: FALSE
  [10:46:12.677] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 39640
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/data/gannet/ripley/R/R-clang/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpsyKAwW/working_dir/RtmpwMQpyg/future.parent=26498.6782236a3f19.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpsyKAwW/working_dir/RtmpwMQpyg/future.parent=26498.6782236a3f19.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/data/gannet/ripley/R/R-clang/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/futureAssign.R:gannet.stats.ox.ac.uk:ripley:26498' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpsyKAwW/working_dir/RtmpwMQpyg/future.parent=26498.6782236a3f19.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=39640 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
  Error in unserialize(node$con) : error reading from connection
  Calls: plan ... FUN -> recvData -> recvData.SOCKnode -> unserialize
  Execution halted
Running the tests in ‘tests/multicore,multithreading.R’ failed.
Complete output:
  > source("incl/start.R")
  [11:05:55.763] plan(): Setting new future strategy stack:
  [11:05:55.765] List of future strategies:
  [11:05:55.765] 1. sequential:
  [11:05:55.765]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [11:05:55.765]    - tweaked: FALSE
  [11:05:55.765]    - call: future::plan("sequential")
  [11:05:55.768] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > plan(multicore)
  [11:05:55.868] plan(): Setting new future strategy stack:
  [11:05:55.868] List of future strategies:
  [11:05:55.868] 1. multicore:
  [11:05:55.868]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [11:05:55.868]    - tweaked: FALSE
  [11:05:55.868]    - call: plan(multicore)
  [11:05:55.972] plan(): nbrOfWorkers() = 2
  > 
  > message("*** multicore() and multi-threading ...")
  *** multicore() and multi-threading ...
  > 
  > message("supportsMulticore(): ", sQuote(supportsMulticore()))
  supportsMulticore(): 'TRUE'
  > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
  availableCores('multicore'): '2'
  > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
  [11:05:56.093] supports_omp_threads() = TRUE
  supports_omp_threads(): 'TRUE'
  > 
  > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
  +   for (enable in c(TRUE, FALSE)) {
  +     options(future.fork.multithreading.enable = enable)
  + 
  +     message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
  + 
  +     f <- future(RhpcBLASctl::omp_get_max_threads())
  +     nthreads <- value(f)
  +     cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
  + 
  +     ## Assert that single-threading was set?
  +     if (enable) {
  +       stopifnot(enable && nthreads > 1L)
  +     } else {
  +       stopifnot(!enable && nthreads == 1L)
  +     }
  +       
  +     message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
  +   } ## for (enable ...)
  + } ## if (requireNamespace("RhpcBLASctl", ...)) {
  [11:05:56.096] supports_omp_threads() = TRUE
  'future.fork.multithreading.enable' = TRUE ...
  [11:05:56.241] getGlobalsAndPackages() ...
  [11:05:56.241] Searching for globals...
  [11:05:56.266] - globals found: [1] '::'
  [11:05:56.267] Searching for globals ... DONE
  [11:05:56.268] Resolving globals: FALSE
  [11:05:56.269] 
  [11:05:56.270] 
  [11:05:56.270] getGlobalsAndPackages() ... DONE
  [11:05:56.288] Packages needed by the future expression (n = 0): <none>
  [11:05:56.289] Packages needed by future strategies (n = 0): <none>
  [11:05:56.326] {
  [11:05:56.326]     {
  [11:05:56.326]         ...future.startTime <- base::Sys.time()
  [11:05:56.326]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [11:05:56.326]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [11:05:56.326]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [11:05:56.326]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [11:05:56.326]             future.resolve.recursive = NULL, width = 80L)
  [11:05:56.326]         {
  [11:05:56.326]             {
  [11:05:56.326]                 {
  [11:05:56.326]                   has_future <- base::requireNamespace("future", 
  [11:05:56.326]                     quietly = TRUE)
  [11:05:56.326]                   version <- if (has_future) 
  [11:05:56.326]                     utils::packageVersion("future")
  [11:05:56.326]                   else NULL
  [11:05:56.326]                   if (!has_future || version < "1.8.0") {
  [11:05:56.326]                     info <- base::c(r_version = base::gsub("R version ", 
  [11:05:56.326]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [11:05:56.326]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [11:05:56.326]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [11:05:56.326]                         "release", "version")], collapse = " "), 
  [11:05:56.326]                       hostname = base::Sys.info()[["nodename"]])
  [11:05:56.326]                     info <- base::sprintf("%s: %s", base::names(info), 
  [11:05:56.326]                       info)
  [11:05:56.326]                     info <- base::paste(info, collapse = "; ")
  [11:05:56.326]                     if (!has_future) {
  [11:05:56.326]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [11:05:56.326]                         info)
  [11:05:56.326]                     }
  [11:05:56.326]                     else {
  [11:05:56.326]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [11:05:56.326]                         info, version)
  [11:05:56.326]                     }
  [11:05:56.326]                     base::stop(msg)
  [11:05:56.326]                   }
  [11:05:56.326]                 }
  [11:05:56.326]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [11:05:56.326]                 base::options(mc.cores = 1L)
  [11:05:56.326]             }
  [11:05:56.326]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [11:05:56.326]         }
  [11:05:56.326]     }
  [11:05:56.326]     if (base::is.na(TRUE)) {
  [11:05:56.326]     }
  [11:05:56.326]     else {
  [11:05:56.326]         if (TRUE) {
  [11:05:56.326]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [11:05:56.326]                 open = "w")
  [11:05:56.326]         }
  [11:05:56.326]         else {
  [11:05:56.326]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [11:05:56.326]                 windows = "NUL", "/dev/null"), open = "w")
  [11:05:56.326]         }
  [11:05:56.326]         base::sink(...future.stdout, type = "output", split = FALSE)
  [11:05:56.326]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [11:05:56.326]             base::sink(type = "output", split = FALSE)
  [11:05:56.326]             base::close(...future.stdout)
  [11:05:56.326]         }, add = TRUE)
  [11:05:56.326]     }
  [11:05:56.326]     ...future.frame <- base::sys.nframe()
  [11:05:56.326]     ...future.conditions <- base::list()
  [11:05:56.326]     ...future.rng <- base::globalenv()$.Random.seed
  [11:05:56.326]     ...future.result <- base::tryCatch({
  [11:05:56.326]         base::withCallingHandlers({
  [11:05:56.326]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [11:05:56.326]             future::FutureResult(value = ...future.value$value, 
  [11:05:56.326]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [11:05:56.326]                   ...future.rng), started = ...future.startTime, 
  [11:05:56.326]                 version = "1.8")
  [11:05:56.326]         }, condition = base::local({
  [11:05:56.326]             c <- base::c
  [11:05:56.326]             inherits <- base::inherits
  [11:05:56.326]             invokeRestart <- base::invokeRestart
  [11:05:56.326]             length <- base::length
  [11:05:56.326]             list <- base::list
  [11:05:56.326]             seq.int <- base::seq.int
  [11:05:56.326]             signalCondition <- base::signalCondition
  [11:05:56.326]             sys.calls <- base::sys.calls
  [11:05:56.326]             Sys.time <- base::Sys.time
  [11:05:56.326]             `[[` <- base::`[[`
  [11:05:56.326]             `+` <- base::`+`
  [11:05:56.326]             `<<-` <- base::`<<-`
  [11:05:56.326]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [11:05:56.326]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [11:05:56.326]                   3L)]
  [11:05:56.326]             }
  [11:05:56.326]             function(cond) {
  [11:05:56.326]                 if (inherits(cond, "error")) {
  [11:05:56.326]                   ...future.conditions[[length(...future.conditions) + 
  [11:05:56.326]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [11:05:56.326]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [11:05:56.326]                   signalCondition(cond)
  [11:05:56.326]                 }
  [11:05:56.326]                 else if (inherits(cond, "condition")) {
  [11:05:56.326]                   signal <- FALSE && inherits(cond, character(0))
  [11:05:56.326]                   ...future.conditions[[length(...future.conditions) + 
  [11:05:56.326]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [11:05:56.326]                   if (!signal) {
  [11:05:56.326]                     muffleCondition <- function (cond) 
  [11:05:56.326]                     {
  [11:05:56.326]                       inherits <- base::inherits
  [11:05:56.326]                       invokeRestart <- base::invokeRestart
  [11:05:56.326]                       muffled <- FALSE
  [11:05:56.326]                       if (inherits(cond, "message")) {
  [11:05:56.326]                         invokeRestart("muffleMessage")
  [11:05:56.326]                         muffled <- TRUE
  [11:05:56.326]                       }
  [11:05:56.326]                       else if (inherits(cond, "warning")) {
  [11:05:56.326]                         invokeRestart("muffleWarning")
  [11:05:56.326]                         muffled <- TRUE
  [11:05:56.326]                       }
  [11:05:56.326]                       else if (inherits(cond, "condition")) {
  [11:05:56.326]                         computeRestarts <- base::computeRestarts
  [11:05:56.326]                         grepl <- base::grepl
  [11:05:56.326]                         is.null <- base::is.null
  [11:05:56.326]                         restarts <- computeRestarts(cond)
  [11:05:56.326]                         for (restart in restarts) {
  [11:05:56.326]                           name <- restart$name
  [11:05:56.326]                           if (is.null(name)) 
  [11:05:56.326]                             next
  [11:05:56.326]                           if (!grepl("^muffle", name)) 
  [11:05:56.326]                             next
  [11:05:56.326]                           invokeRestart(restart)
  [11:05:56.326]                           muffled <- TRUE
  [11:05:56.326]                           break
  [11:05:56.326]                         }
  [11:05:56.326]                       }
  [11:05:56.326]                       invisible(muffled)
  [11:05:56.326]                     }
  [11:05:56.326]                     muffleCondition(cond)
  [11:05:56.326]                   }
  [11:05:56.326]                 }
  [11:05:56.326]             }
  [11:05:56.326]         }))
  [11:05:56.326]     }, error = function(ex) {
  [11:05:56.326]         base::structure(base::list(value = NULL, visible = NULL, 
  [11:05:56.326]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [11:05:56.326]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [11:05:56.326]     }, finally = {
  [11:05:56.326]         {
  [11:05:56.326]             {
  [11:05:56.326]                 base::options(mc.cores = ...future.mc.cores.old)
  [11:05:56.326]             }
  [11:05:56.326]             future::plan(list(function (expr, envir = parent.frame(), 
  [11:05:56.326]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [11:05:56.326]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [11:05:56.326]                 earlySignal = FALSE, label = NULL, ...) 
  [11:05:56.326]             {
  [11:05:56.326]                 if (substitute) 
  [11:05:56.326]                   expr <- substitute(expr)
  [11:05:56.326]                 if (is.function(workers)) 
  [11:05:56.326]                   workers <- workers()
  [11:05:56.326]                 workers <- as.integer(workers)
  [11:05:56.326]                 stop_if_not(is.finite(workers), workers >= 1L)
  [11:05:56.326]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [11:05:56.326]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [11:05:56.326]                     lazy = lazy, seed = seed, globals = globals, 
  [11:05:56.326]                     local = TRUE, label = label, ...))
  [11:05:56.326]                 }
  [11:05:56.326]                 oopts <- options(mc.cores = workers)
  [11:05:56.326]                 on.exit(options(oopts))
  [11:05:56.326]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [11:05:56.326]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [11:05:56.326]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [11:05:56.326]                   label = label, ...)
  [11:05:56.326]                 if (!future$lazy) 
  [11:05:56.326]                   future <- run(future)
  [11:05:56.326]                 invisible(future)
  [11:05:56.326]             }), .cleanup = FALSE, .init = FALSE)
  [11:05:56.326]         }
  [11:05:56.326]         base::options(...future.oldOptions)
  [11:05:56.326]     })
  [11:05:56.326]     Sys.time
  [11:05:56.326]     if (base::is.na(TRUE)) {
  [11:05:56.326]     }
  [11:05:56.326]     else {
  [11:05:56.326]         base::sink(type = "output", split = FALSE)
  [11:05:56.326]         if (TRUE) {
  [11:05:56.326]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [11:05:56.326]         }
  [11:05:56.326]         else {
  [11:05:56.326]             ...future.result["stdout"] <- base::list(NULL)
  [11:05:56.326]         }
  [11:05:56.326]         base::close(...future.stdout)
  [11:05:56.326]         ...future.stdout <- NULL
  [11:05:56.326]     }
  [11:05:56.326]     ...future.result$conditions <- ...future.conditions
  [11:05:56.326]     ...future.result
  [11:05:56.326] }
  [11:05:56.363] requestCore(): workers = 2
  [11:05:56.397] plan(): Setting new future strategy stack:
  [11:05:56.384] MulticoreFuture started
  [11:05:56.398] List of future strategies:
  [11:05:56.398] 1. sequential:
  [11:05:56.398]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [11:05:56.398]    - tweaked: FALSE
  [11:05:56.398]    - call: NULL
  [11:05:56.411] plan(): nbrOfWorkers() = 1
  [11:05:56.424] plan(): Setting new future strategy stack:
  [11:05:56.425] List of future strategies:
  [11:05:56.425] 1. multicore:
  [11:05:56.425]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [11:05:56.425]    - tweaked: FALSE
  [11:05:56.425]    - call: plan(multicore)
  [11:05:56.438] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 24
  'future.fork.multithreading.enable' = TRUE ... DONE
  'future.fork.multithreading.enable' = FALSE ...
  [11:05:56.458] getGlobalsAndPackages() ...
  [11:05:56.459] Searching for globals...
  [11:05:56.464] - globals found: [1] '::'
  [11:05:56.465] Searching for globals ... DONE
  [11:05:56.466] Resolving globals: FALSE
  [11:05:56.471] 
  [11:05:56.471] 
  [11:05:56.472] getGlobalsAndPackages() ... DONE
  [11:05:56.473] - Evaluate future in single-threaded mode ...
  [11:05:56.473] supports_omp_threads() = TRUE
  [11:05:56.474]   - Force single-threaded processing for OpenMP
  [11:05:56.474] - Evaluate future in single-threaded mode ... DONE
  [11:05:56.483] Packages needed by the future expression (n = 0): <none>
  [11:05:56.483] Packages needed by future strategies (n = 0): <none>
  [11:05:56.500] {
  [11:05:56.500]     {
  [11:05:56.500]         ...future.startTime <- base::Sys.time()
  [11:05:56.500]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [11:05:56.500]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [11:05:56.500]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [11:05:56.500]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [11:05:56.500]             future.resolve.recursive = NULL, width = 80L)
  [11:05:56.500]         {
  [11:05:56.500]             {
  [11:05:56.500]                 {
  [11:05:56.500]                   has_future <- base::requireNamespace("future", 
  [11:05:56.500]                     quietly = TRUE)
  [11:05:56.500]                   version <- if (has_future) 
  [11:05:56.500]                     utils::packageVersion("future")
  [11:05:56.500]                   else NULL
  [11:05:56.500]                   if (!has_future || version < "1.8.0") {
  [11:05:56.500]                     info <- base::c(r_version = base::gsub("R version ", 
  [11:05:56.500]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [11:05:56.500]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [11:05:56.500]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [11:05:56.500]                         "release", "version")], collapse = " "), 
  [11:05:56.500]                       hostname = base::Sys.info()[["nodename"]])
  [11:05:56.500]                     info <- base::sprintf("%s: %s", base::names(info), 
  [11:05:56.500]                       info)
  [11:05:56.500]                     info <- base::paste(info, collapse = "; ")
  [11:05:56.500]                     if (!has_future) {
  [11:05:56.500]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [11:05:56.500]                         info)
  [11:05:56.500]                     }
  [11:05:56.500]                     else {
  [11:05:56.500]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [11:05:56.500]                         info, version)
  [11:05:56.500]                     }
  [11:05:56.500]                     base::stop(msg)
  [11:05:56.500]                   }
  [11:05:56.500]                 }
  [11:05:56.500]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [11:05:56.500]                 base::options(mc.cores = 1L)
  [11:05:56.500]             }
  [11:05:56.500]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [11:05:56.500]         }
  [11:05:56.500]     }
  [11:05:56.500]     if (base::is.na(TRUE)) {
  [11:05:56.500]     }
  [11:05:56.500]     else {
  [11:05:56.500]         if (TRUE) {
  [11:05:56.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [11:05:56.500]                 open = "w")
  [11:05:56.500]         }
  [11:05:56.500]         else {
  [11:05:56.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [11:05:56.500]                 windows = "NUL", "/dev/null"), open = "w")
  [11:05:56.500]         }
  [11:05:56.500]         base::sink(...future.stdout, type = "output", split = FALSE)
  [11:05:56.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [11:05:56.500]             base::sink(type = "output", split = FALSE)
  [11:05:56.500]             base::close(...future.stdout)
  [11:05:56.500]         }, add = TRUE)
  [11:05:56.500]     }
  [11:05:56.500]     ...future.frame <- base::sys.nframe()
  [11:05:56.500]     ...future.conditions <- base::list()
  [11:05:56.500]     ...future.rng <- base::globalenv()$.Random.seed
  [11:05:56.500]     ...future.result <- base::tryCatch({
  [11:05:56.500]         base::withCallingHandlers({
  [11:05:56.500]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [11:05:56.500]             future::FutureResult(value = ...future.value$value, 
  [11:05:56.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [11:05:56.500]                   ...future.rng), started = ...future.startTime, 
  [11:05:56.500]                 version = "1.8")
  [11:05:56.500]         }, condition = base::local({
  [11:05:56.500]             c <- base::c
  [11:05:56.500]             inherits <- base::inherits
  [11:05:56.500]             invokeRestart <- base::invokeRestart
  [11:05:56.500]             length <- base::length
  [11:05:56.500]             list <- base::list
  [11:05:56.500]             seq.int <- base::seq.int
  [11:05:56.500]             signalCondition <- base::signalCondition
  [11:05:56.500]             sys.calls <- base::sys.calls
  [11:05:56.500]             Sys.time <- base::Sys.time
  [11:05:56.500]             `[[` <- base::`[[`
  [11:05:56.500]             `+` <- base::`+`
  [11:05:56.500]             `<<-` <- base::`<<-`
  [11:05:56.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [11:05:56.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [11:05:56.500]                   3L)]
  [11:05:56.500]             }
  [11:05:56.500]             function(cond) {
  [11:05:56.500]                 if (inherits(cond, "error")) {
  [11:05:56.500]                   ...future.conditions[[length(...future.conditions) + 
  [11:05:56.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [11:05:56.500]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [11:05:56.500]                   signalCondition(cond)
  [11:05:56.500]                 }
  [11:05:56.500]                 else if (inherits(cond, "condition")) {
  [11:05:56.500]                   signal <- FALSE && inherits(cond, character(0))
  [11:05:56.500]                   ...future.conditions[[length(...future.conditions) + 
  [11:05:56.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [11:05:56.500]                   if (!signal) {
  [11:05:56.500]                     muffleCondition <- function (cond) 
  [11:05:56.500]                     {
  [11:05:56.500]                       inherits <- base::inherits
  [11:05:56.500]                       invokeRestart <- base::invokeRestart
  [11:05:56.500]                       muffled <- FALSE
  [11:05:56.500]                       if (inherits(cond, "message")) {
  [11:05:56.500]                         invokeRestart("muffleMessage")
  [11:05:56.500]                         muffled <- TRUE
  [11:05:56.500]                       }
  [11:05:56.500]                       else if (inherits(cond, "warning")) {
  [11:05:56.500]                         invokeRestart("muffleWarning")
  [11:05:56.500]                         muffled <- TRUE
  [11:05:56.500]                       }
  [11:05:56.500]                       else if (inherits(cond, "condition")) {
  [11:05:56.500]                         computeRestarts <- base::computeRestarts
  [11:05:56.500]                         grepl <- base::grepl
  [11:05:56.500]                         is.null <- base::is.null
  [11:05:56.500]                         restarts <- computeRestarts(cond)
  [11:05:56.500]                         for (restart in restarts) {
  [11:05:56.500]                           name <- restart$name
  [11:05:56.500]                           if (is.null(name)) 
  [11:05:56.500]                             next
  [11:05:56.500]                           if (!grepl("^muffle", name)) 
  [11:05:56.500]                             next
  [11:05:56.500]                           invokeRestart(restart)
  [11:05:56.500]                           muffled <- TRUE
  [11:05:56.500]                           break
  [11:05:56.500]                         }
  [11:05:56.500]                       }
  [11:05:56.500]                       invisible(muffled)
  [11:05:56.500]                     }
  [11:05:56.500]                     muffleCondition(cond)
  [11:05:56.500]                   }
  [11:05:56.500]                 }
  [11:05:56.500]             }
  [11:05:56.500]         }))
  [11:05:56.500]     }, error = function(ex) {
  [11:05:56.500]         base::structure(base::list(value = NULL, visible = NULL, 
  [11:05:56.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [11:05:56.500]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [11:05:56.500]     }, finally = {
  [11:05:56.500]         {
  [11:05:56.500]             {
  [11:05:56.500]                 base::options(mc.cores = ...future.mc.cores.old)
  [11:05:56.500]             }
  [11:05:56.500]             future::plan(list(function (expr, envir = parent.frame(), 
  [11:05:56.500]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [11:05:56.500]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [11:05:56.500]                 earlySignal = FALSE, label = NULL, ...) 
  [11:05:56.500]             {
  [11:05:56.500]                 if (substitute) 
  [11:05:56.500]                   expr <- substitute(expr)
  [11:05:56.500]                 if (is.function(workers)) 
  [11:05:56.500]                   workers <- workers()
  [11:05:56.500]                 workers <- as.integer(workers)
  [11:05:56.500]                 stop_if_not(is.finite(workers), workers >= 1L)
  [11:05:56.500]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [11:05:56.500]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [11:05:56.500]                     lazy = lazy, seed = seed, globals = globals, 
  [11:05:56.500]                     local = TRUE, label = label, ...))
  [11:05:56.500]                 }
  [11:05:56.500]                 oopts <- options(mc.cores = workers)
  [11:05:56.500]                 on.exit(options(oopts))
  [11:05:56.500]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [11:05:56.500]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [11:05:56.500]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [11:05:56.500]                   label = label, ...)
  [11:05:56.500]                 if (!future$lazy) 
  [11:05:56.500]                   future <- run(future)
  [11:05:56.500]                 invisible(future)
  [11:05:56.500]             }), .cleanup = FALSE, .init = FALSE)
  [11:05:56.500]         }
  [11:05:56.500]         base::options(...future.oldOptions)
  [11:05:56.500]     })
  [11:05:56.500]     Sys.time
  [11:05:56.500]     if (base::is.na(TRUE)) {
  [11:05:56.500]     }
  [11:05:56.500]     else {
  [11:05:56.500]         base::sink(type = "output", split = FALSE)
  [11:05:56.500]         if (TRUE) {
  [11:05:56.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [11:05:56.500]         }
  [11:05:56.500]         else {
  [11:05:56.500]             ...future.result["stdout"] <- base::list(NULL)
  [11:05:56.500]         }
  [11:05:56.500]         base::close(...future.stdout)
  [11:05:56.500]         ...future.stdout <- NULL
  [11:05:56.500]     }
  [11:05:56.500]     ...future.result$conditions <- ...future.conditions
  [11:05:56.500]     ...future.result
  [11:05:56.500] }
  [11:05:56.514] requestCore(): workers = 2
  [11:05:56.523] MulticoreFuture started
  [11:05:56.540] plan(): Setting new future strategy stack:
  [11:05:56.540] List of future strategies:
  [11:05:56.540] 1. sequential:
  [11:05:56.540]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [11:05:56.540]    - tweaked: FALSE
  [11:05:56.540]    - call: NULL
  [11:05:56.568] plan(): nbrOfWorkers() = 1
  [11:05:56.635] plan(): Setting new future strategy stack:
  [11:05:56.636] List of future strategies:
  [11:05:56.636] 1. multicore:
  [11:05:56.636]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [11:05:56.636]    - tweaked: FALSE
  [11:05:56.636]    - call: plan(multicore)
  [11:05:56.639] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 24
  Error: !enable && nthreads == 1L is not TRUE
  Execution halted