Running ‘000.sessionDetails.R’ [0s/1s]
  Running ‘ClusterRegistry.R’ [2s/11s]
  Running ‘Future-class.R’ [1s/5s]
  Running ‘FutureError.R’ [0s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/2s]
  Running ‘as.cluster.R’ [1s/5s]
  Running ‘availableCores.R’ [0s/1s]
  Running ‘availableWorkers.R’ [0s/1s]
  Running ‘backtrace.R’ [1s/2s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [6s/36s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [8s/15s]
  Running ‘dotdotdot.R’ [1s/7s]
  Running ‘early-signaling.R’ [2s/13s]
  Running ‘future,labels.R’ [1s/1s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/7s]
  Running ‘futureAssign_OP.R’ [3s/8s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [3s/11s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [15s/48s]
  Running ‘globals,NSE.R’ [1s/1s]
  Running ‘globals,formulas.R’ [3s/9s]
  Running ‘globals,manual.R’ [2s/3s]
  Running ‘globals,resolve.R’ [1s/5s]
  Running ‘globals,subassignment.R’ [3s/7s]
  Running ‘globals,toolarge.R’ [1s/4s]
  Running ‘globals,tricky.R’ [6s/14s]
  Running ‘globals,tricky_recursive.R’ [1s/1s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [1s/2s]
  Running ‘invalid-owner.R’ [1s/6s]
  Running ‘makeClusterPSOCK.R’ [1s/3s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [0s/1s]
  Running ‘multicore,multithreading.R’ [1s/1s]
  Running ‘multicore.R’ [1s/2s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [4s/15s]
  Running ‘nbrOfWorkers.R’ [3s/16s]
  Running ‘nested_futures,mc.cores.R’ [4s/28s]
  Running ‘nested_futures.R’ [1s/1s]
  Running ‘non-exportable,connections.R’ [1s/5s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [2s/5s]
  Running ‘relaying.R’ [1s/3s]
  Running ‘remote.R’ [1s/5s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/11s]
  Running ‘reserved-keyword-functions.R’ [1s/1s]
  Running ‘resolve.R’ [2s/5s]
  Running ‘resolved-non-blocking-test.R’ [2s/36s]
  Running ‘rng.R’ [6s/11s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [0s/1s]
  Running ‘startup.R’ [2s/8s]
  Running ‘stdout.R’ [2s/6s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [1s/2s]
  Running ‘uuid.R’ [1s/2s]
  Running ‘whichIndex.R’ [1s/1s]
Running the tests in ‘tests/rng.R’ failed.
Complete output:
  > source("incl/start.R")
  [21:15:32.616] plan(): Setting new future strategy stack:
  [21:15:32.617] List of future strategies:
  [21:15:32.617] 1. sequential:
  [21:15:32.617]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:32.617]    - tweaked: FALSE
  [21:15:32.617]    - call: future::plan("sequential")
  [21:15:32.619] plan(): nbrOfWorkers() = 1
  > 
  > message("*** rng ...")
  *** rng ...
  > 
  > ## A valid regular seed
  > f <- Future(42, seed = 42L)
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  [1] 42
  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: c(10407, -1871565002, 1968597656, -505666782, 1055078269, 658163990, 1090264187)
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'Future', 'environment'
  > 
  > ## A valid L'Ecuyer-CMRG RNG seed
  > seed <- c(407L, 1420090545L, 65713854L, -990249945L,
  +           1780737596L, -1213437427L, 1082168682L)
  > f <- Future(42, seed = seed)
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  [1] 42
  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: c(407, 1420090545, 65713854, -990249945, 1780737596, -1213437427, 1082168682)
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'Future', 'environment'
  > 
  > f <- Future(42, seed = TRUE)
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  [1] 42
  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: c(10407, -330196876, 252762608, 1298840097, 504241305, -1857806155, 1576215588)
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'Future', 'environment'
  > 
  > f <- Future(42, seed = FALSE)
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  [1] 42
  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 = FALSE)
  Resolved: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'Future', 'environment'
  > 
  > f <- Future(42, seed = NULL)
  > print(f)
  Future:
  Label: '<none>'
  Expression:
  [1] 42
  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: FALSE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'Future', 'environment'
  > 
  > 
  > ## See Section 6 on 'Random-number generation' in
  > ## vignette("parallel", package = "parallel")
  > fsample <- function(x, size = 4L, seed = NULL, what = c("future", "%<-%")) {
  +   what <- match.arg(what)
  +   
  +   ## Must use session-specific '.GlobalEnv' here
  +   .GlobalEnv <- globalenv()
  +   
  +   oseed <- .GlobalEnv$.Random.seed
  +   orng <- RNGkind("L'Ecuyer-CMRG")[1L]
  +   on.exit(RNGkind(orng))
  + 
  +   if (isFALSE(seed) || isNA(seed) || is.null(seed)) {
  +     if (what == "future") {
  +       fs <- list()
  +       for (ii in seq_len(size)) {
  +         label <- sprintf("fsample_%d-%d", ii, sample.int(1e6, size=1L))
  +         fs[[ii]] <- future({ sample(x, size = 1L) }, seed = seed, label = label)
  + 	print(fs[[ii]])
  +       }
  +       res <- values(fs)
  +     } else {
  +       res <- listenv::listenv()
  +       for (ii in seq_len(size)) {
  +         label <- sprintf("fsample_%d-%d", ii, sample.int(1e6, size=1L))
  +         res[[ii]] %<-% { sample(x, size = 1L) } %seed% seed %label% label
  +       }
  +       res <- as.list(res)
  +     }
  +   } else {
  +     ## Reset state of random seed afterwards?
  +     on.exit({
  +       if (is.null(oseed)) {
  +         rm(list = ".Random.seed", envir = .GlobalEnv, inherits = FALSE)
  +       } else {
  +         .GlobalEnv$.Random.seed <- oseed
  +       }
  +     }, add = TRUE)
  + 
  +     set.seed(seed)
  + 
  +     .seed <- .Random.seed
  +   
  +     if (what == "future") {
  +       fs <- list()
  +       for (ii in seq_len(size)) {
  +         .seed <- parallel::nextRNGStream(.seed)
  +         fs[[ii]] <- future({ sample(x, size = 1L) }, seed = .seed)
  +       }
  +       res <- values(fs)
  +     } else {
  +       res <- listenv::listenv()
  +       for (ii in seq_len(size)) {
  +         .seed <- parallel::nextRNGStream(.seed)
  +         res[[ii]] %<-% { sample(x, size = 1L) } %seed% .seed
  +       }
  +       res <- as.list(res)
  +     }
  +   }
  +   
  +   res
  + } # fsample()
  > 
  > 
  > dummy <- sample(0:3, size = 1L)
  > seed0 <- .Random.seed
  > 
  > ## Reference sample with fixed random seed
  > plan("sequential")
  [21:15:32.710] plan(): Setting new future strategy stack:
  [21:15:32.711] List of future strategies:
  [21:15:32.711] 1. sequential:
  [21:15:32.711]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:32.711]    - tweaked: FALSE
  [21:15:32.711]    - call: plan("sequential")
  [21:15:32.771] plan(): nbrOfWorkers() = 1
  > y0 <- fsample(0:3, seed = 42L)
  [21:15:32.897] getGlobalsAndPackages() ...
  [21:15:32.897] Searching for globals...
  [21:15:32.922] - globals found: [3] '{', 'sample', 'x'
  [21:15:32.922] Searching for globals ... DONE
  [21:15:32.923] Resolving globals: FALSE
  [21:15:32.924] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:32.925] - globals: [1] 'x'
  [21:15:32.925] 
  [21:15:32.925] getGlobalsAndPackages() ... DONE
  [21:15:32.928] Packages needed by the future expression (n = 0): <none>
  [21:15:32.928] Packages needed by future strategies (n = 0): <none>
  [21:15:32.949] {
  [21:15:32.949]     {
  [21:15:32.949]         ...future.startTime <- base::Sys.time()
  [21:15:32.949]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:32.949]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:32.949]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [21:15:32.949]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:32.949]             future.resolve.recursive = NULL, width = 80L)
  [21:15:32.949]         {
  [21:15:32.949]             {
  [21:15:32.949]                 {
  [21:15:32.949]                   base::local({
  [21:15:32.949]                     has_future <- base::requireNamespace("future", 
  [21:15:32.949]                       quietly = TRUE)
  [21:15:32.949]                     version <- if (has_future) 
  [21:15:32.949]                       utils::packageVersion("future")
  [21:15:32.949]                     else NULL
  [21:15:32.949]                     if (!has_future || version < "1.8.0") {
  [21:15:32.949]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:32.949]                         "", base::R.version$version.string), 
  [21:15:32.949]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:32.949]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:32.949]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:32.949]                           "release", "version")], collapse = " "), 
  [21:15:32.949]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:32.949]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:32.949]                         info)
  [21:15:32.949]                       info <- base::paste(info, collapse = "; ")
  [21:15:32.949]                       if (!has_future) {
  [21:15:32.949]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:32.949]                           info)
  [21:15:32.949]                       }
  [21:15:32.949]                       else {
  [21:15:32.949]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:32.949]                           info, version)
  [21:15:32.949]                       }
  [21:15:32.949]                       base::stop(msg)
  [21:15:32.949]                     }
  [21:15:32.949]                   })
  [21:15:32.949]                 }
  [21:15:32.949]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:32.949]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:32.949]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:32.949]             }
  [21:15:32.949]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:32.949]         }
  [21:15:32.949]     }
  [21:15:32.949]     if (base::is.na(TRUE)) {
  [21:15:32.949]     }
  [21:15:32.949]     else {
  [21:15:32.949]         if (TRUE) {
  [21:15:32.949]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:32.949]                 open = "w")
  [21:15:32.949]         }
  [21:15:32.949]         else {
  [21:15:32.949]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:32.949]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:32.949]         }
  [21:15:32.949]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:32.949]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:32.949]             base::sink(type = "output", split = FALSE)
  [21:15:32.949]             base::close(...future.stdout)
  [21:15:32.949]         }, add = TRUE)
  [21:15:32.949]     }
  [21:15:32.949]     ...future.frame <- base::sys.nframe()
  [21:15:32.949]     ...future.conditions <- base::list()
  [21:15:32.949]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:32.949]     ...future.result <- base::tryCatch({
  [21:15:32.949]         base::withCallingHandlers({
  [21:15:32.949]             ...future.value <- base::withVisible(base::local({
  [21:15:32.949]                 sample(x, size = 1L)
  [21:15:32.949]             }))
  [21:15:32.949]             future::FutureResult(value = ...future.value$value, 
  [21:15:32.949]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:32.949]                   ...future.rng), started = ...future.startTime, 
  [21:15:32.949]                 version = "1.8")
  [21:15:32.949]         }, condition = base::local({
  [21:15:32.949]             c <- base::c
  [21:15:32.949]             inherits <- base::inherits
  [21:15:32.949]             invokeRestart <- base::invokeRestart
  [21:15:32.949]             length <- base::length
  [21:15:32.949]             list <- base::list
  [21:15:32.949]             seq.int <- base::seq.int
  [21:15:32.949]             signalCondition <- base::signalCondition
  [21:15:32.949]             sys.calls <- base::sys.calls
  [21:15:32.949]             Sys.time <- base::Sys.time
  [21:15:32.949]             `[[` <- base::`[[`
  [21:15:32.949]             `+` <- base::`+`
  [21:15:32.949]             `<<-` <- base::`<<-`
  [21:15:32.949]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:32.949]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:32.949]                   3L)]
  [21:15:32.949]             }
  [21:15:32.949]             function(cond) {
  [21:15:32.949]                 if (inherits(cond, "error")) {
  [21:15:32.949]                   sessionInformation <- function() {
  [21:15:32.949]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:32.949]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:32.949]                       search = base::search(), system = base::Sys.info())
  [21:15:32.949]                   }
  [21:15:32.949]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:32.949]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:32.949]                     cond$call), session = sessionInformation(), 
  [21:15:32.949]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:32.949]                   signalCondition(cond)
  [21:15:32.949]                 }
  [21:15:32.949]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:32.949]                 ))) {
  [21:15:32.949]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:32.949]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:32.949]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:32.949]                   if (!signal) {
  [21:15:32.949]                     muffleCondition <- function (cond) 
  [21:15:32.949]                     {
  [21:15:32.949]                       inherits <- base::inherits
  [21:15:32.949]                       invokeRestart <- base::invokeRestart
  [21:15:32.949]                       muffled <- FALSE
  [21:15:32.949]                       if (inherits(cond, "message")) {
  [21:15:32.949]                         invokeRestart("muffleMessage")
  [21:15:32.949]                         muffled <- TRUE
  [21:15:32.949]                       }
  [21:15:32.949]                       else if (inherits(cond, "warning")) {
  [21:15:32.949]                         invokeRestart("muffleWarning")
  [21:15:32.949]                         muffled <- TRUE
  [21:15:32.949]                       }
  [21:15:32.949]                       else if (inherits(cond, "condition")) {
  [21:15:32.949]                         computeRestarts <- base::computeRestarts
  [21:15:32.949]                         grepl <- base::grepl
  [21:15:32.949]                         is.null <- base::is.null
  [21:15:32.949]                         restarts <- computeRestarts(cond)
  [21:15:32.949]                         for (restart in restarts) {
  [21:15:32.949]                           name <- restart$name
  [21:15:32.949]                           if (is.null(name)) 
  [21:15:32.949]                             next
  [21:15:32.949]                           if (!grepl("^muffle", name)) 
  [21:15:32.949]                             next
  [21:15:32.949]                           invokeRestart(restart)
  [21:15:32.949]                           muffled <- TRUE
  [21:15:32.949]                           break
  [21:15:32.949]                         }
  [21:15:32.949]                       }
  [21:15:32.949]                       invisible(muffled)
  [21:15:32.949]                     }
  [21:15:32.949]                     muffleCondition(cond)
  [21:15:32.949]                   }
  [21:15:32.949]                 }
  [21:15:32.949]             }
  [21:15:32.949]         }))
  [21:15:32.949]     }, error = function(ex) {
  [21:15:32.949]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:32.949]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:32.949]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:32.949]     }, finally = {
  [21:15:32.949]         {
  [21:15:32.949]             NULL
  [21:15:32.949]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:32.949]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:32.949]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:32.949]                 label = NULL, ...) 
  [21:15:32.949]             {
  [21:15:32.949]                 if (substitute) 
  [21:15:32.949]                   expr <- substitute(expr)
  [21:15:32.949]                 local <- as.logical(local)
  [21:15:32.949]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:32.949]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:32.949]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:32.949]                   label = label, ...)
  [21:15:32.949]                 if (!future$lazy) 
  [21:15:32.949]                   future <- run(future)
  [21:15:32.949]                 invisible(future)
  [21:15:32.949]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:32.949]         }
  [21:15:32.949]         base::options(...future.oldOptions)
  [21:15:32.949]     })
  [21:15:32.949]     Sys.time
  [21:15:32.949]     if (base::is.na(TRUE)) {
  [21:15:32.949]     }
  [21:15:32.949]     else {
  [21:15:32.949]         base::sink(type = "output", split = FALSE)
  [21:15:32.949]         if (TRUE) {
  [21:15:32.949]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:32.949]         }
  [21:15:32.949]         else {
  [21:15:32.949]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:32.949]         }
  [21:15:32.949]         base::close(...future.stdout)
  [21:15:32.949]         ...future.stdout <- NULL
  [21:15:32.949]     }
  [21:15:32.949]     ...future.result$conditions <- ...future.conditions
  [21:15:32.949]     ...future.result
  [21:15:32.949] }
  [21:15:32.961] plan(): Setting new future strategy stack:
  [21:15:32.961] List of future strategies:
  [21:15:32.961] 1. sequential:
  [21:15:32.961]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:32.961]    - tweaked: FALSE
  [21:15:32.961]    - call: NULL
  [21:15:32.962] plan(): nbrOfWorkers() = 1
  [21:15:32.964] plan(): Setting new future strategy stack:
  [21:15:32.964] List of future strategies:
  [21:15:32.964] 1. sequential:
  [21:15:32.964]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:32.964]    - tweaked: FALSE
  [21:15:32.964]    - call: plan("sequential")
  [21:15:32.965] plan(): nbrOfWorkers() = 1
  [21:15:32.965] SequentialFuture started (and completed)
  [21:15:32.966] getGlobalsAndPackages() ...
  [21:15:32.967] Searching for globals...
  [21:15:32.969] - globals found: [3] '{', 'sample', 'x'
  [21:15:32.969] Searching for globals ... DONE
  [21:15:32.969] Resolving globals: FALSE
  [21:15:32.970] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:32.970] - globals: [1] 'x'
  [21:15:32.971] 
  [21:15:32.971] getGlobalsAndPackages() ... DONE
  [21:15:32.973] Packages needed by the future expression (n = 0): <none>
  [21:15:32.973] Packages needed by future strategies (n = 0): <none>
  [21:15:32.993] {
  [21:15:32.993]     {
  [21:15:32.993]         ...future.startTime <- base::Sys.time()
  [21:15:32.993]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:32.993]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:32.993]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:32.993]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:32.993]             future.resolve.recursive = NULL, width = 80L)
  [21:15:32.993]         {
  [21:15:32.993]             {
  [21:15:32.993]                 {
  [21:15:32.993]                   base::local({
  [21:15:32.993]                     has_future <- base::requireNamespace("future", 
  [21:15:32.993]                       quietly = TRUE)
  [21:15:32.993]                     version <- if (has_future) 
  [21:15:32.993]                       utils::packageVersion("future")
  [21:15:32.993]                     else NULL
  [21:15:32.993]                     if (!has_future || version < "1.8.0") {
  [21:15:32.993]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:32.993]                         "", base::R.version$version.string), 
  [21:15:32.993]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:32.993]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:32.993]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:32.993]                           "release", "version")], collapse = " "), 
  [21:15:32.993]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:32.993]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:32.993]                         info)
  [21:15:32.993]                       info <- base::paste(info, collapse = "; ")
  [21:15:32.993]                       if (!has_future) {
  [21:15:32.993]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:32.993]                           info)
  [21:15:32.993]                       }
  [21:15:32.993]                       else {
  [21:15:32.993]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:32.993]                           info, version)
  [21:15:32.993]                       }
  [21:15:32.993]                       base::stop(msg)
  [21:15:32.993]                     }
  [21:15:32.993]                   })
  [21:15:32.993]                 }
  [21:15:32.993]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:32.993]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:32.993]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:32.993]             }
  [21:15:32.993]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:32.993]         }
  [21:15:32.993]     }
  [21:15:32.993]     if (base::is.na(TRUE)) {
  [21:15:32.993]     }
  [21:15:32.993]     else {
  [21:15:32.993]         if (TRUE) {
  [21:15:32.993]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:32.993]                 open = "w")
  [21:15:32.993]         }
  [21:15:32.993]         else {
  [21:15:32.993]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:32.993]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:32.993]         }
  [21:15:32.993]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:32.993]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:32.993]             base::sink(type = "output", split = FALSE)
  [21:15:32.993]             base::close(...future.stdout)
  [21:15:32.993]         }, add = TRUE)
  [21:15:32.993]     }
  [21:15:32.993]     ...future.frame <- base::sys.nframe()
  [21:15:32.993]     ...future.conditions <- base::list()
  [21:15:32.993]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:32.993]     ...future.result <- base::tryCatch({
  [21:15:32.993]         base::withCallingHandlers({
  [21:15:32.993]             ...future.value <- base::withVisible(base::local({
  [21:15:32.993]                 sample(x, size = 1L)
  [21:15:32.993]             }))
  [21:15:32.993]             future::FutureResult(value = ...future.value$value, 
  [21:15:32.993]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:32.993]                   ...future.rng), started = ...future.startTime, 
  [21:15:32.993]                 version = "1.8")
  [21:15:32.993]         }, condition = base::local({
  [21:15:32.993]             c <- base::c
  [21:15:32.993]             inherits <- base::inherits
  [21:15:32.993]             invokeRestart <- base::invokeRestart
  [21:15:32.993]             length <- base::length
  [21:15:32.993]             list <- base::list
  [21:15:32.993]             seq.int <- base::seq.int
  [21:15:32.993]             signalCondition <- base::signalCondition
  [21:15:32.993]             sys.calls <- base::sys.calls
  [21:15:32.993]             Sys.time <- base::Sys.time
  [21:15:32.993]             `[[` <- base::`[[`
  [21:15:32.993]             `+` <- base::`+`
  [21:15:32.993]             `<<-` <- base::`<<-`
  [21:15:32.993]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:32.993]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:32.993]                   3L)]
  [21:15:32.993]             }
  [21:15:32.993]             function(cond) {
  [21:15:32.993]                 if (inherits(cond, "error")) {
  [21:15:32.993]                   sessionInformation <- function() {
  [21:15:32.993]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:32.993]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:32.993]                       search = base::search(), system = base::Sys.info())
  [21:15:32.993]                   }
  [21:15:32.993]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:32.993]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:32.993]                     cond$call), session = sessionInformation(), 
  [21:15:32.993]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:32.993]                   signalCondition(cond)
  [21:15:32.993]                 }
  [21:15:32.993]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:32.993]                 ))) {
  [21:15:32.993]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:32.993]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:32.993]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:32.993]                   if (!signal) {
  [21:15:32.993]                     muffleCondition <- function (cond) 
  [21:15:32.993]                     {
  [21:15:32.993]                       inherits <- base::inherits
  [21:15:32.993]                       invokeRestart <- base::invokeRestart
  [21:15:32.993]                       muffled <- FALSE
  [21:15:32.993]                       if (inherits(cond, "message")) {
  [21:15:32.993]                         invokeRestart("muffleMessage")
  [21:15:32.993]                         muffled <- TRUE
  [21:15:32.993]                       }
  [21:15:32.993]                       else if (inherits(cond, "warning")) {
  [21:15:32.993]                         invokeRestart("muffleWarning")
  [21:15:32.993]                         muffled <- TRUE
  [21:15:32.993]                       }
  [21:15:32.993]                       else if (inherits(cond, "condition")) {
  [21:15:32.993]                         computeRestarts <- base::computeRestarts
  [21:15:32.993]                         grepl <- base::grepl
  [21:15:32.993]                         is.null <- base::is.null
  [21:15:32.993]                         restarts <- computeRestarts(cond)
  [21:15:32.993]                         for (restart in restarts) {
  [21:15:32.993]                           name <- restart$name
  [21:15:32.993]                           if (is.null(name)) 
  [21:15:32.993]                             next
  [21:15:32.993]                           if (!grepl("^muffle", name)) 
  [21:15:32.993]                             next
  [21:15:32.993]                           invokeRestart(restart)
  [21:15:32.993]                           muffled <- TRUE
  [21:15:32.993]                           break
  [21:15:32.993]                         }
  [21:15:32.993]                       }
  [21:15:32.993]                       invisible(muffled)
  [21:15:32.993]                     }
  [21:15:32.993]                     muffleCondition(cond)
  [21:15:32.993]                   }
  [21:15:32.993]                 }
  [21:15:32.993]             }
  [21:15:32.993]         }))
  [21:15:32.993]     }, error = function(ex) {
  [21:15:32.993]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:32.993]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:32.993]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:32.993]     }, finally = {
  [21:15:32.993]         {
  [21:15:32.993]             NULL
  [21:15:32.993]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:32.993]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:32.993]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:32.993]                 label = NULL, ...) 
  [21:15:32.993]             {
  [21:15:32.993]                 if (substitute) 
  [21:15:32.993]                   expr <- substitute(expr)
  [21:15:32.993]                 local <- as.logical(local)
  [21:15:32.993]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:32.993]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:32.993]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:32.993]                   label = label, ...)
  [21:15:32.993]                 if (!future$lazy) 
  [21:15:32.993]                   future <- run(future)
  [21:15:32.993]                 invisible(future)
  [21:15:32.993]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:32.993]         }
  [21:15:32.993]         base::options(...future.oldOptions)
  [21:15:32.993]     })
  [21:15:32.993]     Sys.time
  [21:15:32.993]     if (base::is.na(TRUE)) {
  [21:15:32.993]     }
  [21:15:32.993]     else {
  [21:15:32.993]         base::sink(type = "output", split = FALSE)
  [21:15:32.993]         if (TRUE) {
  [21:15:32.993]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:32.993]         }
  [21:15:32.993]         else {
  [21:15:32.993]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:32.993]         }
  [21:15:32.993]         base::close(...future.stdout)
  [21:15:32.993]         ...future.stdout <- NULL
  [21:15:32.993]     }
  [21:15:32.993]     ...future.result$conditions <- ...future.conditions
  [21:15:32.993]     ...future.result
  [21:15:32.993] }
  [21:15:32.997] plan(): Setting new future strategy stack:
  [21:15:32.998] List of future strategies:
  [21:15:32.998] 1. sequential:
  [21:15:32.998]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:32.998]    - tweaked: FALSE
  [21:15:32.998]    - call: NULL
  [21:15:32.998] plan(): nbrOfWorkers() = 1
  [21:15:32.999] plan(): Setting new future strategy stack:
  [21:15:33.000] List of future strategies:
  [21:15:33.000] 1. sequential:
  [21:15:33.000]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.000]    - tweaked: FALSE
  [21:15:33.000]    - call: plan("sequential")
  [21:15:33.000] plan(): nbrOfWorkers() = 1
  [21:15:33.001] SequentialFuture started (and completed)
  [21:15:33.001] getGlobalsAndPackages() ...
  [21:15:33.002] Searching for globals...
  [21:15:33.004] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.004] Searching for globals ... DONE
  [21:15:33.004] Resolving globals: FALSE
  [21:15:33.005] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.005] - globals: [1] 'x'
  [21:15:33.022] 
  [21:15:33.022] getGlobalsAndPackages() ... DONE
  [21:15:33.024] Packages needed by the future expression (n = 0): <none>
  [21:15:33.024] Packages needed by future strategies (n = 0): <none>
  [21:15:33.028] {
  [21:15:33.028]     {
  [21:15:33.028]         ...future.startTime <- base::Sys.time()
  [21:15:33.028]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.028]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.028]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.028]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.028]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.028]         {
  [21:15:33.028]             {
  [21:15:33.028]                 {
  [21:15:33.028]                   base::local({
  [21:15:33.028]                     has_future <- base::requireNamespace("future", 
  [21:15:33.028]                       quietly = TRUE)
  [21:15:33.028]                     version <- if (has_future) 
  [21:15:33.028]                       utils::packageVersion("future")
  [21:15:33.028]                     else NULL
  [21:15:33.028]                     if (!has_future || version < "1.8.0") {
  [21:15:33.028]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.028]                         "", base::R.version$version.string), 
  [21:15:33.028]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.028]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.028]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.028]                           "release", "version")], collapse = " "), 
  [21:15:33.028]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.028]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.028]                         info)
  [21:15:33.028]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.028]                       if (!has_future) {
  [21:15:33.028]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.028]                           info)
  [21:15:33.028]                       }
  [21:15:33.028]                       else {
  [21:15:33.028]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.028]                           info, version)
  [21:15:33.028]                       }
  [21:15:33.028]                       base::stop(msg)
  [21:15:33.028]                     }
  [21:15:33.028]                   })
  [21:15:33.028]                 }
  [21:15:33.028]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:33.028]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:33.028]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.028]             }
  [21:15:33.028]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.028]         }
  [21:15:33.028]     }
  [21:15:33.028]     if (base::is.na(TRUE)) {
  [21:15:33.028]     }
  [21:15:33.028]     else {
  [21:15:33.028]         if (TRUE) {
  [21:15:33.028]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.028]                 open = "w")
  [21:15:33.028]         }
  [21:15:33.028]         else {
  [21:15:33.028]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.028]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.028]         }
  [21:15:33.028]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.028]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.028]             base::sink(type = "output", split = FALSE)
  [21:15:33.028]             base::close(...future.stdout)
  [21:15:33.028]         }, add = TRUE)
  [21:15:33.028]     }
  [21:15:33.028]     ...future.frame <- base::sys.nframe()
  [21:15:33.028]     ...future.conditions <- base::list()
  [21:15:33.028]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.028]     ...future.result <- base::tryCatch({
  [21:15:33.028]         base::withCallingHandlers({
  [21:15:33.028]             ...future.value <- base::withVisible(base::local({
  [21:15:33.028]                 sample(x, size = 1L)
  [21:15:33.028]             }))
  [21:15:33.028]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.028]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.028]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.028]                 version = "1.8")
  [21:15:33.028]         }, condition = base::local({
  [21:15:33.028]             c <- base::c
  [21:15:33.028]             inherits <- base::inherits
  [21:15:33.028]             invokeRestart <- base::invokeRestart
  [21:15:33.028]             length <- base::length
  [21:15:33.028]             list <- base::list
  [21:15:33.028]             seq.int <- base::seq.int
  [21:15:33.028]             signalCondition <- base::signalCondition
  [21:15:33.028]             sys.calls <- base::sys.calls
  [21:15:33.028]             Sys.time <- base::Sys.time
  [21:15:33.028]             `[[` <- base::`[[`
  [21:15:33.028]             `+` <- base::`+`
  [21:15:33.028]             `<<-` <- base::`<<-`
  [21:15:33.028]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.028]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.028]                   3L)]
  [21:15:33.028]             }
  [21:15:33.028]             function(cond) {
  [21:15:33.028]                 if (inherits(cond, "error")) {
  [21:15:33.028]                   sessionInformation <- function() {
  [21:15:33.028]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.028]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.028]                       search = base::search(), system = base::Sys.info())
  [21:15:33.028]                   }
  [21:15:33.028]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.028]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.028]                     cond$call), session = sessionInformation(), 
  [21:15:33.028]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.028]                   signalCondition(cond)
  [21:15:33.028]                 }
  [21:15:33.028]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.028]                 ))) {
  [21:15:33.028]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.028]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.028]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.028]                   if (!signal) {
  [21:15:33.028]                     muffleCondition <- function (cond) 
  [21:15:33.028]                     {
  [21:15:33.028]                       inherits <- base::inherits
  [21:15:33.028]                       invokeRestart <- base::invokeRestart
  [21:15:33.028]                       muffled <- FALSE
  [21:15:33.028]                       if (inherits(cond, "message")) {
  [21:15:33.028]                         invokeRestart("muffleMessage")
  [21:15:33.028]                         muffled <- TRUE
  [21:15:33.028]                       }
  [21:15:33.028]                       else if (inherits(cond, "warning")) {
  [21:15:33.028]                         invokeRestart("muffleWarning")
  [21:15:33.028]                         muffled <- TRUE
  [21:15:33.028]                       }
  [21:15:33.028]                       else if (inherits(cond, "condition")) {
  [21:15:33.028]                         computeRestarts <- base::computeRestarts
  [21:15:33.028]                         grepl <- base::grepl
  [21:15:33.028]                         is.null <- base::is.null
  [21:15:33.028]                         restarts <- computeRestarts(cond)
  [21:15:33.028]                         for (restart in restarts) {
  [21:15:33.028]                           name <- restart$name
  [21:15:33.028]                           if (is.null(name)) 
  [21:15:33.028]                             next
  [21:15:33.028]                           if (!grepl("^muffle", name)) 
  [21:15:33.028]                             next
  [21:15:33.028]                           invokeRestart(restart)
  [21:15:33.028]                           muffled <- TRUE
  [21:15:33.028]                           break
  [21:15:33.028]                         }
  [21:15:33.028]                       }
  [21:15:33.028]                       invisible(muffled)
  [21:15:33.028]                     }
  [21:15:33.028]                     muffleCondition(cond)
  [21:15:33.028]                   }
  [21:15:33.028]                 }
  [21:15:33.028]             }
  [21:15:33.028]         }))
  [21:15:33.028]     }, error = function(ex) {
  [21:15:33.028]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.028]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.028]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.028]     }, finally = {
  [21:15:33.028]         {
  [21:15:33.028]             NULL
  [21:15:33.028]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.028]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.028]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.028]                 label = NULL, ...) 
  [21:15:33.028]             {
  [21:15:33.028]                 if (substitute) 
  [21:15:33.028]                   expr <- substitute(expr)
  [21:15:33.028]                 local <- as.logical(local)
  [21:15:33.028]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.028]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.028]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.028]                   label = label, ...)
  [21:15:33.028]                 if (!future$lazy) 
  [21:15:33.028]                   future <- run(future)
  [21:15:33.028]                 invisible(future)
  [21:15:33.028]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.028]         }
  [21:15:33.028]         base::options(...future.oldOptions)
  [21:15:33.028]     })
  [21:15:33.028]     Sys.time
  [21:15:33.028]     if (base::is.na(TRUE)) {
  [21:15:33.028]     }
  [21:15:33.028]     else {
  [21:15:33.028]         base::sink(type = "output", split = FALSE)
  [21:15:33.028]         if (TRUE) {
  [21:15:33.028]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.028]         }
  [21:15:33.028]         else {
  [21:15:33.028]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.028]         }
  [21:15:33.028]         base::close(...future.stdout)
  [21:15:33.028]         ...future.stdout <- NULL
  [21:15:33.028]     }
  [21:15:33.028]     ...future.result$conditions <- ...future.conditions
  [21:15:33.028]     ...future.result
  [21:15:33.028] }
  [21:15:33.033] plan(): Setting new future strategy stack:
  [21:15:33.033] List of future strategies:
  [21:15:33.033] 1. sequential:
  [21:15:33.033]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.033]    - tweaked: FALSE
  [21:15:33.033]    - call: NULL
  [21:15:33.034] plan(): nbrOfWorkers() = 1
  [21:15:33.035] plan(): Setting new future strategy stack:
  [21:15:33.035] List of future strategies:
  [21:15:33.035] 1. sequential:
  [21:15:33.035]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.035]    - tweaked: FALSE
  [21:15:33.035]    - call: plan("sequential")
  [21:15:33.036] plan(): nbrOfWorkers() = 1
  [21:15:33.037] SequentialFuture started (and completed)
  [21:15:33.037] getGlobalsAndPackages() ...
  [21:15:33.037] Searching for globals...
  [21:15:33.040] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.040] Searching for globals ... DONE
  [21:15:33.040] Resolving globals: FALSE
  [21:15:33.041] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.041] - globals: [1] 'x'
  [21:15:33.042] 
  [21:15:33.042] getGlobalsAndPackages() ... DONE
  [21:15:33.044] Packages needed by the future expression (n = 0): <none>
  [21:15:33.044] Packages needed by future strategies (n = 0): <none>
  [21:15:33.048] {
  [21:15:33.048]     {
  [21:15:33.048]         ...future.startTime <- base::Sys.time()
  [21:15:33.048]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.048]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.048]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.048]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.048]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.048]         {
  [21:15:33.048]             {
  [21:15:33.048]                 {
  [21:15:33.048]                   base::local({
  [21:15:33.048]                     has_future <- base::requireNamespace("future", 
  [21:15:33.048]                       quietly = TRUE)
  [21:15:33.048]                     version <- if (has_future) 
  [21:15:33.048]                       utils::packageVersion("future")
  [21:15:33.048]                     else NULL
  [21:15:33.048]                     if (!has_future || version < "1.8.0") {
  [21:15:33.048]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.048]                         "", base::R.version$version.string), 
  [21:15:33.048]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.048]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.048]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.048]                           "release", "version")], collapse = " "), 
  [21:15:33.048]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.048]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.048]                         info)
  [21:15:33.048]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.048]                       if (!has_future) {
  [21:15:33.048]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.048]                           info)
  [21:15:33.048]                       }
  [21:15:33.048]                       else {
  [21:15:33.048]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.048]                           info, version)
  [21:15:33.048]                       }
  [21:15:33.048]                       base::stop(msg)
  [21:15:33.048]                     }
  [21:15:33.048]                   })
  [21:15:33.048]                 }
  [21:15:33.048]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:33.048]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:33.048]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.048]             }
  [21:15:33.048]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.048]         }
  [21:15:33.048]     }
  [21:15:33.048]     if (base::is.na(TRUE)) {
  [21:15:33.048]     }
  [21:15:33.048]     else {
  [21:15:33.048]         if (TRUE) {
  [21:15:33.048]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.048]                 open = "w")
  [21:15:33.048]         }
  [21:15:33.048]         else {
  [21:15:33.048]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.048]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.048]         }
  [21:15:33.048]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.048]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.048]             base::sink(type = "output", split = FALSE)
  [21:15:33.048]             base::close(...future.stdout)
  [21:15:33.048]         }, add = TRUE)
  [21:15:33.048]     }
  [21:15:33.048]     ...future.frame <- base::sys.nframe()
  [21:15:33.048]     ...future.conditions <- base::list()
  [21:15:33.048]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.048]     ...future.result <- base::tryCatch({
  [21:15:33.048]         base::withCallingHandlers({
  [21:15:33.048]             ...future.value <- base::withVisible(base::local({
  [21:15:33.048]                 sample(x, size = 1L)
  [21:15:33.048]             }))
  [21:15:33.048]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.048]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.048]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.048]                 version = "1.8")
  [21:15:33.048]         }, condition = base::local({
  [21:15:33.048]             c <- base::c
  [21:15:33.048]             inherits <- base::inherits
  [21:15:33.048]             invokeRestart <- base::invokeRestart
  [21:15:33.048]             length <- base::length
  [21:15:33.048]             list <- base::list
  [21:15:33.048]             seq.int <- base::seq.int
  [21:15:33.048]             signalCondition <- base::signalCondition
  [21:15:33.048]             sys.calls <- base::sys.calls
  [21:15:33.048]             Sys.time <- base::Sys.time
  [21:15:33.048]             `[[` <- base::`[[`
  [21:15:33.048]             `+` <- base::`+`
  [21:15:33.048]             `<<-` <- base::`<<-`
  [21:15:33.048]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.048]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.048]                   3L)]
  [21:15:33.048]             }
  [21:15:33.048]             function(cond) {
  [21:15:33.048]                 if (inherits(cond, "error")) {
  [21:15:33.048]                   sessionInformation <- function() {
  [21:15:33.048]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.048]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.048]                       search = base::search(), system = base::Sys.info())
  [21:15:33.048]                   }
  [21:15:33.048]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.048]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.048]                     cond$call), session = sessionInformation(), 
  [21:15:33.048]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.048]                   signalCondition(cond)
  [21:15:33.048]                 }
  [21:15:33.048]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.048]                 ))) {
  [21:15:33.048]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.048]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.048]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.048]                   if (!signal) {
  [21:15:33.048]                     muffleCondition <- function (cond) 
  [21:15:33.048]                     {
  [21:15:33.048]                       inherits <- base::inherits
  [21:15:33.048]                       invokeRestart <- base::invokeRestart
  [21:15:33.048]                       muffled <- FALSE
  [21:15:33.048]                       if (inherits(cond, "message")) {
  [21:15:33.048]                         invokeRestart("muffleMessage")
  [21:15:33.048]                         muffled <- TRUE
  [21:15:33.048]                       }
  [21:15:33.048]                       else if (inherits(cond, "warning")) {
  [21:15:33.048]                         invokeRestart("muffleWarning")
  [21:15:33.048]                         muffled <- TRUE
  [21:15:33.048]                       }
  [21:15:33.048]                       else if (inherits(cond, "condition")) {
  [21:15:33.048]                         computeRestarts <- base::computeRestarts
  [21:15:33.048]                         grepl <- base::grepl
  [21:15:33.048]                         is.null <- base::is.null
  [21:15:33.048]                         restarts <- computeRestarts(cond)
  [21:15:33.048]                         for (restart in restarts) {
  [21:15:33.048]                           name <- restart$name
  [21:15:33.048]                           if (is.null(name)) 
  [21:15:33.048]                             next
  [21:15:33.048]                           if (!grepl("^muffle", name)) 
  [21:15:33.048]                             next
  [21:15:33.048]                           invokeRestart(restart)
  [21:15:33.048]                           muffled <- TRUE
  [21:15:33.048]                           break
  [21:15:33.048]                         }
  [21:15:33.048]                       }
  [21:15:33.048]                       invisible(muffled)
  [21:15:33.048]                     }
  [21:15:33.048]                     muffleCondition(cond)
  [21:15:33.048]                   }
  [21:15:33.048]                 }
  [21:15:33.048]             }
  [21:15:33.048]         }))
  [21:15:33.048]     }, error = function(ex) {
  [21:15:33.048]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.048]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.048]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.048]     }, finally = {
  [21:15:33.048]         {
  [21:15:33.048]             NULL
  [21:15:33.048]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.048]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.048]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.048]                 label = NULL, ...) 
  [21:15:33.048]             {
  [21:15:33.048]                 if (substitute) 
  [21:15:33.048]                   expr <- substitute(expr)
  [21:15:33.048]                 local <- as.logical(local)
  [21:15:33.048]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.048]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.048]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.048]                   label = label, ...)
  [21:15:33.048]                 if (!future$lazy) 
  [21:15:33.048]                   future <- run(future)
  [21:15:33.048]                 invisible(future)
  [21:15:33.048]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.048]         }
  [21:15:33.048]         base::options(...future.oldOptions)
  [21:15:33.048]     })
  [21:15:33.048]     Sys.time
  [21:15:33.048]     if (base::is.na(TRUE)) {
  [21:15:33.048]     }
  [21:15:33.048]     else {
  [21:15:33.048]         base::sink(type = "output", split = FALSE)
  [21:15:33.048]         if (TRUE) {
  [21:15:33.048]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.048]         }
  [21:15:33.048]         else {
  [21:15:33.048]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.048]         }
  [21:15:33.048]         base::close(...future.stdout)
  [21:15:33.048]         ...future.stdout <- NULL
  [21:15:33.048]     }
  [21:15:33.048]     ...future.result$conditions <- ...future.conditions
  [21:15:33.048]     ...future.result
  [21:15:33.048] }
  [21:15:33.053] plan(): Setting new future strategy stack:
  [21:15:33.054] List of future strategies:
  [21:15:33.054] 1. sequential:
  [21:15:33.054]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.054]    - tweaked: FALSE
  [21:15:33.054]    - call: NULL
  [21:15:33.055] plan(): nbrOfWorkers() = 1
  [21:15:33.056] plan(): Setting new future strategy stack:
  [21:15:33.056] List of future strategies:
  [21:15:33.056] 1. sequential:
  [21:15:33.056]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.056]    - tweaked: FALSE
  [21:15:33.056]    - call: plan("sequential")
  [21:15:33.057] plan(): nbrOfWorkers() = 1
  [21:15:33.057] SequentialFuture started (and completed)
  [21:15:33.058] resolve() on list ...
  [21:15:33.058]  recursive: 0
  [21:15:33.059]  length: 4
  [21:15:33.059] 
  [21:15:33.060] Future #1
  [21:15:33.060] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.061] - nx: 4
  [21:15:33.061] - relay: TRUE
  [21:15:33.061] - stdout: TRUE
  [21:15:33.061] - signal: TRUE
  [21:15:33.062] - resignal: FALSE
  [21:15:33.062] - force: TRUE
  [21:15:33.062] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.062] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.067]  - until=1
  [21:15:33.067]  - relaying element #1
  [21:15:33.068] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.068] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.068] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.069]  length: 3 (resolved future 1)
  [21:15:33.069] Future #2
  [21:15:33.070] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.070] - nx: 4
  [21:15:33.070] - relay: TRUE
  [21:15:33.070] - stdout: TRUE
  [21:15:33.070] - signal: TRUE
  [21:15:33.071] - resignal: FALSE
  [21:15:33.071] - force: TRUE
  [21:15:33.071] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.071] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.072]  - until=2
  [21:15:33.072]  - relaying element #2
  [21:15:33.072] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.072] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.073] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.073]  length: 2 (resolved future 2)
  [21:15:33.073] Future #3
  [21:15:33.074] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.074] - nx: 4
  [21:15:33.074] - relay: TRUE
  [21:15:33.074] - stdout: TRUE
  [21:15:33.075] - signal: TRUE
  [21:15:33.075] - resignal: FALSE
  [21:15:33.075] - force: TRUE
  [21:15:33.075] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.076] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.076]  - until=3
  [21:15:33.076]  - relaying element #3
  [21:15:33.077] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.077] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.077] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.077]  length: 1 (resolved future 3)
  [21:15:33.078] Future #4
  [21:15:33.078] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.078] - nx: 4
  [21:15:33.079] - relay: TRUE
  [21:15:33.079] - stdout: TRUE
  [21:15:33.079] - signal: TRUE
  [21:15:33.079] - resignal: FALSE
  [21:15:33.079] - force: TRUE
  [21:15:33.080] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.080] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.080]  - until=4
  [21:15:33.080]  - relaying element #4
  [21:15:33.081] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.081] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.081] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.082]  length: 0 (resolved future 4)
  [21:15:33.082] Relaying remaining futures
  [21:15:33.082] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.082] - nx: 4
  [21:15:33.083] - relay: TRUE
  [21:15:33.083] - stdout: TRUE
  [21:15:33.083] - signal: TRUE
  [21:15:33.083] - resignal: FALSE
  [21:15:33.084] - force: TRUE
  [21:15:33.084] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.084] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.085] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.085] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.085] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.085] resolve() on list ... DONE
  > 
  > ## Assert that random seed is reset
  > stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
  > 
  > 
  > 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("%s ...", strategy))
  + 
  +     plan(strategy)
  + 
  +     for (what in c("future", "%<-%")) {
  +       .GlobalEnv$.Random.seed <- seed0
  + 
  +       ## Fixed random seed
  +       y1 <- fsample(0:3, seed = 42L, what = what)
  +       print(y1)
  +       stopifnot(identical(y1, y0))
  +   
  +       ## Assert that random seed is reset
  +       stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
  +   
  +       ## Fixed random seed
  +       y2 <- fsample(0:3, seed = 42L, what = what)
  +       print(y2)
  +       stopifnot(identical(y2, y1))
  +       stopifnot(identical(y2, y0))
  +   
  +       ## Assert that random seed is reset
  +       stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
  +   
  +       ## No seed
  +       for (misuse in c("ignore", "warning", "error")) {
  +         options(future.rng.onMisuse = misuse)
  + 
  +         y3 <- tryCatch({
  + 	  ## WORKAROUND: fsample() triggers a R_FUTURE_GLOBALS_ONREFERENCE
  + 	  ##             warning.  Not sure why. /HB 2019-12-27
  + 	  ovalue <- Sys.getenv("R_FUTURE_GLOBALS_ONREFERENCE")
  + 	  on.exit(Sys.setenv("R_FUTURE_GLOBALS_ONREFERENCE" = ovalue))
  + 	  Sys.setenv("R_FUTURE_GLOBALS_ONREFERENCE" = "ignore")
  + 	  
  +           fsample(0:3, what = what, seed = FALSE)
  +         }, warning = identity, error = identity)
  +         print(y3)
  +         if (misuse %in% c("warning", "error")) {
  +           stopifnot(inherits(y3, misuse))
  +         }
  + 
  +         ## seed = NULL equals seed = FALSE but without the check of misuse
  +         y4 <- fsample(0:3, what = what, seed = NULL)
  +         print(y4)
  +       }
  +       
  +       options(future.rng.onMisuse = "ignore")
  +     }
  + 
  +     message(sprintf("%s ... done", strategy))
  +   }
  + 
  +   message(sprintf("Testing with %d cores ... DONE", cores))
  + } ## for (cores ...)
  Testing with 1 cores ...
  sequential ...
  [21:15:33.143] plan(): Setting new future strategy stack:
  [21:15:33.143] List of future strategies:
  [21:15:33.143] 1. sequential:
  [21:15:33.143]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.143]    - tweaked: FALSE
  [21:15:33.143]    - call: plan(strategy)
  [21:15:33.144] plan(): nbrOfWorkers() = 1
  [21:15:33.144] getGlobalsAndPackages() ...
  [21:15:33.144] Searching for globals...
  [21:15:33.146] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.147] Searching for globals ... DONE
  [21:15:33.147] Resolving globals: FALSE
  [21:15:33.148] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.148] - globals: [1] 'x'
  [21:15:33.148] 
  [21:15:33.148] getGlobalsAndPackages() ... DONE
  [21:15:33.150] Packages needed by the future expression (n = 0): <none>
  [21:15:33.151] Packages needed by future strategies (n = 0): <none>
  [21:15:33.155] {
  [21:15:33.155]     {
  [21:15:33.155]         ...future.startTime <- base::Sys.time()
  [21:15:33.155]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.155]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.155]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.155]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.155]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.155]         {
  [21:15:33.155]             {
  [21:15:33.155]                 {
  [21:15:33.155]                   base::local({
  [21:15:33.155]                     has_future <- base::requireNamespace("future", 
  [21:15:33.155]                       quietly = TRUE)
  [21:15:33.155]                     version <- if (has_future) 
  [21:15:33.155]                       utils::packageVersion("future")
  [21:15:33.155]                     else NULL
  [21:15:33.155]                     if (!has_future || version < "1.8.0") {
  [21:15:33.155]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.155]                         "", base::R.version$version.string), 
  [21:15:33.155]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.155]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.155]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.155]                           "release", "version")], collapse = " "), 
  [21:15:33.155]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.155]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.155]                         info)
  [21:15:33.155]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.155]                       if (!has_future) {
  [21:15:33.155]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.155]                           info)
  [21:15:33.155]                       }
  [21:15:33.155]                       else {
  [21:15:33.155]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.155]                           info, version)
  [21:15:33.155]                       }
  [21:15:33.155]                       base::stop(msg)
  [21:15:33.155]                     }
  [21:15:33.155]                   })
  [21:15:33.155]                 }
  [21:15:33.155]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:33.155]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:33.155]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.155]             }
  [21:15:33.155]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.155]         }
  [21:15:33.155]     }
  [21:15:33.155]     if (base::is.na(TRUE)) {
  [21:15:33.155]     }
  [21:15:33.155]     else {
  [21:15:33.155]         if (TRUE) {
  [21:15:33.155]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.155]                 open = "w")
  [21:15:33.155]         }
  [21:15:33.155]         else {
  [21:15:33.155]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.155]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.155]         }
  [21:15:33.155]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.155]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.155]             base::sink(type = "output", split = FALSE)
  [21:15:33.155]             base::close(...future.stdout)
  [21:15:33.155]         }, add = TRUE)
  [21:15:33.155]     }
  [21:15:33.155]     ...future.frame <- base::sys.nframe()
  [21:15:33.155]     ...future.conditions <- base::list()
  [21:15:33.155]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.155]     ...future.result <- base::tryCatch({
  [21:15:33.155]         base::withCallingHandlers({
  [21:15:33.155]             ...future.value <- base::withVisible(base::local({
  [21:15:33.155]                 sample(x, size = 1L)
  [21:15:33.155]             }))
  [21:15:33.155]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.155]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.155]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.155]                 version = "1.8")
  [21:15:33.155]         }, condition = base::local({
  [21:15:33.155]             c <- base::c
  [21:15:33.155]             inherits <- base::inherits
  [21:15:33.155]             invokeRestart <- base::invokeRestart
  [21:15:33.155]             length <- base::length
  [21:15:33.155]             list <- base::list
  [21:15:33.155]             seq.int <- base::seq.int
  [21:15:33.155]             signalCondition <- base::signalCondition
  [21:15:33.155]             sys.calls <- base::sys.calls
  [21:15:33.155]             Sys.time <- base::Sys.time
  [21:15:33.155]             `[[` <- base::`[[`
  [21:15:33.155]             `+` <- base::`+`
  [21:15:33.155]             `<<-` <- base::`<<-`
  [21:15:33.155]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.155]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.155]                   3L)]
  [21:15:33.155]             }
  [21:15:33.155]             function(cond) {
  [21:15:33.155]                 if (inherits(cond, "error")) {
  [21:15:33.155]                   sessionInformation <- function() {
  [21:15:33.155]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.155]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.155]                       search = base::search(), system = base::Sys.info())
  [21:15:33.155]                   }
  [21:15:33.155]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.155]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.155]                     cond$call), session = sessionInformation(), 
  [21:15:33.155]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.155]                   signalCondition(cond)
  [21:15:33.155]                 }
  [21:15:33.155]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.155]                 ))) {
  [21:15:33.155]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.155]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.155]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.155]                   if (!signal) {
  [21:15:33.155]                     muffleCondition <- function (cond) 
  [21:15:33.155]                     {
  [21:15:33.155]                       inherits <- base::inherits
  [21:15:33.155]                       invokeRestart <- base::invokeRestart
  [21:15:33.155]                       muffled <- FALSE
  [21:15:33.155]                       if (inherits(cond, "message")) {
  [21:15:33.155]                         invokeRestart("muffleMessage")
  [21:15:33.155]                         muffled <- TRUE
  [21:15:33.155]                       }
  [21:15:33.155]                       else if (inherits(cond, "warning")) {
  [21:15:33.155]                         invokeRestart("muffleWarning")
  [21:15:33.155]                         muffled <- TRUE
  [21:15:33.155]                       }
  [21:15:33.155]                       else if (inherits(cond, "condition")) {
  [21:15:33.155]                         computeRestarts <- base::computeRestarts
  [21:15:33.155]                         grepl <- base::grepl
  [21:15:33.155]                         is.null <- base::is.null
  [21:15:33.155]                         restarts <- computeRestarts(cond)
  [21:15:33.155]                         for (restart in restarts) {
  [21:15:33.155]                           name <- restart$name
  [21:15:33.155]                           if (is.null(name)) 
  [21:15:33.155]                             next
  [21:15:33.155]                           if (!grepl("^muffle", name)) 
  [21:15:33.155]                             next
  [21:15:33.155]                           invokeRestart(restart)
  [21:15:33.155]                           muffled <- TRUE
  [21:15:33.155]                           break
  [21:15:33.155]                         }
  [21:15:33.155]                       }
  [21:15:33.155]                       invisible(muffled)
  [21:15:33.155]                     }
  [21:15:33.155]                     muffleCondition(cond)
  [21:15:33.155]                   }
  [21:15:33.155]                 }
  [21:15:33.155]             }
  [21:15:33.155]         }))
  [21:15:33.155]     }, error = function(ex) {
  [21:15:33.155]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.155]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.155]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.155]     }, finally = {
  [21:15:33.155]         {
  [21:15:33.155]             NULL
  [21:15:33.155]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.155]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.155]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.155]                 label = NULL, ...) 
  [21:15:33.155]             {
  [21:15:33.155]                 if (substitute) 
  [21:15:33.155]                   expr <- substitute(expr)
  [21:15:33.155]                 local <- as.logical(local)
  [21:15:33.155]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.155]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.155]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.155]                   label = label, ...)
  [21:15:33.155]                 if (!future$lazy) 
  [21:15:33.155]                   future <- run(future)
  [21:15:33.155]                 invisible(future)
  [21:15:33.155]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.155]         }
  [21:15:33.155]         base::options(...future.oldOptions)
  [21:15:33.155]     })
  [21:15:33.155]     Sys.time
  [21:15:33.155]     if (base::is.na(TRUE)) {
  [21:15:33.155]     }
  [21:15:33.155]     else {
  [21:15:33.155]         base::sink(type = "output", split = FALSE)
  [21:15:33.155]         if (TRUE) {
  [21:15:33.155]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.155]         }
  [21:15:33.155]         else {
  [21:15:33.155]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.155]         }
  [21:15:33.155]         base::close(...future.stdout)
  [21:15:33.155]         ...future.stdout <- NULL
  [21:15:33.155]     }
  [21:15:33.155]     ...future.result$conditions <- ...future.conditions
  [21:15:33.155]     ...future.result
  [21:15:33.155] }
  [21:15:33.160] plan(): Setting new future strategy stack:
  [21:15:33.160] List of future strategies:
  [21:15:33.160] 1. sequential:
  [21:15:33.160]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.160]    - tweaked: FALSE
  [21:15:33.160]    - call: NULL
  [21:15:33.161] plan(): nbrOfWorkers() = 1
  [21:15:33.162] plan(): Setting new future strategy stack:
  [21:15:33.162] List of future strategies:
  [21:15:33.162] 1. sequential:
  [21:15:33.162]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.162]    - tweaked: FALSE
  [21:15:33.162]    - call: plan(strategy)
  [21:15:33.163] plan(): nbrOfWorkers() = 1
  [21:15:33.163] SequentialFuture started (and completed)
  [21:15:33.164] getGlobalsAndPackages() ...
  [21:15:33.164] Searching for globals...
  [21:15:33.166] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.166] Searching for globals ... DONE
  [21:15:33.166] Resolving globals: FALSE
  [21:15:33.167] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.167] - globals: [1] 'x'
  [21:15:33.168] 
  [21:15:33.168] getGlobalsAndPackages() ... DONE
  [21:15:33.170] Packages needed by the future expression (n = 0): <none>
  [21:15:33.170] Packages needed by future strategies (n = 0): <none>
  [21:15:33.174] {
  [21:15:33.174]     {
  [21:15:33.174]         ...future.startTime <- base::Sys.time()
  [21:15:33.174]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.174]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.174]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.174]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.174]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.174]         {
  [21:15:33.174]             {
  [21:15:33.174]                 {
  [21:15:33.174]                   base::local({
  [21:15:33.174]                     has_future <- base::requireNamespace("future", 
  [21:15:33.174]                       quietly = TRUE)
  [21:15:33.174]                     version <- if (has_future) 
  [21:15:33.174]                       utils::packageVersion("future")
  [21:15:33.174]                     else NULL
  [21:15:33.174]                     if (!has_future || version < "1.8.0") {
  [21:15:33.174]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.174]                         "", base::R.version$version.string), 
  [21:15:33.174]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.174]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.174]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.174]                           "release", "version")], collapse = " "), 
  [21:15:33.174]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.174]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.174]                         info)
  [21:15:33.174]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.174]                       if (!has_future) {
  [21:15:33.174]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.174]                           info)
  [21:15:33.174]                       }
  [21:15:33.174]                       else {
  [21:15:33.174]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.174]                           info, version)
  [21:15:33.174]                       }
  [21:15:33.174]                       base::stop(msg)
  [21:15:33.174]                     }
  [21:15:33.174]                   })
  [21:15:33.174]                 }
  [21:15:33.174]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:33.174]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:33.174]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.174]             }
  [21:15:33.174]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.174]         }
  [21:15:33.174]     }
  [21:15:33.174]     if (base::is.na(TRUE)) {
  [21:15:33.174]     }
  [21:15:33.174]     else {
  [21:15:33.174]         if (TRUE) {
  [21:15:33.174]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.174]                 open = "w")
  [21:15:33.174]         }
  [21:15:33.174]         else {
  [21:15:33.174]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.174]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.174]         }
  [21:15:33.174]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.174]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.174]             base::sink(type = "output", split = FALSE)
  [21:15:33.174]             base::close(...future.stdout)
  [21:15:33.174]         }, add = TRUE)
  [21:15:33.174]     }
  [21:15:33.174]     ...future.frame <- base::sys.nframe()
  [21:15:33.174]     ...future.conditions <- base::list()
  [21:15:33.174]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.174]     ...future.result <- base::tryCatch({
  [21:15:33.174]         base::withCallingHandlers({
  [21:15:33.174]             ...future.value <- base::withVisible(base::local({
  [21:15:33.174]                 sample(x, size = 1L)
  [21:15:33.174]             }))
  [21:15:33.174]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.174]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.174]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.174]                 version = "1.8")
  [21:15:33.174]         }, condition = base::local({
  [21:15:33.174]             c <- base::c
  [21:15:33.174]             inherits <- base::inherits
  [21:15:33.174]             invokeRestart <- base::invokeRestart
  [21:15:33.174]             length <- base::length
  [21:15:33.174]             list <- base::list
  [21:15:33.174]             seq.int <- base::seq.int
  [21:15:33.174]             signalCondition <- base::signalCondition
  [21:15:33.174]             sys.calls <- base::sys.calls
  [21:15:33.174]             Sys.time <- base::Sys.time
  [21:15:33.174]             `[[` <- base::`[[`
  [21:15:33.174]             `+` <- base::`+`
  [21:15:33.174]             `<<-` <- base::`<<-`
  [21:15:33.174]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.174]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.174]                   3L)]
  [21:15:33.174]             }
  [21:15:33.174]             function(cond) {
  [21:15:33.174]                 if (inherits(cond, "error")) {
  [21:15:33.174]                   sessionInformation <- function() {
  [21:15:33.174]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.174]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.174]                       search = base::search(), system = base::Sys.info())
  [21:15:33.174]                   }
  [21:15:33.174]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.174]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.174]                     cond$call), session = sessionInformation(), 
  [21:15:33.174]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.174]                   signalCondition(cond)
  [21:15:33.174]                 }
  [21:15:33.174]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.174]                 ))) {
  [21:15:33.174]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.174]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.174]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.174]                   if (!signal) {
  [21:15:33.174]                     muffleCondition <- function (cond) 
  [21:15:33.174]                     {
  [21:15:33.174]                       inherits <- base::inherits
  [21:15:33.174]                       invokeRestart <- base::invokeRestart
  [21:15:33.174]                       muffled <- FALSE
  [21:15:33.174]                       if (inherits(cond, "message")) {
  [21:15:33.174]                         invokeRestart("muffleMessage")
  [21:15:33.174]                         muffled <- TRUE
  [21:15:33.174]                       }
  [21:15:33.174]                       else if (inherits(cond, "warning")) {
  [21:15:33.174]                         invokeRestart("muffleWarning")
  [21:15:33.174]                         muffled <- TRUE
  [21:15:33.174]                       }
  [21:15:33.174]                       else if (inherits(cond, "condition")) {
  [21:15:33.174]                         computeRestarts <- base::computeRestarts
  [21:15:33.174]                         grepl <- base::grepl
  [21:15:33.174]                         is.null <- base::is.null
  [21:15:33.174]                         restarts <- computeRestarts(cond)
  [21:15:33.174]                         for (restart in restarts) {
  [21:15:33.174]                           name <- restart$name
  [21:15:33.174]                           if (is.null(name)) 
  [21:15:33.174]                             next
  [21:15:33.174]                           if (!grepl("^muffle", name)) 
  [21:15:33.174]                             next
  [21:15:33.174]                           invokeRestart(restart)
  [21:15:33.174]                           muffled <- TRUE
  [21:15:33.174]                           break
  [21:15:33.174]                         }
  [21:15:33.174]                       }
  [21:15:33.174]                       invisible(muffled)
  [21:15:33.174]                     }
  [21:15:33.174]                     muffleCondition(cond)
  [21:15:33.174]                   }
  [21:15:33.174]                 }
  [21:15:33.174]             }
  [21:15:33.174]         }))
  [21:15:33.174]     }, error = function(ex) {
  [21:15:33.174]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.174]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.174]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.174]     }, finally = {
  [21:15:33.174]         {
  [21:15:33.174]             NULL
  [21:15:33.174]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.174]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.174]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.174]                 label = NULL, ...) 
  [21:15:33.174]             {
  [21:15:33.174]                 if (substitute) 
  [21:15:33.174]                   expr <- substitute(expr)
  [21:15:33.174]                 local <- as.logical(local)
  [21:15:33.174]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.174]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.174]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.174]                   label = label, ...)
  [21:15:33.174]                 if (!future$lazy) 
  [21:15:33.174]                   future <- run(future)
  [21:15:33.174]                 invisible(future)
  [21:15:33.174]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.174]         }
  [21:15:33.174]         base::options(...future.oldOptions)
  [21:15:33.174]     })
  [21:15:33.174]     Sys.time
  [21:15:33.174]     if (base::is.na(TRUE)) {
  [21:15:33.174]     }
  [21:15:33.174]     else {
  [21:15:33.174]         base::sink(type = "output", split = FALSE)
  [21:15:33.174]         if (TRUE) {
  [21:15:33.174]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.174]         }
  [21:15:33.174]         else {
  [21:15:33.174]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.174]         }
  [21:15:33.174]         base::close(...future.stdout)
  [21:15:33.174]         ...future.stdout <- NULL
  [21:15:33.174]     }
  [21:15:33.174]     ...future.result$conditions <- ...future.conditions
  [21:15:33.174]     ...future.result
  [21:15:33.174] }
  [21:15:33.179] plan(): Setting new future strategy stack:
  [21:15:33.179] List of future strategies:
  [21:15:33.179] 1. sequential:
  [21:15:33.179]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.179]    - tweaked: FALSE
  [21:15:33.179]    - call: NULL
  [21:15:33.180] plan(): nbrOfWorkers() = 1
  [21:15:33.181] plan(): Setting new future strategy stack:
  [21:15:33.181] List of future strategies:
  [21:15:33.181] 1. sequential:
  [21:15:33.181]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.181]    - tweaked: FALSE
  [21:15:33.181]    - call: plan(strategy)
  [21:15:33.182] plan(): nbrOfWorkers() = 1
  [21:15:33.183] SequentialFuture started (and completed)
  [21:15:33.183] getGlobalsAndPackages() ...
  [21:15:33.183] Searching for globals...
  [21:15:33.185] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.186] Searching for globals ... DONE
  [21:15:33.186] Resolving globals: FALSE
  [21:15:33.187] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.187] - globals: [1] 'x'
  [21:15:33.187] 
  [21:15:33.188] getGlobalsAndPackages() ... DONE
  [21:15:33.189] Packages needed by the future expression (n = 0): <none>
  [21:15:33.190] Packages needed by future strategies (n = 0): <none>
  [21:15:33.194] {
  [21:15:33.194]     {
  [21:15:33.194]         ...future.startTime <- base::Sys.time()
  [21:15:33.194]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.194]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.194]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.194]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.194]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.194]         {
  [21:15:33.194]             {
  [21:15:33.194]                 {
  [21:15:33.194]                   base::local({
  [21:15:33.194]                     has_future <- base::requireNamespace("future", 
  [21:15:33.194]                       quietly = TRUE)
  [21:15:33.194]                     version <- if (has_future) 
  [21:15:33.194]                       utils::packageVersion("future")
  [21:15:33.194]                     else NULL
  [21:15:33.194]                     if (!has_future || version < "1.8.0") {
  [21:15:33.194]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.194]                         "", base::R.version$version.string), 
  [21:15:33.194]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.194]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.194]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.194]                           "release", "version")], collapse = " "), 
  [21:15:33.194]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.194]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.194]                         info)
  [21:15:33.194]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.194]                       if (!has_future) {
  [21:15:33.194]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.194]                           info)
  [21:15:33.194]                       }
  [21:15:33.194]                       else {
  [21:15:33.194]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.194]                           info, version)
  [21:15:33.194]                       }
  [21:15:33.194]                       base::stop(msg)
  [21:15:33.194]                     }
  [21:15:33.194]                   })
  [21:15:33.194]                 }
  [21:15:33.194]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:33.194]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:33.194]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.194]             }
  [21:15:33.194]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.194]         }
  [21:15:33.194]     }
  [21:15:33.194]     if (base::is.na(TRUE)) {
  [21:15:33.194]     }
  [21:15:33.194]     else {
  [21:15:33.194]         if (TRUE) {
  [21:15:33.194]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.194]                 open = "w")
  [21:15:33.194]         }
  [21:15:33.194]         else {
  [21:15:33.194]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.194]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.194]         }
  [21:15:33.194]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.194]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.194]             base::sink(type = "output", split = FALSE)
  [21:15:33.194]             base::close(...future.stdout)
  [21:15:33.194]         }, add = TRUE)
  [21:15:33.194]     }
  [21:15:33.194]     ...future.frame <- base::sys.nframe()
  [21:15:33.194]     ...future.conditions <- base::list()
  [21:15:33.194]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.194]     ...future.result <- base::tryCatch({
  [21:15:33.194]         base::withCallingHandlers({
  [21:15:33.194]             ...future.value <- base::withVisible(base::local({
  [21:15:33.194]                 sample(x, size = 1L)
  [21:15:33.194]             }))
  [21:15:33.194]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.194]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.194]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.194]                 version = "1.8")
  [21:15:33.194]         }, condition = base::local({
  [21:15:33.194]             c <- base::c
  [21:15:33.194]             inherits <- base::inherits
  [21:15:33.194]             invokeRestart <- base::invokeRestart
  [21:15:33.194]             length <- base::length
  [21:15:33.194]             list <- base::list
  [21:15:33.194]             seq.int <- base::seq.int
  [21:15:33.194]             signalCondition <- base::signalCondition
  [21:15:33.194]             sys.calls <- base::sys.calls
  [21:15:33.194]             Sys.time <- base::Sys.time
  [21:15:33.194]             `[[` <- base::`[[`
  [21:15:33.194]             `+` <- base::`+`
  [21:15:33.194]             `<<-` <- base::`<<-`
  [21:15:33.194]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.194]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.194]                   3L)]
  [21:15:33.194]             }
  [21:15:33.194]             function(cond) {
  [21:15:33.194]                 if (inherits(cond, "error")) {
  [21:15:33.194]                   sessionInformation <- function() {
  [21:15:33.194]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.194]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.194]                       search = base::search(), system = base::Sys.info())
  [21:15:33.194]                   }
  [21:15:33.194]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.194]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.194]                     cond$call), session = sessionInformation(), 
  [21:15:33.194]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.194]                   signalCondition(cond)
  [21:15:33.194]                 }
  [21:15:33.194]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.194]                 ))) {
  [21:15:33.194]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.194]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.194]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.194]                   if (!signal) {
  [21:15:33.194]                     muffleCondition <- function (cond) 
  [21:15:33.194]                     {
  [21:15:33.194]                       inherits <- base::inherits
  [21:15:33.194]                       invokeRestart <- base::invokeRestart
  [21:15:33.194]                       muffled <- FALSE
  [21:15:33.194]                       if (inherits(cond, "message")) {
  [21:15:33.194]                         invokeRestart("muffleMessage")
  [21:15:33.194]                         muffled <- TRUE
  [21:15:33.194]                       }
  [21:15:33.194]                       else if (inherits(cond, "warning")) {
  [21:15:33.194]                         invokeRestart("muffleWarning")
  [21:15:33.194]                         muffled <- TRUE
  [21:15:33.194]                       }
  [21:15:33.194]                       else if (inherits(cond, "condition")) {
  [21:15:33.194]                         computeRestarts <- base::computeRestarts
  [21:15:33.194]                         grepl <- base::grepl
  [21:15:33.194]                         is.null <- base::is.null
  [21:15:33.194]                         restarts <- computeRestarts(cond)
  [21:15:33.194]                         for (restart in restarts) {
  [21:15:33.194]                           name <- restart$name
  [21:15:33.194]                           if (is.null(name)) 
  [21:15:33.194]                             next
  [21:15:33.194]                           if (!grepl("^muffle", name)) 
  [21:15:33.194]                             next
  [21:15:33.194]                           invokeRestart(restart)
  [21:15:33.194]                           muffled <- TRUE
  [21:15:33.194]                           break
  [21:15:33.194]                         }
  [21:15:33.194]                       }
  [21:15:33.194]                       invisible(muffled)
  [21:15:33.194]                     }
  [21:15:33.194]                     muffleCondition(cond)
  [21:15:33.194]                   }
  [21:15:33.194]                 }
  [21:15:33.194]             }
  [21:15:33.194]         }))
  [21:15:33.194]     }, error = function(ex) {
  [21:15:33.194]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.194]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.194]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.194]     }, finally = {
  [21:15:33.194]         {
  [21:15:33.194]             NULL
  [21:15:33.194]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.194]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.194]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.194]                 label = NULL, ...) 
  [21:15:33.194]             {
  [21:15:33.194]                 if (substitute) 
  [21:15:33.194]                   expr <- substitute(expr)
  [21:15:33.194]                 local <- as.logical(local)
  [21:15:33.194]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.194]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.194]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.194]                   label = label, ...)
  [21:15:33.194]                 if (!future$lazy) 
  [21:15:33.194]                   future <- run(future)
  [21:15:33.194]                 invisible(future)
  [21:15:33.194]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.194]         }
  [21:15:33.194]         base::options(...future.oldOptions)
  [21:15:33.194]     })
  [21:15:33.194]     Sys.time
  [21:15:33.194]     if (base::is.na(TRUE)) {
  [21:15:33.194]     }
  [21:15:33.194]     else {
  [21:15:33.194]         base::sink(type = "output", split = FALSE)
  [21:15:33.194]         if (TRUE) {
  [21:15:33.194]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.194]         }
  [21:15:33.194]         else {
  [21:15:33.194]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.194]         }
  [21:15:33.194]         base::close(...future.stdout)
  [21:15:33.194]         ...future.stdout <- NULL
  [21:15:33.194]     }
  [21:15:33.194]     ...future.result$conditions <- ...future.conditions
  [21:15:33.194]     ...future.result
  [21:15:33.194] }
  [21:15:33.198] plan(): Setting new future strategy stack:
  [21:15:33.199] List of future strategies:
  [21:15:33.199] 1. sequential:
  [21:15:33.199]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.199]    - tweaked: FALSE
  [21:15:33.199]    - call: NULL
  [21:15:33.200] plan(): nbrOfWorkers() = 1
  [21:15:33.204] plan(): Setting new future strategy stack:
  [21:15:33.204] List of future strategies:
  [21:15:33.204] 1. sequential:
  [21:15:33.204]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.204]    - tweaked: FALSE
  [21:15:33.204]    - call: plan(strategy)
  [21:15:33.205] plan(): nbrOfWorkers() = 1
  [21:15:33.205] SequentialFuture started (and completed)
  [21:15:33.206] getGlobalsAndPackages() ...
  [21:15:33.206] Searching for globals...
  [21:15:33.208] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.208] Searching for globals ... DONE
  [21:15:33.208] Resolving globals: FALSE
  [21:15:33.209] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.210] - globals: [1] 'x'
  [21:15:33.210] 
  [21:15:33.210] getGlobalsAndPackages() ... DONE
  [21:15:33.212] Packages needed by the future expression (n = 0): <none>
  [21:15:33.212] Packages needed by future strategies (n = 0): <none>
  [21:15:33.216] {
  [21:15:33.216]     {
  [21:15:33.216]         ...future.startTime <- base::Sys.time()
  [21:15:33.216]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.216]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.216]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.216]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.216]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.216]         {
  [21:15:33.216]             {
  [21:15:33.216]                 {
  [21:15:33.216]                   base::local({
  [21:15:33.216]                     has_future <- base::requireNamespace("future", 
  [21:15:33.216]                       quietly = TRUE)
  [21:15:33.216]                     version <- if (has_future) 
  [21:15:33.216]                       utils::packageVersion("future")
  [21:15:33.216]                     else NULL
  [21:15:33.216]                     if (!has_future || version < "1.8.0") {
  [21:15:33.216]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.216]                         "", base::R.version$version.string), 
  [21:15:33.216]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.216]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.216]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.216]                           "release", "version")], collapse = " "), 
  [21:15:33.216]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.216]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.216]                         info)
  [21:15:33.216]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.216]                       if (!has_future) {
  [21:15:33.216]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.216]                           info)
  [21:15:33.216]                       }
  [21:15:33.216]                       else {
  [21:15:33.216]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.216]                           info, version)
  [21:15:33.216]                       }
  [21:15:33.216]                       base::stop(msg)
  [21:15:33.216]                     }
  [21:15:33.216]                   })
  [21:15:33.216]                 }
  [21:15:33.216]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:33.216]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:33.216]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.216]             }
  [21:15:33.216]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.216]         }
  [21:15:33.216]     }
  [21:15:33.216]     if (base::is.na(TRUE)) {
  [21:15:33.216]     }
  [21:15:33.216]     else {
  [21:15:33.216]         if (TRUE) {
  [21:15:33.216]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.216]                 open = "w")
  [21:15:33.216]         }
  [21:15:33.216]         else {
  [21:15:33.216]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.216]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.216]         }
  [21:15:33.216]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.216]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.216]             base::sink(type = "output", split = FALSE)
  [21:15:33.216]             base::close(...future.stdout)
  [21:15:33.216]         }, add = TRUE)
  [21:15:33.216]     }
  [21:15:33.216]     ...future.frame <- base::sys.nframe()
  [21:15:33.216]     ...future.conditions <- base::list()
  [21:15:33.216]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.216]     ...future.result <- base::tryCatch({
  [21:15:33.216]         base::withCallingHandlers({
  [21:15:33.216]             ...future.value <- base::withVisible(base::local({
  [21:15:33.216]                 sample(x, size = 1L)
  [21:15:33.216]             }))
  [21:15:33.216]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.216]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.216]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.216]                 version = "1.8")
  [21:15:33.216]         }, condition = base::local({
  [21:15:33.216]             c <- base::c
  [21:15:33.216]             inherits <- base::inherits
  [21:15:33.216]             invokeRestart <- base::invokeRestart
  [21:15:33.216]             length <- base::length
  [21:15:33.216]             list <- base::list
  [21:15:33.216]             seq.int <- base::seq.int
  [21:15:33.216]             signalCondition <- base::signalCondition
  [21:15:33.216]             sys.calls <- base::sys.calls
  [21:15:33.216]             Sys.time <- base::Sys.time
  [21:15:33.216]             `[[` <- base::`[[`
  [21:15:33.216]             `+` <- base::`+`
  [21:15:33.216]             `<<-` <- base::`<<-`
  [21:15:33.216]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.216]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.216]                   3L)]
  [21:15:33.216]             }
  [21:15:33.216]             function(cond) {
  [21:15:33.216]                 if (inherits(cond, "error")) {
  [21:15:33.216]                   sessionInformation <- function() {
  [21:15:33.216]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.216]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.216]                       search = base::search(), system = base::Sys.info())
  [21:15:33.216]                   }
  [21:15:33.216]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.216]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.216]                     cond$call), session = sessionInformation(), 
  [21:15:33.216]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.216]                   signalCondition(cond)
  [21:15:33.216]                 }
  [21:15:33.216]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.216]                 ))) {
  [21:15:33.216]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.216]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.216]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.216]                   if (!signal) {
  [21:15:33.216]                     muffleCondition <- function (cond) 
  [21:15:33.216]                     {
  [21:15:33.216]                       inherits <- base::inherits
  [21:15:33.216]                       invokeRestart <- base::invokeRestart
  [21:15:33.216]                       muffled <- FALSE
  [21:15:33.216]                       if (inherits(cond, "message")) {
  [21:15:33.216]                         invokeRestart("muffleMessage")
  [21:15:33.216]                         muffled <- TRUE
  [21:15:33.216]                       }
  [21:15:33.216]                       else if (inherits(cond, "warning")) {
  [21:15:33.216]                         invokeRestart("muffleWarning")
  [21:15:33.216]                         muffled <- TRUE
  [21:15:33.216]                       }
  [21:15:33.216]                       else if (inherits(cond, "condition")) {
  [21:15:33.216]                         computeRestarts <- base::computeRestarts
  [21:15:33.216]                         grepl <- base::grepl
  [21:15:33.216]                         is.null <- base::is.null
  [21:15:33.216]                         restarts <- computeRestarts(cond)
  [21:15:33.216]                         for (restart in restarts) {
  [21:15:33.216]                           name <- restart$name
  [21:15:33.216]                           if (is.null(name)) 
  [21:15:33.216]                             next
  [21:15:33.216]                           if (!grepl("^muffle", name)) 
  [21:15:33.216]                             next
  [21:15:33.216]                           invokeRestart(restart)
  [21:15:33.216]                           muffled <- TRUE
  [21:15:33.216]                           break
  [21:15:33.216]                         }
  [21:15:33.216]                       }
  [21:15:33.216]                       invisible(muffled)
  [21:15:33.216]                     }
  [21:15:33.216]                     muffleCondition(cond)
  [21:15:33.216]                   }
  [21:15:33.216]                 }
  [21:15:33.216]             }
  [21:15:33.216]         }))
  [21:15:33.216]     }, error = function(ex) {
  [21:15:33.216]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.216]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.216]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.216]     }, finally = {
  [21:15:33.216]         {
  [21:15:33.216]             NULL
  [21:15:33.216]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.216]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.216]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.216]                 label = NULL, ...) 
  [21:15:33.216]             {
  [21:15:33.216]                 if (substitute) 
  [21:15:33.216]                   expr <- substitute(expr)
  [21:15:33.216]                 local <- as.logical(local)
  [21:15:33.216]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.216]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.216]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.216]                   label = label, ...)
  [21:15:33.216]                 if (!future$lazy) 
  [21:15:33.216]                   future <- run(future)
  [21:15:33.216]                 invisible(future)
  [21:15:33.216]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.216]         }
  [21:15:33.216]         base::options(...future.oldOptions)
  [21:15:33.216]     })
  [21:15:33.216]     Sys.time
  [21:15:33.216]     if (base::is.na(TRUE)) {
  [21:15:33.216]     }
  [21:15:33.216]     else {
  [21:15:33.216]         base::sink(type = "output", split = FALSE)
  [21:15:33.216]         if (TRUE) {
  [21:15:33.216]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.216]         }
  [21:15:33.216]         else {
  [21:15:33.216]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.216]         }
  [21:15:33.216]         base::close(...future.stdout)
  [21:15:33.216]         ...future.stdout <- NULL
  [21:15:33.216]     }
  [21:15:33.216]     ...future.result$conditions <- ...future.conditions
  [21:15:33.216]     ...future.result
  [21:15:33.216] }
  [21:15:33.221] plan(): Setting new future strategy stack:
  [21:15:33.221] List of future strategies:
  [21:15:33.221] 1. sequential:
  [21:15:33.221]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.221]    - tweaked: FALSE
  [21:15:33.221]    - call: NULL
  [21:15:33.222] plan(): nbrOfWorkers() = 1
  [21:15:33.223] plan(): Setting new future strategy stack:
  [21:15:33.223] List of future strategies:
  [21:15:33.223] 1. sequential:
  [21:15:33.223]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.223]    - tweaked: FALSE
  [21:15:33.223]    - call: plan(strategy)
  [21:15:33.224] plan(): nbrOfWorkers() = 1
  [21:15:33.225] SequentialFuture started (and completed)
  [21:15:33.225] resolve() on list ...
  [21:15:33.225]  recursive: 0
  [21:15:33.226]  length: 4
  [21:15:33.226] 
  [21:15:33.226] Future #1
  [21:15:33.227] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.227] - nx: 4
  [21:15:33.227] - relay: TRUE
  [21:15:33.227] - stdout: TRUE
  [21:15:33.228] - signal: TRUE
  [21:15:33.228] - resignal: FALSE
  [21:15:33.228] - force: TRUE
  [21:15:33.228] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.229] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.229]  - until=1
  [21:15:33.229]  - relaying element #1
  [21:15:33.230] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.230] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.230] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.230]  length: 3 (resolved future 1)
  [21:15:33.231] Future #2
  [21:15:33.231] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.231] - nx: 4
  [21:15:33.232] - relay: TRUE
  [21:15:33.232] - stdout: TRUE
  [21:15:33.232] - signal: TRUE
  [21:15:33.232] - resignal: FALSE
  [21:15:33.233] - force: TRUE
  [21:15:33.233] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.233] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.233]  - until=2
  [21:15:33.234]  - relaying element #2
  [21:15:33.234] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.234] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.235] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.235]  length: 2 (resolved future 2)
  [21:15:33.235] Future #3
  [21:15:33.236] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.236] - nx: 4
  [21:15:33.236] - relay: TRUE
  [21:15:33.236] - stdout: TRUE
  [21:15:33.237] - signal: TRUE
  [21:15:33.237] - resignal: FALSE
  [21:15:33.237] - force: TRUE
  [21:15:33.237] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.237] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.238]  - until=3
  [21:15:33.238]  - relaying element #3
  [21:15:33.239] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.239] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.239] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.239]  length: 1 (resolved future 3)
  [21:15:33.240] Future #4
  [21:15:33.240] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.240] - nx: 4
  [21:15:33.241] - relay: TRUE
  [21:15:33.241] - stdout: TRUE
  [21:15:33.241] - signal: TRUE
  [21:15:33.241] - resignal: FALSE
  [21:15:33.241] - force: TRUE
  [21:15:33.242] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.242] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.242]  - until=4
  [21:15:33.243]  - relaying element #4
  [21:15:33.243] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.243] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.244] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.244]  length: 0 (resolved future 4)
  [21:15:33.244] Relaying remaining futures
  [21:15:33.244] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.245] - nx: 4
  [21:15:33.245] - relay: TRUE
  [21:15:33.245] - stdout: TRUE
  [21:15:33.245] - signal: TRUE
  [21:15:33.245] - resignal: FALSE
  [21:15:33.246] - force: TRUE
  [21:15:33.246] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.246] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.247] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.247] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.247] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.247] resolve() on list ... DONE
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 1
  
  [21:15:33.248] getGlobalsAndPackages() ...
  [21:15:33.249] Searching for globals...
  [21:15:33.251] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.251] Searching for globals ... DONE
  [21:15:33.251] Resolving globals: FALSE
  [21:15:33.252] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.252] - globals: [1] 'x'
  [21:15:33.253] 
  [21:15:33.253] getGlobalsAndPackages() ... DONE
  [21:15:33.255] Packages needed by the future expression (n = 0): <none>
  [21:15:33.255] Packages needed by future strategies (n = 0): <none>
  [21:15:33.259] {
  [21:15:33.259]     {
  [21:15:33.259]         ...future.startTime <- base::Sys.time()
  [21:15:33.259]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.259]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.259]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.259]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.259]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.259]         {
  [21:15:33.259]             {
  [21:15:33.259]                 {
  [21:15:33.259]                   base::local({
  [21:15:33.259]                     has_future <- base::requireNamespace("future", 
  [21:15:33.259]                       quietly = TRUE)
  [21:15:33.259]                     version <- if (has_future) 
  [21:15:33.259]                       utils::packageVersion("future")
  [21:15:33.259]                     else NULL
  [21:15:33.259]                     if (!has_future || version < "1.8.0") {
  [21:15:33.259]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.259]                         "", base::R.version$version.string), 
  [21:15:33.259]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.259]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.259]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.259]                           "release", "version")], collapse = " "), 
  [21:15:33.259]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.259]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.259]                         info)
  [21:15:33.259]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.259]                       if (!has_future) {
  [21:15:33.259]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.259]                           info)
  [21:15:33.259]                       }
  [21:15:33.259]                       else {
  [21:15:33.259]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.259]                           info, version)
  [21:15:33.259]                       }
  [21:15:33.259]                       base::stop(msg)
  [21:15:33.259]                     }
  [21:15:33.259]                   })
  [21:15:33.259]                 }
  [21:15:33.259]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:33.259]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:33.259]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.259]             }
  [21:15:33.259]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.259]         }
  [21:15:33.259]     }
  [21:15:33.259]     if (base::is.na(TRUE)) {
  [21:15:33.259]     }
  [21:15:33.259]     else {
  [21:15:33.259]         if (TRUE) {
  [21:15:33.259]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.259]                 open = "w")
  [21:15:33.259]         }
  [21:15:33.259]         else {
  [21:15:33.259]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.259]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.259]         }
  [21:15:33.259]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.259]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.259]             base::sink(type = "output", split = FALSE)
  [21:15:33.259]             base::close(...future.stdout)
  [21:15:33.259]         }, add = TRUE)
  [21:15:33.259]     }
  [21:15:33.259]     ...future.frame <- base::sys.nframe()
  [21:15:33.259]     ...future.conditions <- base::list()
  [21:15:33.259]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.259]     ...future.result <- base::tryCatch({
  [21:15:33.259]         base::withCallingHandlers({
  [21:15:33.259]             ...future.value <- base::withVisible(base::local({
  [21:15:33.259]                 sample(x, size = 1L)
  [21:15:33.259]             }))
  [21:15:33.259]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.259]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.259]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.259]                 version = "1.8")
  [21:15:33.259]         }, condition = base::local({
  [21:15:33.259]             c <- base::c
  [21:15:33.259]             inherits <- base::inherits
  [21:15:33.259]             invokeRestart <- base::invokeRestart
  [21:15:33.259]             length <- base::length
  [21:15:33.259]             list <- base::list
  [21:15:33.259]             seq.int <- base::seq.int
  [21:15:33.259]             signalCondition <- base::signalCondition
  [21:15:33.259]             sys.calls <- base::sys.calls
  [21:15:33.259]             Sys.time <- base::Sys.time
  [21:15:33.259]             `[[` <- base::`[[`
  [21:15:33.259]             `+` <- base::`+`
  [21:15:33.259]             `<<-` <- base::`<<-`
  [21:15:33.259]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.259]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.259]                   3L)]
  [21:15:33.259]             }
  [21:15:33.259]             function(cond) {
  [21:15:33.259]                 if (inherits(cond, "error")) {
  [21:15:33.259]                   sessionInformation <- function() {
  [21:15:33.259]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.259]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.259]                       search = base::search(), system = base::Sys.info())
  [21:15:33.259]                   }
  [21:15:33.259]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.259]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.259]                     cond$call), session = sessionInformation(), 
  [21:15:33.259]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.259]                   signalCondition(cond)
  [21:15:33.259]                 }
  [21:15:33.259]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.259]                 ))) {
  [21:15:33.259]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.259]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.259]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.259]                   if (!signal) {
  [21:15:33.259]                     muffleCondition <- function (cond) 
  [21:15:33.259]                     {
  [21:15:33.259]                       inherits <- base::inherits
  [21:15:33.259]                       invokeRestart <- base::invokeRestart
  [21:15:33.259]                       muffled <- FALSE
  [21:15:33.259]                       if (inherits(cond, "message")) {
  [21:15:33.259]                         invokeRestart("muffleMessage")
  [21:15:33.259]                         muffled <- TRUE
  [21:15:33.259]                       }
  [21:15:33.259]                       else if (inherits(cond, "warning")) {
  [21:15:33.259]                         invokeRestart("muffleWarning")
  [21:15:33.259]                         muffled <- TRUE
  [21:15:33.259]                       }
  [21:15:33.259]                       else if (inherits(cond, "condition")) {
  [21:15:33.259]                         computeRestarts <- base::computeRestarts
  [21:15:33.259]                         grepl <- base::grepl
  [21:15:33.259]                         is.null <- base::is.null
  [21:15:33.259]                         restarts <- computeRestarts(cond)
  [21:15:33.259]                         for (restart in restarts) {
  [21:15:33.259]                           name <- restart$name
  [21:15:33.259]                           if (is.null(name)) 
  [21:15:33.259]                             next
  [21:15:33.259]                           if (!grepl("^muffle", name)) 
  [21:15:33.259]                             next
  [21:15:33.259]                           invokeRestart(restart)
  [21:15:33.259]                           muffled <- TRUE
  [21:15:33.259]                           break
  [21:15:33.259]                         }
  [21:15:33.259]                       }
  [21:15:33.259]                       invisible(muffled)
  [21:15:33.259]                     }
  [21:15:33.259]                     muffleCondition(cond)
  [21:15:33.259]                   }
  [21:15:33.259]                 }
  [21:15:33.259]             }
  [21:15:33.259]         }))
  [21:15:33.259]     }, error = function(ex) {
  [21:15:33.259]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.259]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.259]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.259]     }, finally = {
  [21:15:33.259]         {
  [21:15:33.259]             NULL
  [21:15:33.259]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.259]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.259]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.259]                 label = NULL, ...) 
  [21:15:33.259]             {
  [21:15:33.259]                 if (substitute) 
  [21:15:33.259]                   expr <- substitute(expr)
  [21:15:33.259]                 local <- as.logical(local)
  [21:15:33.259]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.259]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.259]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.259]                   label = label, ...)
  [21:15:33.259]                 if (!future$lazy) 
  [21:15:33.259]                   future <- run(future)
  [21:15:33.259]                 invisible(future)
  [21:15:33.259]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.259]         }
  [21:15:33.259]         base::options(...future.oldOptions)
  [21:15:33.259]     })
  [21:15:33.259]     Sys.time
  [21:15:33.259]     if (base::is.na(TRUE)) {
  [21:15:33.259]     }
  [21:15:33.259]     else {
  [21:15:33.259]         base::sink(type = "output", split = FALSE)
  [21:15:33.259]         if (TRUE) {
  [21:15:33.259]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.259]         }
  [21:15:33.259]         else {
  [21:15:33.259]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.259]         }
  [21:15:33.259]         base::close(...future.stdout)
  [21:15:33.259]         ...future.stdout <- NULL
  [21:15:33.259]     }
  [21:15:33.259]     ...future.result$conditions <- ...future.conditions
  [21:15:33.259]     ...future.result
  [21:15:33.259] }
  [21:15:33.264] plan(): Setting new future strategy stack:
  [21:15:33.264] List of future strategies:
  [21:15:33.264] 1. sequential:
  [21:15:33.264]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.264]    - tweaked: FALSE
  [21:15:33.264]    - call: NULL
  [21:15:33.265] plan(): nbrOfWorkers() = 1
  [21:15:33.266] plan(): Setting new future strategy stack:
  [21:15:33.266] List of future strategies:
  [21:15:33.266] 1. sequential:
  [21:15:33.266]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.266]    - tweaked: FALSE
  [21:15:33.266]    - call: plan(strategy)
  [21:15:33.267] plan(): nbrOfWorkers() = 1
  [21:15:33.267] SequentialFuture started (and completed)
  [21:15:33.268] getGlobalsAndPackages() ...
  [21:15:33.268] Searching for globals...
  [21:15:33.270] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.270] Searching for globals ... DONE
  [21:15:33.271] Resolving globals: FALSE
  [21:15:33.271] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.272] - globals: [1] 'x'
  [21:15:33.272] 
  [21:15:33.272] getGlobalsAndPackages() ... DONE
  [21:15:33.277] Packages needed by the future expression (n = 0): <none>
  [21:15:33.277] Packages needed by future strategies (n = 0): <none>
  [21:15:33.281] {
  [21:15:33.281]     {
  [21:15:33.281]         ...future.startTime <- base::Sys.time()
  [21:15:33.281]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.281]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.281]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.281]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.281]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.281]         {
  [21:15:33.281]             {
  [21:15:33.281]                 {
  [21:15:33.281]                   base::local({
  [21:15:33.281]                     has_future <- base::requireNamespace("future", 
  [21:15:33.281]                       quietly = TRUE)
  [21:15:33.281]                     version <- if (has_future) 
  [21:15:33.281]                       utils::packageVersion("future")
  [21:15:33.281]                     else NULL
  [21:15:33.281]                     if (!has_future || version < "1.8.0") {
  [21:15:33.281]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.281]                         "", base::R.version$version.string), 
  [21:15:33.281]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.281]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.281]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.281]                           "release", "version")], collapse = " "), 
  [21:15:33.281]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.281]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.281]                         info)
  [21:15:33.281]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.281]                       if (!has_future) {
  [21:15:33.281]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.281]                           info)
  [21:15:33.281]                       }
  [21:15:33.281]                       else {
  [21:15:33.281]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.281]                           info, version)
  [21:15:33.281]                       }
  [21:15:33.281]                       base::stop(msg)
  [21:15:33.281]                     }
  [21:15:33.281]                   })
  [21:15:33.281]                 }
  [21:15:33.281]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:33.281]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:33.281]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.281]             }
  [21:15:33.281]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.281]         }
  [21:15:33.281]     }
  [21:15:33.281]     if (base::is.na(TRUE)) {
  [21:15:33.281]     }
  [21:15:33.281]     else {
  [21:15:33.281]         if (TRUE) {
  [21:15:33.281]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.281]                 open = "w")
  [21:15:33.281]         }
  [21:15:33.281]         else {
  [21:15:33.281]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.281]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.281]         }
  [21:15:33.281]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.281]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.281]             base::sink(type = "output", split = FALSE)
  [21:15:33.281]             base::close(...future.stdout)
  [21:15:33.281]         }, add = TRUE)
  [21:15:33.281]     }
  [21:15:33.281]     ...future.frame <- base::sys.nframe()
  [21:15:33.281]     ...future.conditions <- base::list()
  [21:15:33.281]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.281]     ...future.result <- base::tryCatch({
  [21:15:33.281]         base::withCallingHandlers({
  [21:15:33.281]             ...future.value <- base::withVisible(base::local({
  [21:15:33.281]                 sample(x, size = 1L)
  [21:15:33.281]             }))
  [21:15:33.281]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.281]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.281]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.281]                 version = "1.8")
  [21:15:33.281]         }, condition = base::local({
  [21:15:33.281]             c <- base::c
  [21:15:33.281]             inherits <- base::inherits
  [21:15:33.281]             invokeRestart <- base::invokeRestart
  [21:15:33.281]             length <- base::length
  [21:15:33.281]             list <- base::list
  [21:15:33.281]             seq.int <- base::seq.int
  [21:15:33.281]             signalCondition <- base::signalCondition
  [21:15:33.281]             sys.calls <- base::sys.calls
  [21:15:33.281]             Sys.time <- base::Sys.time
  [21:15:33.281]             `[[` <- base::`[[`
  [21:15:33.281]             `+` <- base::`+`
  [21:15:33.281]             `<<-` <- base::`<<-`
  [21:15:33.281]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.281]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.281]                   3L)]
  [21:15:33.281]             }
  [21:15:33.281]             function(cond) {
  [21:15:33.281]                 if (inherits(cond, "error")) {
  [21:15:33.281]                   sessionInformation <- function() {
  [21:15:33.281]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.281]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.281]                       search = base::search(), system = base::Sys.info())
  [21:15:33.281]                   }
  [21:15:33.281]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.281]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.281]                     cond$call), session = sessionInformation(), 
  [21:15:33.281]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.281]                   signalCondition(cond)
  [21:15:33.281]                 }
  [21:15:33.281]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.281]                 ))) {
  [21:15:33.281]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.281]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.281]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.281]                   if (!signal) {
  [21:15:33.281]                     muffleCondition <- function (cond) 
  [21:15:33.281]                     {
  [21:15:33.281]                       inherits <- base::inherits
  [21:15:33.281]                       invokeRestart <- base::invokeRestart
  [21:15:33.281]                       muffled <- FALSE
  [21:15:33.281]                       if (inherits(cond, "message")) {
  [21:15:33.281]                         invokeRestart("muffleMessage")
  [21:15:33.281]                         muffled <- TRUE
  [21:15:33.281]                       }
  [21:15:33.281]                       else if (inherits(cond, "warning")) {
  [21:15:33.281]                         invokeRestart("muffleWarning")
  [21:15:33.281]                         muffled <- TRUE
  [21:15:33.281]                       }
  [21:15:33.281]                       else if (inherits(cond, "condition")) {
  [21:15:33.281]                         computeRestarts <- base::computeRestarts
  [21:15:33.281]                         grepl <- base::grepl
  [21:15:33.281]                         is.null <- base::is.null
  [21:15:33.281]                         restarts <- computeRestarts(cond)
  [21:15:33.281]                         for (restart in restarts) {
  [21:15:33.281]                           name <- restart$name
  [21:15:33.281]                           if (is.null(name)) 
  [21:15:33.281]                             next
  [21:15:33.281]                           if (!grepl("^muffle", name)) 
  [21:15:33.281]                             next
  [21:15:33.281]                           invokeRestart(restart)
  [21:15:33.281]                           muffled <- TRUE
  [21:15:33.281]                           break
  [21:15:33.281]                         }
  [21:15:33.281]                       }
  [21:15:33.281]                       invisible(muffled)
  [21:15:33.281]                     }
  [21:15:33.281]                     muffleCondition(cond)
  [21:15:33.281]                   }
  [21:15:33.281]                 }
  [21:15:33.281]             }
  [21:15:33.281]         }))
  [21:15:33.281]     }, error = function(ex) {
  [21:15:33.281]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.281]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.281]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.281]     }, finally = {
  [21:15:33.281]         {
  [21:15:33.281]             NULL
  [21:15:33.281]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.281]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.281]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.281]                 label = NULL, ...) 
  [21:15:33.281]             {
  [21:15:33.281]                 if (substitute) 
  [21:15:33.281]                   expr <- substitute(expr)
  [21:15:33.281]                 local <- as.logical(local)
  [21:15:33.281]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.281]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.281]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.281]                   label = label, ...)
  [21:15:33.281]                 if (!future$lazy) 
  [21:15:33.281]                   future <- run(future)
  [21:15:33.281]                 invisible(future)
  [21:15:33.281]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.281]         }
  [21:15:33.281]         base::options(...future.oldOptions)
  [21:15:33.281]     })
  [21:15:33.281]     Sys.time
  [21:15:33.281]     if (base::is.na(TRUE)) {
  [21:15:33.281]     }
  [21:15:33.281]     else {
  [21:15:33.281]         base::sink(type = "output", split = FALSE)
  [21:15:33.281]         if (TRUE) {
  [21:15:33.281]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.281]         }
  [21:15:33.281]         else {
  [21:15:33.281]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.281]         }
  [21:15:33.281]         base::close(...future.stdout)
  [21:15:33.281]         ...future.stdout <- NULL
  [21:15:33.281]     }
  [21:15:33.281]     ...future.result$conditions <- ...future.conditions
  [21:15:33.281]     ...future.result
  [21:15:33.281] }
  [21:15:33.302] plan(): Setting new future strategy stack:
  [21:15:33.303] List of future strategies:
  [21:15:33.303] 1. sequential:
  [21:15:33.303]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.303]    - tweaked: FALSE
  [21:15:33.303]    - call: NULL
  [21:15:33.304] plan(): nbrOfWorkers() = 1
  [21:15:33.305] plan(): Setting new future strategy stack:
  [21:15:33.305] List of future strategies:
  [21:15:33.305] 1. sequential:
  [21:15:33.305]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.305]    - tweaked: FALSE
  [21:15:33.305]    - call: plan(strategy)
  [21:15:33.306] plan(): nbrOfWorkers() = 1
  [21:15:33.306] SequentialFuture started (and completed)
  [21:15:33.307] getGlobalsAndPackages() ...
  [21:15:33.307] Searching for globals...
  [21:15:33.309] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.309] Searching for globals ... DONE
  [21:15:33.310] Resolving globals: FALSE
  [21:15:33.310] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.311] - globals: [1] 'x'
  [21:15:33.311] 
  [21:15:33.311] getGlobalsAndPackages() ... DONE
  [21:15:33.313] Packages needed by the future expression (n = 0): <none>
  [21:15:33.313] Packages needed by future strategies (n = 0): <none>
  [21:15:33.317] {
  [21:15:33.317]     {
  [21:15:33.317]         ...future.startTime <- base::Sys.time()
  [21:15:33.317]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.317]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.317]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.317]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.317]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.317]         {
  [21:15:33.317]             {
  [21:15:33.317]                 {
  [21:15:33.317]                   base::local({
  [21:15:33.317]                     has_future <- base::requireNamespace("future", 
  [21:15:33.317]                       quietly = TRUE)
  [21:15:33.317]                     version <- if (has_future) 
  [21:15:33.317]                       utils::packageVersion("future")
  [21:15:33.317]                     else NULL
  [21:15:33.317]                     if (!has_future || version < "1.8.0") {
  [21:15:33.317]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.317]                         "", base::R.version$version.string), 
  [21:15:33.317]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.317]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.317]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.317]                           "release", "version")], collapse = " "), 
  [21:15:33.317]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.317]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.317]                         info)
  [21:15:33.317]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.317]                       if (!has_future) {
  [21:15:33.317]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.317]                           info)
  [21:15:33.317]                       }
  [21:15:33.317]                       else {
  [21:15:33.317]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.317]                           info, version)
  [21:15:33.317]                       }
  [21:15:33.317]                       base::stop(msg)
  [21:15:33.317]                     }
  [21:15:33.317]                   })
  [21:15:33.317]                 }
  [21:15:33.317]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:33.317]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:33.317]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.317]             }
  [21:15:33.317]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.317]         }
  [21:15:33.317]     }
  [21:15:33.317]     if (base::is.na(TRUE)) {
  [21:15:33.317]     }
  [21:15:33.317]     else {
  [21:15:33.317]         if (TRUE) {
  [21:15:33.317]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.317]                 open = "w")
  [21:15:33.317]         }
  [21:15:33.317]         else {
  [21:15:33.317]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.317]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.317]         }
  [21:15:33.317]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.317]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.317]             base::sink(type = "output", split = FALSE)
  [21:15:33.317]             base::close(...future.stdout)
  [21:15:33.317]         }, add = TRUE)
  [21:15:33.317]     }
  [21:15:33.317]     ...future.frame <- base::sys.nframe()
  [21:15:33.317]     ...future.conditions <- base::list()
  [21:15:33.317]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.317]     ...future.result <- base::tryCatch({
  [21:15:33.317]         base::withCallingHandlers({
  [21:15:33.317]             ...future.value <- base::withVisible(base::local({
  [21:15:33.317]                 sample(x, size = 1L)
  [21:15:33.317]             }))
  [21:15:33.317]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.317]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.317]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.317]                 version = "1.8")
  [21:15:33.317]         }, condition = base::local({
  [21:15:33.317]             c <- base::c
  [21:15:33.317]             inherits <- base::inherits
  [21:15:33.317]             invokeRestart <- base::invokeRestart
  [21:15:33.317]             length <- base::length
  [21:15:33.317]             list <- base::list
  [21:15:33.317]             seq.int <- base::seq.int
  [21:15:33.317]             signalCondition <- base::signalCondition
  [21:15:33.317]             sys.calls <- base::sys.calls
  [21:15:33.317]             Sys.time <- base::Sys.time
  [21:15:33.317]             `[[` <- base::`[[`
  [21:15:33.317]             `+` <- base::`+`
  [21:15:33.317]             `<<-` <- base::`<<-`
  [21:15:33.317]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.317]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.317]                   3L)]
  [21:15:33.317]             }
  [21:15:33.317]             function(cond) {
  [21:15:33.317]                 if (inherits(cond, "error")) {
  [21:15:33.317]                   sessionInformation <- function() {
  [21:15:33.317]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.317]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.317]                       search = base::search(), system = base::Sys.info())
  [21:15:33.317]                   }
  [21:15:33.317]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.317]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.317]                     cond$call), session = sessionInformation(), 
  [21:15:33.317]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.317]                   signalCondition(cond)
  [21:15:33.317]                 }
  [21:15:33.317]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.317]                 ))) {
  [21:15:33.317]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.317]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.317]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.317]                   if (!signal) {
  [21:15:33.317]                     muffleCondition <- function (cond) 
  [21:15:33.317]                     {
  [21:15:33.317]                       inherits <- base::inherits
  [21:15:33.317]                       invokeRestart <- base::invokeRestart
  [21:15:33.317]                       muffled <- FALSE
  [21:15:33.317]                       if (inherits(cond, "message")) {
  [21:15:33.317]                         invokeRestart("muffleMessage")
  [21:15:33.317]                         muffled <- TRUE
  [21:15:33.317]                       }
  [21:15:33.317]                       else if (inherits(cond, "warning")) {
  [21:15:33.317]                         invokeRestart("muffleWarning")
  [21:15:33.317]                         muffled <- TRUE
  [21:15:33.317]                       }
  [21:15:33.317]                       else if (inherits(cond, "condition")) {
  [21:15:33.317]                         computeRestarts <- base::computeRestarts
  [21:15:33.317]                         grepl <- base::grepl
  [21:15:33.317]                         is.null <- base::is.null
  [21:15:33.317]                         restarts <- computeRestarts(cond)
  [21:15:33.317]                         for (restart in restarts) {
  [21:15:33.317]                           name <- restart$name
  [21:15:33.317]                           if (is.null(name)) 
  [21:15:33.317]                             next
  [21:15:33.317]                           if (!grepl("^muffle", name)) 
  [21:15:33.317]                             next
  [21:15:33.317]                           invokeRestart(restart)
  [21:15:33.317]                           muffled <- TRUE
  [21:15:33.317]                           break
  [21:15:33.317]                         }
  [21:15:33.317]                       }
  [21:15:33.317]                       invisible(muffled)
  [21:15:33.317]                     }
  [21:15:33.317]                     muffleCondition(cond)
  [21:15:33.317]                   }
  [21:15:33.317]                 }
  [21:15:33.317]             }
  [21:15:33.317]         }))
  [21:15:33.317]     }, error = function(ex) {
  [21:15:33.317]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.317]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.317]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.317]     }, finally = {
  [21:15:33.317]         {
  [21:15:33.317]             NULL
  [21:15:33.317]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.317]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.317]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.317]                 label = NULL, ...) 
  [21:15:33.317]             {
  [21:15:33.317]                 if (substitute) 
  [21:15:33.317]                   expr <- substitute(expr)
  [21:15:33.317]                 local <- as.logical(local)
  [21:15:33.317]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.317]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.317]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.317]                   label = label, ...)
  [21:15:33.317]                 if (!future$lazy) 
  [21:15:33.317]                   future <- run(future)
  [21:15:33.317]                 invisible(future)
  [21:15:33.317]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.317]         }
  [21:15:33.317]         base::options(...future.oldOptions)
  [21:15:33.317]     })
  [21:15:33.317]     Sys.time
  [21:15:33.317]     if (base::is.na(TRUE)) {
  [21:15:33.317]     }
  [21:15:33.317]     else {
  [21:15:33.317]         base::sink(type = "output", split = FALSE)
  [21:15:33.317]         if (TRUE) {
  [21:15:33.317]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.317]         }
  [21:15:33.317]         else {
  [21:15:33.317]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.317]         }
  [21:15:33.317]         base::close(...future.stdout)
  [21:15:33.317]         ...future.stdout <- NULL
  [21:15:33.317]     }
  [21:15:33.317]     ...future.result$conditions <- ...future.conditions
  [21:15:33.317]     ...future.result
  [21:15:33.317] }
  [21:15:33.327] plan(): Setting new future strategy stack:
  [21:15:33.328] List of future strategies:
  [21:15:33.328] 1. sequential:
  [21:15:33.328]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.328]    - tweaked: FALSE
  [21:15:33.328]    - call: NULL
  [21:15:33.328] plan(): nbrOfWorkers() = 1
  [21:15:33.330] plan(): Setting new future strategy stack:
  [21:15:33.330] List of future strategies:
  [21:15:33.330] 1. sequential:
  [21:15:33.330]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.330]    - tweaked: FALSE
  [21:15:33.330]    - call: plan(strategy)
  [21:15:33.331] plan(): nbrOfWorkers() = 1
  [21:15:33.331] SequentialFuture started (and completed)
  [21:15:33.332] getGlobalsAndPackages() ...
  [21:15:33.332] Searching for globals...
  [21:15:33.334] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.334] Searching for globals ... DONE
  [21:15:33.335] Resolving globals: FALSE
  [21:15:33.335] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.336] - globals: [1] 'x'
  [21:15:33.336] 
  [21:15:33.336] getGlobalsAndPackages() ... DONE
  [21:15:33.338] Packages needed by the future expression (n = 0): <none>
  [21:15:33.338] Packages needed by future strategies (n = 0): <none>
  [21:15:33.342] {
  [21:15:33.342]     {
  [21:15:33.342]         ...future.startTime <- base::Sys.time()
  [21:15:33.342]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.342]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.342]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.342]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.342]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.342]         {
  [21:15:33.342]             {
  [21:15:33.342]                 {
  [21:15:33.342]                   base::local({
  [21:15:33.342]                     has_future <- base::requireNamespace("future", 
  [21:15:33.342]                       quietly = TRUE)
  [21:15:33.342]                     version <- if (has_future) 
  [21:15:33.342]                       utils::packageVersion("future")
  [21:15:33.342]                     else NULL
  [21:15:33.342]                     if (!has_future || version < "1.8.0") {
  [21:15:33.342]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.342]                         "", base::R.version$version.string), 
  [21:15:33.342]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.342]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.342]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.342]                           "release", "version")], collapse = " "), 
  [21:15:33.342]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:33.342]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.342]                         info)
  [21:15:33.342]                       info <- base::paste(info, collapse = "; ")
  [21:15:33.342]                       if (!has_future) {
  [21:15:33.342]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.342]                           info)
  [21:15:33.342]                       }
  [21:15:33.342]                       else {
  [21:15:33.342]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.342]                           info, version)
  [21:15:33.342]                       }
  [21:15:33.342]                       base::stop(msg)
  [21:15:33.342]                     }
  [21:15:33.342]                   })
  [21:15:33.342]                 }
  [21:15:33.342]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:33.342]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:33.342]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:33.342]             }
  [21:15:33.342]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.342]         }
  [21:15:33.342]     }
  [21:15:33.342]     if (base::is.na(TRUE)) {
  [21:15:33.342]     }
  [21:15:33.342]     else {
  [21:15:33.342]         if (TRUE) {
  [21:15:33.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.342]                 open = "w")
  [21:15:33.342]         }
  [21:15:33.342]         else {
  [21:15:33.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.342]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.342]         }
  [21:15:33.342]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.342]             base::sink(type = "output", split = FALSE)
  [21:15:33.342]             base::close(...future.stdout)
  [21:15:33.342]         }, add = TRUE)
  [21:15:33.342]     }
  [21:15:33.342]     ...future.frame <- base::sys.nframe()
  [21:15:33.342]     ...future.conditions <- base::list()
  [21:15:33.342]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.342]     ...future.result <- base::tryCatch({
  [21:15:33.342]         base::withCallingHandlers({
  [21:15:33.342]             ...future.value <- base::withVisible(base::local({
  [21:15:33.342]                 sample(x, size = 1L)
  [21:15:33.342]             }))
  [21:15:33.342]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.342]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.342]                 version = "1.8")
  [21:15:33.342]         }, condition = base::local({
  [21:15:33.342]             c <- base::c
  [21:15:33.342]             inherits <- base::inherits
  [21:15:33.342]             invokeRestart <- base::invokeRestart
  [21:15:33.342]             length <- base::length
  [21:15:33.342]             list <- base::list
  [21:15:33.342]             seq.int <- base::seq.int
  [21:15:33.342]             signalCondition <- base::signalCondition
  [21:15:33.342]             sys.calls <- base::sys.calls
  [21:15:33.342]             Sys.time <- base::Sys.time
  [21:15:33.342]             `[[` <- base::`[[`
  [21:15:33.342]             `+` <- base::`+`
  [21:15:33.342]             `<<-` <- base::`<<-`
  [21:15:33.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.342]                   3L)]
  [21:15:33.342]             }
  [21:15:33.342]             function(cond) {
  [21:15:33.342]                 if (inherits(cond, "error")) {
  [21:15:33.342]                   sessionInformation <- function() {
  [21:15:33.342]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.342]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.342]                       search = base::search(), system = base::Sys.info())
  [21:15:33.342]                   }
  [21:15:33.342]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.342]                     cond$call), session = sessionInformation(), 
  [21:15:33.342]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.342]                   signalCondition(cond)
  [21:15:33.342]                 }
  [21:15:33.342]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.342]                 ))) {
  [21:15:33.342]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.342]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.342]                   if (!signal) {
  [21:15:33.342]                     muffleCondition <- function (cond) 
  [21:15:33.342]                     {
  [21:15:33.342]                       inherits <- base::inherits
  [21:15:33.342]                       invokeRestart <- base::invokeRestart
  [21:15:33.342]                       muffled <- FALSE
  [21:15:33.342]                       if (inherits(cond, "message")) {
  [21:15:33.342]                         invokeRestart("muffleMessage")
  [21:15:33.342]                         muffled <- TRUE
  [21:15:33.342]                       }
  [21:15:33.342]                       else if (inherits(cond, "warning")) {
  [21:15:33.342]                         invokeRestart("muffleWarning")
  [21:15:33.342]                         muffled <- TRUE
  [21:15:33.342]                       }
  [21:15:33.342]                       else if (inherits(cond, "condition")) {
  [21:15:33.342]                         computeRestarts <- base::computeRestarts
  [21:15:33.342]                         grepl <- base::grepl
  [21:15:33.342]                         is.null <- base::is.null
  [21:15:33.342]                         restarts <- computeRestarts(cond)
  [21:15:33.342]                         for (restart in restarts) {
  [21:15:33.342]                           name <- restart$name
  [21:15:33.342]                           if (is.null(name)) 
  [21:15:33.342]                             next
  [21:15:33.342]                           if (!grepl("^muffle", name)) 
  [21:15:33.342]                             next
  [21:15:33.342]                           invokeRestart(restart)
  [21:15:33.342]                           muffled <- TRUE
  [21:15:33.342]                           break
  [21:15:33.342]                         }
  [21:15:33.342]                       }
  [21:15:33.342]                       invisible(muffled)
  [21:15:33.342]                     }
  [21:15:33.342]                     muffleCondition(cond)
  [21:15:33.342]                   }
  [21:15:33.342]                 }
  [21:15:33.342]             }
  [21:15:33.342]         }))
  [21:15:33.342]     }, error = function(ex) {
  [21:15:33.342]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.342]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.342]     }, finally = {
  [21:15:33.342]         {
  [21:15:33.342]             NULL
  [21:15:33.342]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.342]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.342]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.342]                 label = NULL, ...) 
  [21:15:33.342]             {
  [21:15:33.342]                 if (substitute) 
  [21:15:33.342]                   expr <- substitute(expr)
  [21:15:33.342]                 local <- as.logical(local)
  [21:15:33.342]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.342]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.342]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.342]                   label = label, ...)
  [21:15:33.342]                 if (!future$lazy) 
  [21:15:33.342]                   future <- run(future)
  [21:15:33.342]                 invisible(future)
  [21:15:33.342]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.342]         }
  [21:15:33.342]         base::options(...future.oldOptions)
  [21:15:33.342]     })
  [21:15:33.342]     Sys.time
  [21:15:33.342]     if (base::is.na(TRUE)) {
  [21:15:33.342]     }
  [21:15:33.342]     else {
  [21:15:33.342]         base::sink(type = "output", split = FALSE)
  [21:15:33.342]         if (TRUE) {
  [21:15:33.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.342]         }
  [21:15:33.342]         else {
  [21:15:33.342]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.342]         }
  [21:15:33.342]         base::close(...future.stdout)
  [21:15:33.342]         ...future.stdout <- NULL
  [21:15:33.342]     }
  [21:15:33.342]     ...future.result$conditions <- ...future.conditions
  [21:15:33.342]     ...future.result
  [21:15:33.342] }
  [21:15:33.349] plan(): Setting new future strategy stack:
  [21:15:33.349] List of future strategies:
  [21:15:33.349] 1. sequential:
  [21:15:33.349]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.349]    - tweaked: FALSE
  [21:15:33.349]    - call: NULL
  [21:15:33.350] plan(): nbrOfWorkers() = 1
  [21:15:33.351] plan(): Setting new future strategy stack:
  [21:15:33.351] List of future strategies:
  [21:15:33.351] 1. sequential:
  [21:15:33.351]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.351]    - tweaked: FALSE
  [21:15:33.351]    - call: plan(strategy)
  [21:15:33.352] plan(): nbrOfWorkers() = 1
  [21:15:33.353] SequentialFuture started (and completed)
  [21:15:33.353] resolve() on list ...
  [21:15:33.354]  recursive: 0
  [21:15:33.354]  length: 4
  [21:15:33.354] 
  [21:15:33.354] Future #1
  [21:15:33.355] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.355] - nx: 4
  [21:15:33.355] - relay: TRUE
  [21:15:33.356] - stdout: TRUE
  [21:15:33.356] - signal: TRUE
  [21:15:33.356] - resignal: FALSE
  [21:15:33.356] - force: TRUE
  [21:15:33.357] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.357] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.357]  - until=1
  [21:15:33.357]  - relaying element #1
  [21:15:33.358] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.358] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.358] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.359]  length: 3 (resolved future 1)
  [21:15:33.359] Future #2
  [21:15:33.359] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.360] - nx: 4
  [21:15:33.360] - relay: TRUE
  [21:15:33.360] - stdout: TRUE
  [21:15:33.360] - signal: TRUE
  [21:15:33.361] - resignal: FALSE
  [21:15:33.361] - force: TRUE
  [21:15:33.361] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.361] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.362]  - until=2
  [21:15:33.362]  - relaying element #2
  [21:15:33.362] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.363] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.363] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.363]  length: 2 (resolved future 2)
  [21:15:33.364] Future #3
  [21:15:33.364] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.364] - nx: 4
  [21:15:33.365] - relay: TRUE
  [21:15:33.365] - stdout: TRUE
  [21:15:33.365] - signal: TRUE
  [21:15:33.365] - resignal: FALSE
  [21:15:33.366] - force: TRUE
  [21:15:33.366] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.366] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.366]  - until=3
  [21:15:33.367]  - relaying element #3
  [21:15:33.367] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.367] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.368] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.368]  length: 1 (resolved future 3)
  [21:15:33.371] Future #4
  [21:15:33.372] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.372] - nx: 4
  [21:15:33.372] - relay: TRUE
  [21:15:33.373] - stdout: TRUE
  [21:15:33.373] - signal: TRUE
  [21:15:33.373] - resignal: FALSE
  [21:15:33.373] - force: TRUE
  [21:15:33.373] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.374] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.374]  - until=4
  [21:15:33.374]  - relaying element #4
  [21:15:33.375] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.375] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.375] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.375]  length: 0 (resolved future 4)
  [21:15:33.376] Relaying remaining futures
  [21:15:33.376] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.376] - nx: 4
  [21:15:33.376] - relay: TRUE
  [21:15:33.377] - stdout: TRUE
  [21:15:33.377] - signal: TRUE
  [21:15:33.377] - resignal: FALSE
  [21:15:33.377] - force: TRUE
  [21:15:33.378] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.378] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.378] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.379] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.379] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.379] resolve() on list ... DONE
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 1
  
  [21:15:33.380] getGlobalsAndPackages() ...
  [21:15:33.381] Searching for globals...
  [21:15:33.383] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.383] Searching for globals ... DONE
  [21:15:33.383] Resolving globals: FALSE
  [21:15:33.384] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.385] - globals: [1] 'x'
  [21:15:33.385] 
  [21:15:33.385] getGlobalsAndPackages() ... DONE
  [21:15:33.387] Packages needed by the future expression (n = 0): <none>
  [21:15:33.387] Packages needed by future strategies (n = 0): <none>
  [21:15:33.392] {
  [21:15:33.392]     {
  [21:15:33.392]         ...future.startTime <- base::Sys.time()
  [21:15:33.392]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.392]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.392]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.392]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.392]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.392]         {
  [21:15:33.392]             {
  [21:15:33.392]                 base::local({
  [21:15:33.392]                   has_future <- base::requireNamespace("future", 
  [21:15:33.392]                     quietly = TRUE)
  [21:15:33.392]                   version <- if (has_future) 
  [21:15:33.392]                     utils::packageVersion("future")
  [21:15:33.392]                   else NULL
  [21:15:33.392]                   if (!has_future || version < "1.8.0") {
  [21:15:33.392]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.392]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.392]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.392]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.392]                         "release", "version")], collapse = " "), 
  [21:15:33.392]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.392]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.392]                       info)
  [21:15:33.392]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.392]                     if (!has_future) {
  [21:15:33.392]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.392]                         info)
  [21:15:33.392]                     }
  [21:15:33.392]                     else {
  [21:15:33.392]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.392]                         info, version)
  [21:15:33.392]                     }
  [21:15:33.392]                     base::stop(msg)
  [21:15:33.392]                   }
  [21:15:33.392]                 })
  [21:15:33.392]             }
  [21:15:33.392]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.392]         }
  [21:15:33.392]     }
  [21:15:33.392]     if (base::is.na(TRUE)) {
  [21:15:33.392]     }
  [21:15:33.392]     else {
  [21:15:33.392]         if (TRUE) {
  [21:15:33.392]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.392]                 open = "w")
  [21:15:33.392]         }
  [21:15:33.392]         else {
  [21:15:33.392]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.392]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.392]         }
  [21:15:33.392]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.392]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.392]             base::sink(type = "output", split = FALSE)
  [21:15:33.392]             base::close(...future.stdout)
  [21:15:33.392]         }, add = TRUE)
  [21:15:33.392]     }
  [21:15:33.392]     ...future.frame <- base::sys.nframe()
  [21:15:33.392]     ...future.conditions <- base::list()
  [21:15:33.392]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.392]     ...future.result <- base::tryCatch({
  [21:15:33.392]         base::withCallingHandlers({
  [21:15:33.392]             ...future.value <- base::withVisible(base::local({
  [21:15:33.392]                 sample(x, size = 1L)
  [21:15:33.392]             }))
  [21:15:33.392]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.392]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.392]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.392]                 version = "1.8")
  [21:15:33.392]         }, condition = base::local({
  [21:15:33.392]             c <- base::c
  [21:15:33.392]             inherits <- base::inherits
  [21:15:33.392]             invokeRestart <- base::invokeRestart
  [21:15:33.392]             length <- base::length
  [21:15:33.392]             list <- base::list
  [21:15:33.392]             seq.int <- base::seq.int
  [21:15:33.392]             signalCondition <- base::signalCondition
  [21:15:33.392]             sys.calls <- base::sys.calls
  [21:15:33.392]             Sys.time <- base::Sys.time
  [21:15:33.392]             `[[` <- base::`[[`
  [21:15:33.392]             `+` <- base::`+`
  [21:15:33.392]             `<<-` <- base::`<<-`
  [21:15:33.392]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.392]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.392]                   3L)]
  [21:15:33.392]             }
  [21:15:33.392]             function(cond) {
  [21:15:33.392]                 if (inherits(cond, "error")) {
  [21:15:33.392]                   sessionInformation <- function() {
  [21:15:33.392]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.392]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.392]                       search = base::search(), system = base::Sys.info())
  [21:15:33.392]                   }
  [21:15:33.392]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.392]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.392]                     cond$call), session = sessionInformation(), 
  [21:15:33.392]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.392]                   signalCondition(cond)
  [21:15:33.392]                 }
  [21:15:33.392]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.392]                 ))) {
  [21:15:33.392]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.392]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.392]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.392]                   if (!signal) {
  [21:15:33.392]                     muffleCondition <- function (cond) 
  [21:15:33.392]                     {
  [21:15:33.392]                       inherits <- base::inherits
  [21:15:33.392]                       invokeRestart <- base::invokeRestart
  [21:15:33.392]                       muffled <- FALSE
  [21:15:33.392]                       if (inherits(cond, "message")) {
  [21:15:33.392]                         invokeRestart("muffleMessage")
  [21:15:33.392]                         muffled <- TRUE
  [21:15:33.392]                       }
  [21:15:33.392]                       else if (inherits(cond, "warning")) {
  [21:15:33.392]                         invokeRestart("muffleWarning")
  [21:15:33.392]                         muffled <- TRUE
  [21:15:33.392]                       }
  [21:15:33.392]                       else if (inherits(cond, "condition")) {
  [21:15:33.392]                         computeRestarts <- base::computeRestarts
  [21:15:33.392]                         grepl <- base::grepl
  [21:15:33.392]                         is.null <- base::is.null
  [21:15:33.392]                         restarts <- computeRestarts(cond)
  [21:15:33.392]                         for (restart in restarts) {
  [21:15:33.392]                           name <- restart$name
  [21:15:33.392]                           if (is.null(name)) 
  [21:15:33.392]                             next
  [21:15:33.392]                           if (!grepl("^muffle", name)) 
  [21:15:33.392]                             next
  [21:15:33.392]                           invokeRestart(restart)
  [21:15:33.392]                           muffled <- TRUE
  [21:15:33.392]                           break
  [21:15:33.392]                         }
  [21:15:33.392]                       }
  [21:15:33.392]                       invisible(muffled)
  [21:15:33.392]                     }
  [21:15:33.392]                     muffleCondition(cond)
  [21:15:33.392]                   }
  [21:15:33.392]                 }
  [21:15:33.392]             }
  [21:15:33.392]         }))
  [21:15:33.392]     }, error = function(ex) {
  [21:15:33.392]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.392]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.392]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.392]     }, finally = {
  [21:15:33.392]         {
  [21:15:33.392]             NULL
  [21:15:33.392]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.392]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.392]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.392]                 label = NULL, ...) 
  [21:15:33.392]             {
  [21:15:33.392]                 if (substitute) 
  [21:15:33.392]                   expr <- substitute(expr)
  [21:15:33.392]                 local <- as.logical(local)
  [21:15:33.392]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.392]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.392]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.392]                   label = label, ...)
  [21:15:33.392]                 if (!future$lazy) 
  [21:15:33.392]                   future <- run(future)
  [21:15:33.392]                 invisible(future)
  [21:15:33.392]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.392]         }
  [21:15:33.392]         base::options(...future.oldOptions)
  [21:15:33.392]     })
  [21:15:33.392]     Sys.time
  [21:15:33.392]     if (base::is.na(TRUE)) {
  [21:15:33.392]     }
  [21:15:33.392]     else {
  [21:15:33.392]         base::sink(type = "output", split = FALSE)
  [21:15:33.392]         if (TRUE) {
  [21:15:33.392]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.392]         }
  [21:15:33.392]         else {
  [21:15:33.392]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.392]         }
  [21:15:33.392]         base::close(...future.stdout)
  [21:15:33.392]         ...future.stdout <- NULL
  [21:15:33.392]     }
  [21:15:33.392]     ...future.result$conditions <- ...future.conditions
  [21:15:33.392]     ...future.result
  [21:15:33.392] }
  [21:15:33.396] plan(): Setting new future strategy stack:
  [21:15:33.397] List of future strategies:
  [21:15:33.397] 1. sequential:
  [21:15:33.397]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.397]    - tweaked: FALSE
  [21:15:33.397]    - call: NULL
  [21:15:33.397] plan(): nbrOfWorkers() = 1
  [21:15:33.398] plan(): Setting new future strategy stack:
  [21:15:33.399] List of future strategies:
  [21:15:33.399] 1. sequential:
  [21:15:33.399]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.399]    - tweaked: FALSE
  [21:15:33.399]    - call: plan(strategy)
  [21:15:33.400] plan(): nbrOfWorkers() = 1
  [21:15:33.400] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-750903'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334937c538>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.403] getGlobalsAndPackages() ...
  [21:15:33.403] Searching for globals...
  [21:15:33.405] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.405] Searching for globals ... DONE
  [21:15:33.406] Resolving globals: FALSE
  [21:15:33.406] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.407] - globals: [1] 'x'
  [21:15:33.407] 
  [21:15:33.407] getGlobalsAndPackages() ... DONE
  [21:15:33.409] Packages needed by the future expression (n = 0): <none>
  [21:15:33.409] Packages needed by future strategies (n = 0): <none>
  [21:15:33.415] {
  [21:15:33.415]     {
  [21:15:33.415]         ...future.startTime <- base::Sys.time()
  [21:15:33.415]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.415]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.415]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.415]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.415]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.415]         {
  [21:15:33.415]             {
  [21:15:33.415]                 base::local({
  [21:15:33.415]                   has_future <- base::requireNamespace("future", 
  [21:15:33.415]                     quietly = TRUE)
  [21:15:33.415]                   version <- if (has_future) 
  [21:15:33.415]                     utils::packageVersion("future")
  [21:15:33.415]                   else NULL
  [21:15:33.415]                   if (!has_future || version < "1.8.0") {
  [21:15:33.415]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.415]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.415]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.415]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.415]                         "release", "version")], collapse = " "), 
  [21:15:33.415]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.415]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.415]                       info)
  [21:15:33.415]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.415]                     if (!has_future) {
  [21:15:33.415]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.415]                         info)
  [21:15:33.415]                     }
  [21:15:33.415]                     else {
  [21:15:33.415]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.415]                         info, version)
  [21:15:33.415]                     }
  [21:15:33.415]                     base::stop(msg)
  [21:15:33.415]                   }
  [21:15:33.415]                 })
  [21:15:33.415]             }
  [21:15:33.415]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.415]         }
  [21:15:33.415]     }
  [21:15:33.415]     if (base::is.na(TRUE)) {
  [21:15:33.415]     }
  [21:15:33.415]     else {
  [21:15:33.415]         if (TRUE) {
  [21:15:33.415]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.415]                 open = "w")
  [21:15:33.415]         }
  [21:15:33.415]         else {
  [21:15:33.415]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.415]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.415]         }
  [21:15:33.415]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.415]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.415]             base::sink(type = "output", split = FALSE)
  [21:15:33.415]             base::close(...future.stdout)
  [21:15:33.415]         }, add = TRUE)
  [21:15:33.415]     }
  [21:15:33.415]     ...future.frame <- base::sys.nframe()
  [21:15:33.415]     ...future.conditions <- base::list()
  [21:15:33.415]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.415]     ...future.result <- base::tryCatch({
  [21:15:33.415]         base::withCallingHandlers({
  [21:15:33.415]             ...future.value <- base::withVisible(base::local({
  [21:15:33.415]                 sample(x, size = 1L)
  [21:15:33.415]             }))
  [21:15:33.415]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.415]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.415]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.415]                 version = "1.8")
  [21:15:33.415]         }, condition = base::local({
  [21:15:33.415]             c <- base::c
  [21:15:33.415]             inherits <- base::inherits
  [21:15:33.415]             invokeRestart <- base::invokeRestart
  [21:15:33.415]             length <- base::length
  [21:15:33.415]             list <- base::list
  [21:15:33.415]             seq.int <- base::seq.int
  [21:15:33.415]             signalCondition <- base::signalCondition
  [21:15:33.415]             sys.calls <- base::sys.calls
  [21:15:33.415]             Sys.time <- base::Sys.time
  [21:15:33.415]             `[[` <- base::`[[`
  [21:15:33.415]             `+` <- base::`+`
  [21:15:33.415]             `<<-` <- base::`<<-`
  [21:15:33.415]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.415]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.415]                   3L)]
  [21:15:33.415]             }
  [21:15:33.415]             function(cond) {
  [21:15:33.415]                 if (inherits(cond, "error")) {
  [21:15:33.415]                   sessionInformation <- function() {
  [21:15:33.415]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.415]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.415]                       search = base::search(), system = base::Sys.info())
  [21:15:33.415]                   }
  [21:15:33.415]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.415]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.415]                     cond$call), session = sessionInformation(), 
  [21:15:33.415]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.415]                   signalCondition(cond)
  [21:15:33.415]                 }
  [21:15:33.415]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.415]                 ))) {
  [21:15:33.415]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.415]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.415]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.415]                   if (!signal) {
  [21:15:33.415]                     muffleCondition <- function (cond) 
  [21:15:33.415]                     {
  [21:15:33.415]                       inherits <- base::inherits
  [21:15:33.415]                       invokeRestart <- base::invokeRestart
  [21:15:33.415]                       muffled <- FALSE
  [21:15:33.415]                       if (inherits(cond, "message")) {
  [21:15:33.415]                         invokeRestart("muffleMessage")
  [21:15:33.415]                         muffled <- TRUE
  [21:15:33.415]                       }
  [21:15:33.415]                       else if (inherits(cond, "warning")) {
  [21:15:33.415]                         invokeRestart("muffleWarning")
  [21:15:33.415]                         muffled <- TRUE
  [21:15:33.415]                       }
  [21:15:33.415]                       else if (inherits(cond, "condition")) {
  [21:15:33.415]                         computeRestarts <- base::computeRestarts
  [21:15:33.415]                         grepl <- base::grepl
  [21:15:33.415]                         is.null <- base::is.null
  [21:15:33.415]                         restarts <- computeRestarts(cond)
  [21:15:33.415]                         for (restart in restarts) {
  [21:15:33.415]                           name <- restart$name
  [21:15:33.415]                           if (is.null(name)) 
  [21:15:33.415]                             next
  [21:15:33.415]                           if (!grepl("^muffle", name)) 
  [21:15:33.415]                             next
  [21:15:33.415]                           invokeRestart(restart)
  [21:15:33.415]                           muffled <- TRUE
  [21:15:33.415]                           break
  [21:15:33.415]                         }
  [21:15:33.415]                       }
  [21:15:33.415]                       invisible(muffled)
  [21:15:33.415]                     }
  [21:15:33.415]                     muffleCondition(cond)
  [21:15:33.415]                   }
  [21:15:33.415]                 }
  [21:15:33.415]             }
  [21:15:33.415]         }))
  [21:15:33.415]     }, error = function(ex) {
  [21:15:33.415]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.415]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.415]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.415]     }, finally = {
  [21:15:33.415]         {
  [21:15:33.415]             NULL
  [21:15:33.415]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.415]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.415]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.415]                 label = NULL, ...) 
  [21:15:33.415]             {
  [21:15:33.415]                 if (substitute) 
  [21:15:33.415]                   expr <- substitute(expr)
  [21:15:33.415]                 local <- as.logical(local)
  [21:15:33.415]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.415]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.415]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.415]                   label = label, ...)
  [21:15:33.415]                 if (!future$lazy) 
  [21:15:33.415]                   future <- run(future)
  [21:15:33.415]                 invisible(future)
  [21:15:33.415]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.415]         }
  [21:15:33.415]         base::options(...future.oldOptions)
  [21:15:33.415]     })
  [21:15:33.415]     Sys.time
  [21:15:33.415]     if (base::is.na(TRUE)) {
  [21:15:33.415]     }
  [21:15:33.415]     else {
  [21:15:33.415]         base::sink(type = "output", split = FALSE)
  [21:15:33.415]         if (TRUE) {
  [21:15:33.415]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.415]         }
  [21:15:33.415]         else {
  [21:15:33.415]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.415]         }
  [21:15:33.415]         base::close(...future.stdout)
  [21:15:33.415]         ...future.stdout <- NULL
  [21:15:33.415]     }
  [21:15:33.415]     ...future.result$conditions <- ...future.conditions
  [21:15:33.415]     ...future.result
  [21:15:33.415] }
  [21:15:33.419] plan(): Setting new future strategy stack:
  [21:15:33.420] List of future strategies:
  [21:15:33.420] 1. sequential:
  [21:15:33.420]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.420]    - tweaked: FALSE
  [21:15:33.420]    - call: NULL
  [21:15:33.421] plan(): nbrOfWorkers() = 1
  [21:15:33.422] plan(): Setting new future strategy stack:
  [21:15:33.422] List of future strategies:
  [21:15:33.422] 1. sequential:
  [21:15:33.422]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.422]    - tweaked: FALSE
  [21:15:33.422]    - call: plan(strategy)
  [21:15:33.423] plan(): nbrOfWorkers() = 1
  [21:15:33.424] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-363469'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334937c538>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.425] getGlobalsAndPackages() ...
  [21:15:33.438] Searching for globals...
  [21:15:33.440] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.440] Searching for globals ... DONE
  [21:15:33.441] Resolving globals: FALSE
  [21:15:33.442] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.442] - globals: [1] 'x'
  [21:15:33.442] 
  [21:15:33.443] getGlobalsAndPackages() ... DONE
  [21:15:33.444] Packages needed by the future expression (n = 0): <none>
  [21:15:33.445] Packages needed by future strategies (n = 0): <none>
  [21:15:33.449] {
  [21:15:33.449]     {
  [21:15:33.449]         ...future.startTime <- base::Sys.time()
  [21:15:33.449]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.449]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.449]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.449]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.449]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.449]         {
  [21:15:33.449]             {
  [21:15:33.449]                 base::local({
  [21:15:33.449]                   has_future <- base::requireNamespace("future", 
  [21:15:33.449]                     quietly = TRUE)
  [21:15:33.449]                   version <- if (has_future) 
  [21:15:33.449]                     utils::packageVersion("future")
  [21:15:33.449]                   else NULL
  [21:15:33.449]                   if (!has_future || version < "1.8.0") {
  [21:15:33.449]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.449]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.449]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.449]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.449]                         "release", "version")], collapse = " "), 
  [21:15:33.449]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.449]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.449]                       info)
  [21:15:33.449]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.449]                     if (!has_future) {
  [21:15:33.449]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.449]                         info)
  [21:15:33.449]                     }
  [21:15:33.449]                     else {
  [21:15:33.449]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.449]                         info, version)
  [21:15:33.449]                     }
  [21:15:33.449]                     base::stop(msg)
  [21:15:33.449]                   }
  [21:15:33.449]                 })
  [21:15:33.449]             }
  [21:15:33.449]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.449]         }
  [21:15:33.449]     }
  [21:15:33.449]     if (base::is.na(TRUE)) {
  [21:15:33.449]     }
  [21:15:33.449]     else {
  [21:15:33.449]         if (TRUE) {
  [21:15:33.449]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.449]                 open = "w")
  [21:15:33.449]         }
  [21:15:33.449]         else {
  [21:15:33.449]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.449]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.449]         }
  [21:15:33.449]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.449]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.449]             base::sink(type = "output", split = FALSE)
  [21:15:33.449]             base::close(...future.stdout)
  [21:15:33.449]         }, add = TRUE)
  [21:15:33.449]     }
  [21:15:33.449]     ...future.frame <- base::sys.nframe()
  [21:15:33.449]     ...future.conditions <- base::list()
  [21:15:33.449]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.449]     ...future.result <- base::tryCatch({
  [21:15:33.449]         base::withCallingHandlers({
  [21:15:33.449]             ...future.value <- base::withVisible(base::local({
  [21:15:33.449]                 sample(x, size = 1L)
  [21:15:33.449]             }))
  [21:15:33.449]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.449]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.449]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.449]                 version = "1.8")
  [21:15:33.449]         }, condition = base::local({
  [21:15:33.449]             c <- base::c
  [21:15:33.449]             inherits <- base::inherits
  [21:15:33.449]             invokeRestart <- base::invokeRestart
  [21:15:33.449]             length <- base::length
  [21:15:33.449]             list <- base::list
  [21:15:33.449]             seq.int <- base::seq.int
  [21:15:33.449]             signalCondition <- base::signalCondition
  [21:15:33.449]             sys.calls <- base::sys.calls
  [21:15:33.449]             Sys.time <- base::Sys.time
  [21:15:33.449]             `[[` <- base::`[[`
  [21:15:33.449]             `+` <- base::`+`
  [21:15:33.449]             `<<-` <- base::`<<-`
  [21:15:33.449]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.449]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.449]                   3L)]
  [21:15:33.449]             }
  [21:15:33.449]             function(cond) {
  [21:15:33.449]                 if (inherits(cond, "error")) {
  [21:15:33.449]                   sessionInformation <- function() {
  [21:15:33.449]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.449]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.449]                       search = base::search(), system = base::Sys.info())
  [21:15:33.449]                   }
  [21:15:33.449]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.449]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.449]                     cond$call), session = sessionInformation(), 
  [21:15:33.449]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.449]                   signalCondition(cond)
  [21:15:33.449]                 }
  [21:15:33.449]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.449]                 ))) {
  [21:15:33.449]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.449]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.449]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.449]                   if (!signal) {
  [21:15:33.449]                     muffleCondition <- function (cond) 
  [21:15:33.449]                     {
  [21:15:33.449]                       inherits <- base::inherits
  [21:15:33.449]                       invokeRestart <- base::invokeRestart
  [21:15:33.449]                       muffled <- FALSE
  [21:15:33.449]                       if (inherits(cond, "message")) {
  [21:15:33.449]                         invokeRestart("muffleMessage")
  [21:15:33.449]                         muffled <- TRUE
  [21:15:33.449]                       }
  [21:15:33.449]                       else if (inherits(cond, "warning")) {
  [21:15:33.449]                         invokeRestart("muffleWarning")
  [21:15:33.449]                         muffled <- TRUE
  [21:15:33.449]                       }
  [21:15:33.449]                       else if (inherits(cond, "condition")) {
  [21:15:33.449]                         computeRestarts <- base::computeRestarts
  [21:15:33.449]                         grepl <- base::grepl
  [21:15:33.449]                         is.null <- base::is.null
  [21:15:33.449]                         restarts <- computeRestarts(cond)
  [21:15:33.449]                         for (restart in restarts) {
  [21:15:33.449]                           name <- restart$name
  [21:15:33.449]                           if (is.null(name)) 
  [21:15:33.449]                             next
  [21:15:33.449]                           if (!grepl("^muffle", name)) 
  [21:15:33.449]                             next
  [21:15:33.449]                           invokeRestart(restart)
  [21:15:33.449]                           muffled <- TRUE
  [21:15:33.449]                           break
  [21:15:33.449]                         }
  [21:15:33.449]                       }
  [21:15:33.449]                       invisible(muffled)
  [21:15:33.449]                     }
  [21:15:33.449]                     muffleCondition(cond)
  [21:15:33.449]                   }
  [21:15:33.449]                 }
  [21:15:33.449]             }
  [21:15:33.449]         }))
  [21:15:33.449]     }, error = function(ex) {
  [21:15:33.449]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.449]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.449]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.449]     }, finally = {
  [21:15:33.449]         {
  [21:15:33.449]             NULL
  [21:15:33.449]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.449]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.449]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.449]                 label = NULL, ...) 
  [21:15:33.449]             {
  [21:15:33.449]                 if (substitute) 
  [21:15:33.449]                   expr <- substitute(expr)
  [21:15:33.449]                 local <- as.logical(local)
  [21:15:33.449]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.449]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.449]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.449]                   label = label, ...)
  [21:15:33.449]                 if (!future$lazy) 
  [21:15:33.449]                   future <- run(future)
  [21:15:33.449]                 invisible(future)
  [21:15:33.449]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.449]         }
  [21:15:33.449]         base::options(...future.oldOptions)
  [21:15:33.449]     })
  [21:15:33.449]     Sys.time
  [21:15:33.449]     if (base::is.na(TRUE)) {
  [21:15:33.449]     }
  [21:15:33.449]     else {
  [21:15:33.449]         base::sink(type = "output", split = FALSE)
  [21:15:33.449]         if (TRUE) {
  [21:15:33.449]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.449]         }
  [21:15:33.449]         else {
  [21:15:33.449]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.449]         }
  [21:15:33.449]         base::close(...future.stdout)
  [21:15:33.449]         ...future.stdout <- NULL
  [21:15:33.449]     }
  [21:15:33.449]     ...future.result$conditions <- ...future.conditions
  [21:15:33.449]     ...future.result
  [21:15:33.449] }
  [21:15:33.453] plan(): Setting new future strategy stack:
  [21:15:33.470] List of future strategies:
  [21:15:33.470] 1. sequential:
  [21:15:33.470]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.470]    - tweaked: FALSE
  [21:15:33.470]    - call: NULL
  [21:15:33.471] plan(): nbrOfWorkers() = 1
  [21:15:33.475] plan(): Setting new future strategy stack:
  [21:15:33.475] List of future strategies:
  [21:15:33.475] 1. sequential:
  [21:15:33.475]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.475]    - tweaked: FALSE
  [21:15:33.475]    - call: plan(strategy)
  [21:15:33.476] plan(): nbrOfWorkers() = 1
  [21:15:33.477] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-208680'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334937c538>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.479] getGlobalsAndPackages() ...
  [21:15:33.479] Searching for globals...
  [21:15:33.503] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.503] Searching for globals ... DONE
  [21:15:33.504] Resolving globals: FALSE
  [21:15:33.504] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.505] - globals: [1] 'x'
  [21:15:33.505] 
  [21:15:33.505] getGlobalsAndPackages() ... DONE
  [21:15:33.507] Packages needed by the future expression (n = 0): <none>
  [21:15:33.507] Packages needed by future strategies (n = 0): <none>
  [21:15:33.512] {
  [21:15:33.512]     {
  [21:15:33.512]         ...future.startTime <- base::Sys.time()
  [21:15:33.512]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.512]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.512]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.512]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.512]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.512]         {
  [21:15:33.512]             {
  [21:15:33.512]                 base::local({
  [21:15:33.512]                   has_future <- base::requireNamespace("future", 
  [21:15:33.512]                     quietly = TRUE)
  [21:15:33.512]                   version <- if (has_future) 
  [21:15:33.512]                     utils::packageVersion("future")
  [21:15:33.512]                   else NULL
  [21:15:33.512]                   if (!has_future || version < "1.8.0") {
  [21:15:33.512]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.512]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.512]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.512]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.512]                         "release", "version")], collapse = " "), 
  [21:15:33.512]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.512]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.512]                       info)
  [21:15:33.512]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.512]                     if (!has_future) {
  [21:15:33.512]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.512]                         info)
  [21:15:33.512]                     }
  [21:15:33.512]                     else {
  [21:15:33.512]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.512]                         info, version)
  [21:15:33.512]                     }
  [21:15:33.512]                     base::stop(msg)
  [21:15:33.512]                   }
  [21:15:33.512]                 })
  [21:15:33.512]             }
  [21:15:33.512]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.512]         }
  [21:15:33.512]     }
  [21:15:33.512]     if (base::is.na(TRUE)) {
  [21:15:33.512]     }
  [21:15:33.512]     else {
  [21:15:33.512]         if (TRUE) {
  [21:15:33.512]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.512]                 open = "w")
  [21:15:33.512]         }
  [21:15:33.512]         else {
  [21:15:33.512]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.512]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.512]         }
  [21:15:33.512]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.512]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.512]             base::sink(type = "output", split = FALSE)
  [21:15:33.512]             base::close(...future.stdout)
  [21:15:33.512]         }, add = TRUE)
  [21:15:33.512]     }
  [21:15:33.512]     ...future.frame <- base::sys.nframe()
  [21:15:33.512]     ...future.conditions <- base::list()
  [21:15:33.512]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.512]     ...future.result <- base::tryCatch({
  [21:15:33.512]         base::withCallingHandlers({
  [21:15:33.512]             ...future.value <- base::withVisible(base::local({
  [21:15:33.512]                 sample(x, size = 1L)
  [21:15:33.512]             }))
  [21:15:33.512]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.512]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.512]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.512]                 version = "1.8")
  [21:15:33.512]         }, condition = base::local({
  [21:15:33.512]             c <- base::c
  [21:15:33.512]             inherits <- base::inherits
  [21:15:33.512]             invokeRestart <- base::invokeRestart
  [21:15:33.512]             length <- base::length
  [21:15:33.512]             list <- base::list
  [21:15:33.512]             seq.int <- base::seq.int
  [21:15:33.512]             signalCondition <- base::signalCondition
  [21:15:33.512]             sys.calls <- base::sys.calls
  [21:15:33.512]             Sys.time <- base::Sys.time
  [21:15:33.512]             `[[` <- base::`[[`
  [21:15:33.512]             `+` <- base::`+`
  [21:15:33.512]             `<<-` <- base::`<<-`
  [21:15:33.512]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.512]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.512]                   3L)]
  [21:15:33.512]             }
  [21:15:33.512]             function(cond) {
  [21:15:33.512]                 if (inherits(cond, "error")) {
  [21:15:33.512]                   sessionInformation <- function() {
  [21:15:33.512]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.512]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.512]                       search = base::search(), system = base::Sys.info())
  [21:15:33.512]                   }
  [21:15:33.512]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.512]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.512]                     cond$call), session = sessionInformation(), 
  [21:15:33.512]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.512]                   signalCondition(cond)
  [21:15:33.512]                 }
  [21:15:33.512]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.512]                 ))) {
  [21:15:33.512]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.512]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.512]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.512]                   if (!signal) {
  [21:15:33.512]                     muffleCondition <- function (cond) 
  [21:15:33.512]                     {
  [21:15:33.512]                       inherits <- base::inherits
  [21:15:33.512]                       invokeRestart <- base::invokeRestart
  [21:15:33.512]                       muffled <- FALSE
  [21:15:33.512]                       if (inherits(cond, "message")) {
  [21:15:33.512]                         invokeRestart("muffleMessage")
  [21:15:33.512]                         muffled <- TRUE
  [21:15:33.512]                       }
  [21:15:33.512]                       else if (inherits(cond, "warning")) {
  [21:15:33.512]                         invokeRestart("muffleWarning")
  [21:15:33.512]                         muffled <- TRUE
  [21:15:33.512]                       }
  [21:15:33.512]                       else if (inherits(cond, "condition")) {
  [21:15:33.512]                         computeRestarts <- base::computeRestarts
  [21:15:33.512]                         grepl <- base::grepl
  [21:15:33.512]                         is.null <- base::is.null
  [21:15:33.512]                         restarts <- computeRestarts(cond)
  [21:15:33.512]                         for (restart in restarts) {
  [21:15:33.512]                           name <- restart$name
  [21:15:33.512]                           if (is.null(name)) 
  [21:15:33.512]                             next
  [21:15:33.512]                           if (!grepl("^muffle", name)) 
  [21:15:33.512]                             next
  [21:15:33.512]                           invokeRestart(restart)
  [21:15:33.512]                           muffled <- TRUE
  [21:15:33.512]                           break
  [21:15:33.512]                         }
  [21:15:33.512]                       }
  [21:15:33.512]                       invisible(muffled)
  [21:15:33.512]                     }
  [21:15:33.512]                     muffleCondition(cond)
  [21:15:33.512]                   }
  [21:15:33.512]                 }
  [21:15:33.512]             }
  [21:15:33.512]         }))
  [21:15:33.512]     }, error = function(ex) {
  [21:15:33.512]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.512]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.512]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.512]     }, finally = {
  [21:15:33.512]         {
  [21:15:33.512]             NULL
  [21:15:33.512]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.512]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.512]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.512]                 label = NULL, ...) 
  [21:15:33.512]             {
  [21:15:33.512]                 if (substitute) 
  [21:15:33.512]                   expr <- substitute(expr)
  [21:15:33.512]                 local <- as.logical(local)
  [21:15:33.512]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.512]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.512]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.512]                   label = label, ...)
  [21:15:33.512]                 if (!future$lazy) 
  [21:15:33.512]                   future <- run(future)
  [21:15:33.512]                 invisible(future)
  [21:15:33.512]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.512]         }
  [21:15:33.512]         base::options(...future.oldOptions)
  [21:15:33.512]     })
  [21:15:33.512]     Sys.time
  [21:15:33.512]     if (base::is.na(TRUE)) {
  [21:15:33.512]     }
  [21:15:33.512]     else {
  [21:15:33.512]         base::sink(type = "output", split = FALSE)
  [21:15:33.512]         if (TRUE) {
  [21:15:33.512]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.512]         }
  [21:15:33.512]         else {
  [21:15:33.512]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.512]         }
  [21:15:33.512]         base::close(...future.stdout)
  [21:15:33.512]         ...future.stdout <- NULL
  [21:15:33.512]     }
  [21:15:33.512]     ...future.result$conditions <- ...future.conditions
  [21:15:33.512]     ...future.result
  [21:15:33.512] }
  [21:15:33.516] plan(): Setting new future strategy stack:
  [21:15:33.517] List of future strategies:
  [21:15:33.517] 1. sequential:
  [21:15:33.517]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.517]    - tweaked: FALSE
  [21:15:33.517]    - call: NULL
  [21:15:33.517] plan(): nbrOfWorkers() = 1
  [21:15:33.535] plan(): Setting new future strategy stack:
  [21:15:33.535] List of future strategies:
  [21:15:33.535] 1. sequential:
  [21:15:33.535]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.535]    - tweaked: FALSE
  [21:15:33.535]    - call: plan(strategy)
  [21:15:33.536] plan(): nbrOfWorkers() = 1
  [21:15:33.536] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-123760'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334937c538>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.538] resolve() on list ...
  [21:15:33.539]  recursive: 0
  [21:15:33.539]  length: 4
  [21:15:33.539] 
  [21:15:33.539] Future #1
  [21:15:33.540] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.540] - nx: 4
  [21:15:33.541] - relay: TRUE
  [21:15:33.541] - stdout: TRUE
  [21:15:33.541] - signal: TRUE
  [21:15:33.541] - resignal: FALSE
  [21:15:33.542] - force: TRUE
  [21:15:33.542] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.542] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.543]  - until=1
  [21:15:33.543]  - relaying element #1
  [21:15:33.543] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.544] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.544] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.544]  length: 3 (resolved future 1)
  [21:15:33.545] Future #2
  [21:15:33.545] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.546] - nx: 4
  [21:15:33.546] - relay: TRUE
  [21:15:33.546] - stdout: TRUE
  [21:15:33.546] - signal: TRUE
  [21:15:33.547] - resignal: FALSE
  [21:15:33.547] - force: TRUE
  [21:15:33.547] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.547] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.548]  - until=2
  [21:15:33.548]  - relaying element #2
  [21:15:33.549] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.549] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.549] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.566]  length: 2 (resolved future 2)
  [21:15:33.566] Future #3
  [21:15:33.567] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.567] - nx: 4
  [21:15:33.567] - relay: TRUE
  [21:15:33.568] - stdout: TRUE
  [21:15:33.568] - signal: TRUE
  [21:15:33.568] - resignal: FALSE
  [21:15:33.568] - force: TRUE
  [21:15:33.569] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.569] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.569]  - until=3
  [21:15:33.570]  - relaying element #3
  [21:15:33.570] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.570] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.571] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.571]  length: 1 (resolved future 3)
  [21:15:33.571] Future #4
  [21:15:33.572] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.572] - nx: 4
  [21:15:33.572] - relay: TRUE
  [21:15:33.572] - stdout: TRUE
  [21:15:33.573] - signal: TRUE
  [21:15:33.573] - resignal: FALSE
  [21:15:33.573] - force: TRUE
  [21:15:33.573] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.574] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.574]  - until=4
  [21:15:33.574]  - relaying element #4
  [21:15:33.575] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.575] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.575] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.575]  length: 0 (resolved future 4)
  [21:15:33.576] Relaying remaining futures
  [21:15:33.576] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.576] - nx: 4
  [21:15:33.576] - relay: TRUE
  [21:15:33.577] - stdout: TRUE
  [21:15:33.577] - signal: TRUE
  [21:15:33.577] - resignal: FALSE
  [21:15:33.577] - force: TRUE
  [21:15:33.581] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.581] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.581] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.582] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.582] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.582] resolve() on list ... DONE
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 2
  
  [21:15:33.583] getGlobalsAndPackages() ...
  [21:15:33.583] Searching for globals...
  [21:15:33.585] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.586] Searching for globals ... DONE
  [21:15:33.586] Resolving globals: FALSE
  [21:15:33.587] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.587] - globals: [1] 'x'
  [21:15:33.587] 
  [21:15:33.587] getGlobalsAndPackages() ... DONE
  [21:15:33.589] Packages needed by the future expression (n = 0): <none>
  [21:15:33.589] Packages needed by future strategies (n = 0): <none>
  [21:15:33.593] {
  [21:15:33.593]     {
  [21:15:33.593]         ...future.startTime <- base::Sys.time()
  [21:15:33.593]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.593]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.593]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.593]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.593]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.593]         {
  [21:15:33.593]             {
  [21:15:33.593]                 base::local({
  [21:15:33.593]                   has_future <- base::requireNamespace("future", 
  [21:15:33.593]                     quietly = TRUE)
  [21:15:33.593]                   version <- if (has_future) 
  [21:15:33.593]                     utils::packageVersion("future")
  [21:15:33.593]                   else NULL
  [21:15:33.593]                   if (!has_future || version < "1.8.0") {
  [21:15:33.593]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.593]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.593]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.593]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.593]                         "release", "version")], collapse = " "), 
  [21:15:33.593]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.593]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.593]                       info)
  [21:15:33.593]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.593]                     if (!has_future) {
  [21:15:33.593]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.593]                         info)
  [21:15:33.593]                     }
  [21:15:33.593]                     else {
  [21:15:33.593]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.593]                         info, version)
  [21:15:33.593]                     }
  [21:15:33.593]                     base::stop(msg)
  [21:15:33.593]                   }
  [21:15:33.593]                 })
  [21:15:33.593]             }
  [21:15:33.593]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.593]         }
  [21:15:33.593]     }
  [21:15:33.593]     if (base::is.na(TRUE)) {
  [21:15:33.593]     }
  [21:15:33.593]     else {
  [21:15:33.593]         if (TRUE) {
  [21:15:33.593]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.593]                 open = "w")
  [21:15:33.593]         }
  [21:15:33.593]         else {
  [21:15:33.593]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.593]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.593]         }
  [21:15:33.593]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.593]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.593]             base::sink(type = "output", split = FALSE)
  [21:15:33.593]             base::close(...future.stdout)
  [21:15:33.593]         }, add = TRUE)
  [21:15:33.593]     }
  [21:15:33.593]     ...future.frame <- base::sys.nframe()
  [21:15:33.593]     ...future.conditions <- base::list()
  [21:15:33.593]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.593]     ...future.result <- base::tryCatch({
  [21:15:33.593]         base::withCallingHandlers({
  [21:15:33.593]             ...future.value <- base::withVisible(base::local({
  [21:15:33.593]                 sample(x, size = 1L)
  [21:15:33.593]             }))
  [21:15:33.593]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.593]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.593]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.593]                 version = "1.8")
  [21:15:33.593]         }, condition = base::local({
  [21:15:33.593]             c <- base::c
  [21:15:33.593]             inherits <- base::inherits
  [21:15:33.593]             invokeRestart <- base::invokeRestart
  [21:15:33.593]             length <- base::length
  [21:15:33.593]             list <- base::list
  [21:15:33.593]             seq.int <- base::seq.int
  [21:15:33.593]             signalCondition <- base::signalCondition
  [21:15:33.593]             sys.calls <- base::sys.calls
  [21:15:33.593]             Sys.time <- base::Sys.time
  [21:15:33.593]             `[[` <- base::`[[`
  [21:15:33.593]             `+` <- base::`+`
  [21:15:33.593]             `<<-` <- base::`<<-`
  [21:15:33.593]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.593]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.593]                   3L)]
  [21:15:33.593]             }
  [21:15:33.593]             function(cond) {
  [21:15:33.593]                 if (inherits(cond, "error")) {
  [21:15:33.593]                   sessionInformation <- function() {
  [21:15:33.593]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.593]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.593]                       search = base::search(), system = base::Sys.info())
  [21:15:33.593]                   }
  [21:15:33.593]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.593]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.593]                     cond$call), session = sessionInformation(), 
  [21:15:33.593]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.593]                   signalCondition(cond)
  [21:15:33.593]                 }
  [21:15:33.593]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.593]                 ))) {
  [21:15:33.593]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.593]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.593]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.593]                   if (!signal) {
  [21:15:33.593]                     muffleCondition <- function (cond) 
  [21:15:33.593]                     {
  [21:15:33.593]                       inherits <- base::inherits
  [21:15:33.593]                       invokeRestart <- base::invokeRestart
  [21:15:33.593]                       muffled <- FALSE
  [21:15:33.593]                       if (inherits(cond, "message")) {
  [21:15:33.593]                         invokeRestart("muffleMessage")
  [21:15:33.593]                         muffled <- TRUE
  [21:15:33.593]                       }
  [21:15:33.593]                       else if (inherits(cond, "warning")) {
  [21:15:33.593]                         invokeRestart("muffleWarning")
  [21:15:33.593]                         muffled <- TRUE
  [21:15:33.593]                       }
  [21:15:33.593]                       else if (inherits(cond, "condition")) {
  [21:15:33.593]                         computeRestarts <- base::computeRestarts
  [21:15:33.593]                         grepl <- base::grepl
  [21:15:33.593]                         is.null <- base::is.null
  [21:15:33.593]                         restarts <- computeRestarts(cond)
  [21:15:33.593]                         for (restart in restarts) {
  [21:15:33.593]                           name <- restart$name
  [21:15:33.593]                           if (is.null(name)) 
  [21:15:33.593]                             next
  [21:15:33.593]                           if (!grepl("^muffle", name)) 
  [21:15:33.593]                             next
  [21:15:33.593]                           invokeRestart(restart)
  [21:15:33.593]                           muffled <- TRUE
  [21:15:33.593]                           break
  [21:15:33.593]                         }
  [21:15:33.593]                       }
  [21:15:33.593]                       invisible(muffled)
  [21:15:33.593]                     }
  [21:15:33.593]                     muffleCondition(cond)
  [21:15:33.593]                   }
  [21:15:33.593]                 }
  [21:15:33.593]             }
  [21:15:33.593]         }))
  [21:15:33.593]     }, error = function(ex) {
  [21:15:33.593]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.593]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.593]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.593]     }, finally = {
  [21:15:33.593]         {
  [21:15:33.593]             NULL
  [21:15:33.593]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.593]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.593]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.593]                 label = NULL, ...) 
  [21:15:33.593]             {
  [21:15:33.593]                 if (substitute) 
  [21:15:33.593]                   expr <- substitute(expr)
  [21:15:33.593]                 local <- as.logical(local)
  [21:15:33.593]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.593]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.593]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.593]                   label = label, ...)
  [21:15:33.593]                 if (!future$lazy) 
  [21:15:33.593]                   future <- run(future)
  [21:15:33.593]                 invisible(future)
  [21:15:33.593]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.593]         }
  [21:15:33.593]         base::options(...future.oldOptions)
  [21:15:33.593]     })
  [21:15:33.593]     Sys.time
  [21:15:33.593]     if (base::is.na(TRUE)) {
  [21:15:33.593]     }
  [21:15:33.593]     else {
  [21:15:33.593]         base::sink(type = "output", split = FALSE)
  [21:15:33.593]         if (TRUE) {
  [21:15:33.593]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.593]         }
  [21:15:33.593]         else {
  [21:15:33.593]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.593]         }
  [21:15:33.593]         base::close(...future.stdout)
  [21:15:33.593]         ...future.stdout <- NULL
  [21:15:33.593]     }
  [21:15:33.593]     ...future.result$conditions <- ...future.conditions
  [21:15:33.593]     ...future.result
  [21:15:33.593] }
  [21:15:33.598] plan(): Setting new future strategy stack:
  [21:15:33.598] List of future strategies:
  [21:15:33.598] 1. sequential:
  [21:15:33.598]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.598]    - tweaked: FALSE
  [21:15:33.598]    - call: NULL
  [21:15:33.599] plan(): nbrOfWorkers() = 1
  [21:15:33.600] plan(): Setting new future strategy stack:
  [21:15:33.601] List of future strategies:
  [21:15:33.601] 1. sequential:
  [21:15:33.601]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.601]    - tweaked: FALSE
  [21:15:33.601]    - call: plan(strategy)
  [21:15:33.601] plan(): nbrOfWorkers() = 1
  [21:15:33.602] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-325728'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334abd97c0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.606] getGlobalsAndPackages() ...
  [21:15:33.607] Searching for globals...
  [21:15:33.609] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.609] Searching for globals ... DONE
  [21:15:33.609] Resolving globals: FALSE
  [21:15:33.619] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.620] - globals: [1] 'x'
  [21:15:33.620] 
  [21:15:33.620] getGlobalsAndPackages() ... DONE
  [21:15:33.622] Packages needed by the future expression (n = 0): <none>
  [21:15:33.622] Packages needed by future strategies (n = 0): <none>
  [21:15:33.628] {
  [21:15:33.628]     {
  [21:15:33.628]         ...future.startTime <- base::Sys.time()
  [21:15:33.628]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.628]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.628]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.628]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.628]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.628]         {
  [21:15:33.628]             {
  [21:15:33.628]                 base::local({
  [21:15:33.628]                   has_future <- base::requireNamespace("future", 
  [21:15:33.628]                     quietly = TRUE)
  [21:15:33.628]                   version <- if (has_future) 
  [21:15:33.628]                     utils::packageVersion("future")
  [21:15:33.628]                   else NULL
  [21:15:33.628]                   if (!has_future || version < "1.8.0") {
  [21:15:33.628]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.628]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.628]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.628]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.628]                         "release", "version")], collapse = " "), 
  [21:15:33.628]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.628]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.628]                       info)
  [21:15:33.628]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.628]                     if (!has_future) {
  [21:15:33.628]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.628]                         info)
  [21:15:33.628]                     }
  [21:15:33.628]                     else {
  [21:15:33.628]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.628]                         info, version)
  [21:15:33.628]                     }
  [21:15:33.628]                     base::stop(msg)
  [21:15:33.628]                   }
  [21:15:33.628]                 })
  [21:15:33.628]             }
  [21:15:33.628]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.628]         }
  [21:15:33.628]     }
  [21:15:33.628]     if (base::is.na(TRUE)) {
  [21:15:33.628]     }
  [21:15:33.628]     else {
  [21:15:33.628]         if (TRUE) {
  [21:15:33.628]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.628]                 open = "w")
  [21:15:33.628]         }
  [21:15:33.628]         else {
  [21:15:33.628]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.628]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.628]         }
  [21:15:33.628]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.628]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.628]             base::sink(type = "output", split = FALSE)
  [21:15:33.628]             base::close(...future.stdout)
  [21:15:33.628]         }, add = TRUE)
  [21:15:33.628]     }
  [21:15:33.628]     ...future.frame <- base::sys.nframe()
  [21:15:33.628]     ...future.conditions <- base::list()
  [21:15:33.628]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.628]     ...future.result <- base::tryCatch({
  [21:15:33.628]         base::withCallingHandlers({
  [21:15:33.628]             ...future.value <- base::withVisible(base::local({
  [21:15:33.628]                 sample(x, size = 1L)
  [21:15:33.628]             }))
  [21:15:33.628]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.628]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.628]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.628]                 version = "1.8")
  [21:15:33.628]         }, condition = base::local({
  [21:15:33.628]             c <- base::c
  [21:15:33.628]             inherits <- base::inherits
  [21:15:33.628]             invokeRestart <- base::invokeRestart
  [21:15:33.628]             length <- base::length
  [21:15:33.628]             list <- base::list
  [21:15:33.628]             seq.int <- base::seq.int
  [21:15:33.628]             signalCondition <- base::signalCondition
  [21:15:33.628]             sys.calls <- base::sys.calls
  [21:15:33.628]             Sys.time <- base::Sys.time
  [21:15:33.628]             `[[` <- base::`[[`
  [21:15:33.628]             `+` <- base::`+`
  [21:15:33.628]             `<<-` <- base::`<<-`
  [21:15:33.628]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.628]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.628]                   3L)]
  [21:15:33.628]             }
  [21:15:33.628]             function(cond) {
  [21:15:33.628]                 if (inherits(cond, "error")) {
  [21:15:33.628]                   sessionInformation <- function() {
  [21:15:33.628]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.628]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.628]                       search = base::search(), system = base::Sys.info())
  [21:15:33.628]                   }
  [21:15:33.628]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.628]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.628]                     cond$call), session = sessionInformation(), 
  [21:15:33.628]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.628]                   signalCondition(cond)
  [21:15:33.628]                 }
  [21:15:33.628]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.628]                 ))) {
  [21:15:33.628]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.628]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.628]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.628]                   if (!signal) {
  [21:15:33.628]                     muffleCondition <- function (cond) 
  [21:15:33.628]                     {
  [21:15:33.628]                       inherits <- base::inherits
  [21:15:33.628]                       invokeRestart <- base::invokeRestart
  [21:15:33.628]                       muffled <- FALSE
  [21:15:33.628]                       if (inherits(cond, "message")) {
  [21:15:33.628]                         invokeRestart("muffleMessage")
  [21:15:33.628]                         muffled <- TRUE
  [21:15:33.628]                       }
  [21:15:33.628]                       else if (inherits(cond, "warning")) {
  [21:15:33.628]                         invokeRestart("muffleWarning")
  [21:15:33.628]                         muffled <- TRUE
  [21:15:33.628]                       }
  [21:15:33.628]                       else if (inherits(cond, "condition")) {
  [21:15:33.628]                         computeRestarts <- base::computeRestarts
  [21:15:33.628]                         grepl <- base::grepl
  [21:15:33.628]                         is.null <- base::is.null
  [21:15:33.628]                         restarts <- computeRestarts(cond)
  [21:15:33.628]                         for (restart in restarts) {
  [21:15:33.628]                           name <- restart$name
  [21:15:33.628]                           if (is.null(name)) 
  [21:15:33.628]                             next
  [21:15:33.628]                           if (!grepl("^muffle", name)) 
  [21:15:33.628]                             next
  [21:15:33.628]                           invokeRestart(restart)
  [21:15:33.628]                           muffled <- TRUE
  [21:15:33.628]                           break
  [21:15:33.628]                         }
  [21:15:33.628]                       }
  [21:15:33.628]                       invisible(muffled)
  [21:15:33.628]                     }
  [21:15:33.628]                     muffleCondition(cond)
  [21:15:33.628]                   }
  [21:15:33.628]                 }
  [21:15:33.628]             }
  [21:15:33.628]         }))
  [21:15:33.628]     }, error = function(ex) {
  [21:15:33.628]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.628]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.628]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.628]     }, finally = {
  [21:15:33.628]         {
  [21:15:33.628]             NULL
  [21:15:33.628]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.628]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.628]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.628]                 label = NULL, ...) 
  [21:15:33.628]             {
  [21:15:33.628]                 if (substitute) 
  [21:15:33.628]                   expr <- substitute(expr)
  [21:15:33.628]                 local <- as.logical(local)
  [21:15:33.628]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.628]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.628]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.628]                   label = label, ...)
  [21:15:33.628]                 if (!future$lazy) 
  [21:15:33.628]                   future <- run(future)
  [21:15:33.628]                 invisible(future)
  [21:15:33.628]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.628]         }
  [21:15:33.628]         base::options(...future.oldOptions)
  [21:15:33.628]     })
  [21:15:33.628]     Sys.time
  [21:15:33.628]     if (base::is.na(TRUE)) {
  [21:15:33.628]     }
  [21:15:33.628]     else {
  [21:15:33.628]         base::sink(type = "output", split = FALSE)
  [21:15:33.628]         if (TRUE) {
  [21:15:33.628]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.628]         }
  [21:15:33.628]         else {
  [21:15:33.628]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.628]         }
  [21:15:33.628]         base::close(...future.stdout)
  [21:15:33.628]         ...future.stdout <- NULL
  [21:15:33.628]     }
  [21:15:33.628]     ...future.result$conditions <- ...future.conditions
  [21:15:33.628]     ...future.result
  [21:15:33.628] }
  [21:15:33.632] plan(): Setting new future strategy stack:
  [21:15:33.633] List of future strategies:
  [21:15:33.633] 1. sequential:
  [21:15:33.633]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.633]    - tweaked: FALSE
  [21:15:33.633]    - call: NULL
  [21:15:33.634] plan(): nbrOfWorkers() = 1
  [21:15:33.635] plan(): Setting new future strategy stack:
  [21:15:33.635] List of future strategies:
  [21:15:33.635] 1. sequential:
  [21:15:33.635]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.635]    - tweaked: FALSE
  [21:15:33.635]    - call: plan(strategy)
  [21:15:33.636] plan(): nbrOfWorkers() = 1
  [21:15:33.636] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-299671'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334abd97c0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.638] getGlobalsAndPackages() ...
  [21:15:33.638] Searching for globals...
  [21:15:33.640] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.640] Searching for globals ... DONE
  [21:15:33.640] Resolving globals: FALSE
  [21:15:33.641] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.642] - globals: [1] 'x'
  [21:15:33.642] 
  [21:15:33.642] getGlobalsAndPackages() ... DONE
  [21:15:33.644] Packages needed by the future expression (n = 0): <none>
  [21:15:33.645] Packages needed by future strategies (n = 0): <none>
  [21:15:33.649] {
  [21:15:33.649]     {
  [21:15:33.649]         ...future.startTime <- base::Sys.time()
  [21:15:33.649]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.649]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.649]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.649]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.649]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.649]         {
  [21:15:33.649]             {
  [21:15:33.649]                 base::local({
  [21:15:33.649]                   has_future <- base::requireNamespace("future", 
  [21:15:33.649]                     quietly = TRUE)
  [21:15:33.649]                   version <- if (has_future) 
  [21:15:33.649]                     utils::packageVersion("future")
  [21:15:33.649]                   else NULL
  [21:15:33.649]                   if (!has_future || version < "1.8.0") {
  [21:15:33.649]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.649]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.649]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.649]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.649]                         "release", "version")], collapse = " "), 
  [21:15:33.649]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.649]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.649]                       info)
  [21:15:33.649]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.649]                     if (!has_future) {
  [21:15:33.649]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.649]                         info)
  [21:15:33.649]                     }
  [21:15:33.649]                     else {
  [21:15:33.649]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.649]                         info, version)
  [21:15:33.649]                     }
  [21:15:33.649]                     base::stop(msg)
  [21:15:33.649]                   }
  [21:15:33.649]                 })
  [21:15:33.649]             }
  [21:15:33.649]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.649]         }
  [21:15:33.649]     }
  [21:15:33.649]     if (base::is.na(TRUE)) {
  [21:15:33.649]     }
  [21:15:33.649]     else {
  [21:15:33.649]         if (TRUE) {
  [21:15:33.649]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.649]                 open = "w")
  [21:15:33.649]         }
  [21:15:33.649]         else {
  [21:15:33.649]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.649]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.649]         }
  [21:15:33.649]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.649]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.649]             base::sink(type = "output", split = FALSE)
  [21:15:33.649]             base::close(...future.stdout)
  [21:15:33.649]         }, add = TRUE)
  [21:15:33.649]     }
  [21:15:33.649]     ...future.frame <- base::sys.nframe()
  [21:15:33.649]     ...future.conditions <- base::list()
  [21:15:33.649]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.649]     ...future.result <- base::tryCatch({
  [21:15:33.649]         base::withCallingHandlers({
  [21:15:33.649]             ...future.value <- base::withVisible(base::local({
  [21:15:33.649]                 sample(x, size = 1L)
  [21:15:33.649]             }))
  [21:15:33.649]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.649]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.649]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.649]                 version = "1.8")
  [21:15:33.649]         }, condition = base::local({
  [21:15:33.649]             c <- base::c
  [21:15:33.649]             inherits <- base::inherits
  [21:15:33.649]             invokeRestart <- base::invokeRestart
  [21:15:33.649]             length <- base::length
  [21:15:33.649]             list <- base::list
  [21:15:33.649]             seq.int <- base::seq.int
  [21:15:33.649]             signalCondition <- base::signalCondition
  [21:15:33.649]             sys.calls <- base::sys.calls
  [21:15:33.649]             Sys.time <- base::Sys.time
  [21:15:33.649]             `[[` <- base::`[[`
  [21:15:33.649]             `+` <- base::`+`
  [21:15:33.649]             `<<-` <- base::`<<-`
  [21:15:33.649]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.649]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.649]                   3L)]
  [21:15:33.649]             }
  [21:15:33.649]             function(cond) {
  [21:15:33.649]                 if (inherits(cond, "error")) {
  [21:15:33.649]                   sessionInformation <- function() {
  [21:15:33.649]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.649]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.649]                       search = base::search(), system = base::Sys.info())
  [21:15:33.649]                   }
  [21:15:33.649]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.649]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.649]                     cond$call), session = sessionInformation(), 
  [21:15:33.649]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.649]                   signalCondition(cond)
  [21:15:33.649]                 }
  [21:15:33.649]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.649]                 ))) {
  [21:15:33.649]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.649]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.649]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.649]                   if (!signal) {
  [21:15:33.649]                     muffleCondition <- function (cond) 
  [21:15:33.649]                     {
  [21:15:33.649]                       inherits <- base::inherits
  [21:15:33.649]                       invokeRestart <- base::invokeRestart
  [21:15:33.649]                       muffled <- FALSE
  [21:15:33.649]                       if (inherits(cond, "message")) {
  [21:15:33.649]                         invokeRestart("muffleMessage")
  [21:15:33.649]                         muffled <- TRUE
  [21:15:33.649]                       }
  [21:15:33.649]                       else if (inherits(cond, "warning")) {
  [21:15:33.649]                         invokeRestart("muffleWarning")
  [21:15:33.649]                         muffled <- TRUE
  [21:15:33.649]                       }
  [21:15:33.649]                       else if (inherits(cond, "condition")) {
  [21:15:33.649]                         computeRestarts <- base::computeRestarts
  [21:15:33.649]                         grepl <- base::grepl
  [21:15:33.649]                         is.null <- base::is.null
  [21:15:33.649]                         restarts <- computeRestarts(cond)
  [21:15:33.649]                         for (restart in restarts) {
  [21:15:33.649]                           name <- restart$name
  [21:15:33.649]                           if (is.null(name)) 
  [21:15:33.649]                             next
  [21:15:33.649]                           if (!grepl("^muffle", name)) 
  [21:15:33.649]                             next
  [21:15:33.649]                           invokeRestart(restart)
  [21:15:33.649]                           muffled <- TRUE
  [21:15:33.649]                           break
  [21:15:33.649]                         }
  [21:15:33.649]                       }
  [21:15:33.649]                       invisible(muffled)
  [21:15:33.649]                     }
  [21:15:33.649]                     muffleCondition(cond)
  [21:15:33.649]                   }
  [21:15:33.649]                 }
  [21:15:33.649]             }
  [21:15:33.649]         }))
  [21:15:33.649]     }, error = function(ex) {
  [21:15:33.649]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.649]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.649]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.649]     }, finally = {
  [21:15:33.649]         {
  [21:15:33.649]             NULL
  [21:15:33.649]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.649]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.649]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.649]                 label = NULL, ...) 
  [21:15:33.649]             {
  [21:15:33.649]                 if (substitute) 
  [21:15:33.649]                   expr <- substitute(expr)
  [21:15:33.649]                 local <- as.logical(local)
  [21:15:33.649]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.649]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.649]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.649]                   label = label, ...)
  [21:15:33.649]                 if (!future$lazy) 
  [21:15:33.649]                   future <- run(future)
  [21:15:33.649]                 invisible(future)
  [21:15:33.649]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.649]         }
  [21:15:33.649]         base::options(...future.oldOptions)
  [21:15:33.649]     })
  [21:15:33.649]     Sys.time
  [21:15:33.649]     if (base::is.na(TRUE)) {
  [21:15:33.649]     }
  [21:15:33.649]     else {
  [21:15:33.649]         base::sink(type = "output", split = FALSE)
  [21:15:33.649]         if (TRUE) {
  [21:15:33.649]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.649]         }
  [21:15:33.649]         else {
  [21:15:33.649]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.649]         }
  [21:15:33.649]         base::close(...future.stdout)
  [21:15:33.649]         ...future.stdout <- NULL
  [21:15:33.649]     }
  [21:15:33.649]     ...future.result$conditions <- ...future.conditions
  [21:15:33.649]     ...future.result
  [21:15:33.649] }
  [21:15:33.654] plan(): Setting new future strategy stack:
  [21:15:33.655] List of future strategies:
  [21:15:33.655] 1. sequential:
  [21:15:33.655]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.655]    - tweaked: FALSE
  [21:15:33.655]    - call: NULL
  [21:15:33.656] plan(): nbrOfWorkers() = 1
  [21:15:33.657] plan(): Setting new future strategy stack:
  [21:15:33.657] List of future strategies:
  [21:15:33.657] 1. sequential:
  [21:15:33.657]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.657]    - tweaked: FALSE
  [21:15:33.657]    - call: plan(strategy)
  [21:15:33.658] plan(): nbrOfWorkers() = 1
  [21:15:33.658] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-174585'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334abd97c0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.660] getGlobalsAndPackages() ...
  [21:15:33.660] Searching for globals...
  [21:15:33.663] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.664] Searching for globals ... DONE
  [21:15:33.664] Resolving globals: FALSE
  [21:15:33.665] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.665] - globals: [1] 'x'
  [21:15:33.665] 
  [21:15:33.665] getGlobalsAndPackages() ... DONE
  [21:15:33.667] Packages needed by the future expression (n = 0): <none>
  [21:15:33.667] Packages needed by future strategies (n = 0): <none>
  [21:15:33.672] {
  [21:15:33.672]     {
  [21:15:33.672]         ...future.startTime <- base::Sys.time()
  [21:15:33.672]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.672]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.672]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.672]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.672]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.672]         {
  [21:15:33.672]             {
  [21:15:33.672]                 base::local({
  [21:15:33.672]                   has_future <- base::requireNamespace("future", 
  [21:15:33.672]                     quietly = TRUE)
  [21:15:33.672]                   version <- if (has_future) 
  [21:15:33.672]                     utils::packageVersion("future")
  [21:15:33.672]                   else NULL
  [21:15:33.672]                   if (!has_future || version < "1.8.0") {
  [21:15:33.672]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.672]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.672]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.672]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.672]                         "release", "version")], collapse = " "), 
  [21:15:33.672]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.672]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.672]                       info)
  [21:15:33.672]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.672]                     if (!has_future) {
  [21:15:33.672]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.672]                         info)
  [21:15:33.672]                     }
  [21:15:33.672]                     else {
  [21:15:33.672]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.672]                         info, version)
  [21:15:33.672]                     }
  [21:15:33.672]                     base::stop(msg)
  [21:15:33.672]                   }
  [21:15:33.672]                 })
  [21:15:33.672]             }
  [21:15:33.672]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.672]         }
  [21:15:33.672]     }
  [21:15:33.672]     if (base::is.na(TRUE)) {
  [21:15:33.672]     }
  [21:15:33.672]     else {
  [21:15:33.672]         if (TRUE) {
  [21:15:33.672]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.672]                 open = "w")
  [21:15:33.672]         }
  [21:15:33.672]         else {
  [21:15:33.672]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.672]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.672]         }
  [21:15:33.672]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.672]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.672]             base::sink(type = "output", split = FALSE)
  [21:15:33.672]             base::close(...future.stdout)
  [21:15:33.672]         }, add = TRUE)
  [21:15:33.672]     }
  [21:15:33.672]     ...future.frame <- base::sys.nframe()
  [21:15:33.672]     ...future.conditions <- base::list()
  [21:15:33.672]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.672]     ...future.result <- base::tryCatch({
  [21:15:33.672]         base::withCallingHandlers({
  [21:15:33.672]             ...future.value <- base::withVisible(base::local({
  [21:15:33.672]                 sample(x, size = 1L)
  [21:15:33.672]             }))
  [21:15:33.672]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.672]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.672]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.672]                 version = "1.8")
  [21:15:33.672]         }, condition = base::local({
  [21:15:33.672]             c <- base::c
  [21:15:33.672]             inherits <- base::inherits
  [21:15:33.672]             invokeRestart <- base::invokeRestart
  [21:15:33.672]             length <- base::length
  [21:15:33.672]             list <- base::list
  [21:15:33.672]             seq.int <- base::seq.int
  [21:15:33.672]             signalCondition <- base::signalCondition
  [21:15:33.672]             sys.calls <- base::sys.calls
  [21:15:33.672]             Sys.time <- base::Sys.time
  [21:15:33.672]             `[[` <- base::`[[`
  [21:15:33.672]             `+` <- base::`+`
  [21:15:33.672]             `<<-` <- base::`<<-`
  [21:15:33.672]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.672]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.672]                   3L)]
  [21:15:33.672]             }
  [21:15:33.672]             function(cond) {
  [21:15:33.672]                 if (inherits(cond, "error")) {
  [21:15:33.672]                   sessionInformation <- function() {
  [21:15:33.672]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.672]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.672]                       search = base::search(), system = base::Sys.info())
  [21:15:33.672]                   }
  [21:15:33.672]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.672]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.672]                     cond$call), session = sessionInformation(), 
  [21:15:33.672]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.672]                   signalCondition(cond)
  [21:15:33.672]                 }
  [21:15:33.672]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.672]                 ))) {
  [21:15:33.672]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.672]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.672]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.672]                   if (!signal) {
  [21:15:33.672]                     muffleCondition <- function (cond) 
  [21:15:33.672]                     {
  [21:15:33.672]                       inherits <- base::inherits
  [21:15:33.672]                       invokeRestart <- base::invokeRestart
  [21:15:33.672]                       muffled <- FALSE
  [21:15:33.672]                       if (inherits(cond, "message")) {
  [21:15:33.672]                         invokeRestart("muffleMessage")
  [21:15:33.672]                         muffled <- TRUE
  [21:15:33.672]                       }
  [21:15:33.672]                       else if (inherits(cond, "warning")) {
  [21:15:33.672]                         invokeRestart("muffleWarning")
  [21:15:33.672]                         muffled <- TRUE
  [21:15:33.672]                       }
  [21:15:33.672]                       else if (inherits(cond, "condition")) {
  [21:15:33.672]                         computeRestarts <- base::computeRestarts
  [21:15:33.672]                         grepl <- base::grepl
  [21:15:33.672]                         is.null <- base::is.null
  [21:15:33.672]                         restarts <- computeRestarts(cond)
  [21:15:33.672]                         for (restart in restarts) {
  [21:15:33.672]                           name <- restart$name
  [21:15:33.672]                           if (is.null(name)) 
  [21:15:33.672]                             next
  [21:15:33.672]                           if (!grepl("^muffle", name)) 
  [21:15:33.672]                             next
  [21:15:33.672]                           invokeRestart(restart)
  [21:15:33.672]                           muffled <- TRUE
  [21:15:33.672]                           break
  [21:15:33.672]                         }
  [21:15:33.672]                       }
  [21:15:33.672]                       invisible(muffled)
  [21:15:33.672]                     }
  [21:15:33.672]                     muffleCondition(cond)
  [21:15:33.672]                   }
  [21:15:33.672]                 }
  [21:15:33.672]             }
  [21:15:33.672]         }))
  [21:15:33.672]     }, error = function(ex) {
  [21:15:33.672]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.672]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.672]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.672]     }, finally = {
  [21:15:33.672]         {
  [21:15:33.672]             NULL
  [21:15:33.672]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.672]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.672]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.672]                 label = NULL, ...) 
  [21:15:33.672]             {
  [21:15:33.672]                 if (substitute) 
  [21:15:33.672]                   expr <- substitute(expr)
  [21:15:33.672]                 local <- as.logical(local)
  [21:15:33.672]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.672]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.672]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.672]                   label = label, ...)
  [21:15:33.672]                 if (!future$lazy) 
  [21:15:33.672]                   future <- run(future)
  [21:15:33.672]                 invisible(future)
  [21:15:33.672]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.672]         }
  [21:15:33.672]         base::options(...future.oldOptions)
  [21:15:33.672]     })
  [21:15:33.672]     Sys.time
  [21:15:33.672]     if (base::is.na(TRUE)) {
  [21:15:33.672]     }
  [21:15:33.672]     else {
  [21:15:33.672]         base::sink(type = "output", split = FALSE)
  [21:15:33.672]         if (TRUE) {
  [21:15:33.672]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.672]         }
  [21:15:33.672]         else {
  [21:15:33.672]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.672]         }
  [21:15:33.672]         base::close(...future.stdout)
  [21:15:33.672]         ...future.stdout <- NULL
  [21:15:33.672]     }
  [21:15:33.672]     ...future.result$conditions <- ...future.conditions
  [21:15:33.672]     ...future.result
  [21:15:33.672] }
  [21:15:33.677] plan(): Setting new future strategy stack:
  [21:15:33.677] List of future strategies:
  [21:15:33.677] 1. sequential:
  [21:15:33.677]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.677]    - tweaked: FALSE
  [21:15:33.677]    - call: NULL
  [21:15:33.678] plan(): nbrOfWorkers() = 1
  [21:15:33.679] plan(): Setting new future strategy stack:
  [21:15:33.679] List of future strategies:
  [21:15:33.679] 1. sequential:
  [21:15:33.679]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.679]    - tweaked: FALSE
  [21:15:33.679]    - call: plan(strategy)
  [21:15:33.680] plan(): nbrOfWorkers() = 1
  [21:15:33.681] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-922351'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334abd97c0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.682] resolve() on list ...
  [21:15:33.683]  recursive: 0
  [21:15:33.683]  length: 4
  [21:15:33.683] 
  [21:15:33.683] Future #1
  [21:15:33.684] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.684] - nx: 4
  [21:15:33.684] - relay: TRUE
  [21:15:33.687] - stdout: TRUE
  [21:15:33.688] - signal: TRUE
  [21:15:33.688] - resignal: FALSE
  [21:15:33.688] - force: TRUE
  [21:15:33.688] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.689] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.689]  - until=1
  [21:15:33.689]  - relaying element #1
  [21:15:33.690] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.690] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.690] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.690]  length: 3 (resolved future 1)
  [21:15:33.691] Future #2
  [21:15:33.691] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.691] - nx: 4
  [21:15:33.692] - relay: TRUE
  [21:15:33.692] - stdout: TRUE
  [21:15:33.692] - signal: TRUE
  [21:15:33.692] - resignal: FALSE
  [21:15:33.693] - force: TRUE
  [21:15:33.693] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.693] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.693]  - until=2
  [21:15:33.693]  - relaying element #2
  [21:15:33.694] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.694] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.695] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.695]  length: 2 (resolved future 2)
  [21:15:33.695] Future #3
  [21:15:33.696] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.696] - nx: 4
  [21:15:33.696] - relay: TRUE
  [21:15:33.696] - stdout: TRUE
  [21:15:33.697] - signal: TRUE
  [21:15:33.697] - resignal: FALSE
  [21:15:33.697] - force: TRUE
  [21:15:33.697] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.698] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.698]  - until=3
  [21:15:33.698]  - relaying element #3
  [21:15:33.699] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.699] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.699] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.699]  length: 1 (resolved future 3)
  [21:15:33.700] Future #4
  [21:15:33.700] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.700] - nx: 4
  [21:15:33.700] - relay: TRUE
  [21:15:33.701] - stdout: TRUE
  [21:15:33.701] - signal: TRUE
  [21:15:33.701] - resignal: FALSE
  [21:15:33.701] - force: TRUE
  [21:15:33.702] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.702] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.702]  - until=4
  [21:15:33.702]  - relaying element #4
  [21:15:33.703] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.703] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.703] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.704]  length: 0 (resolved future 4)
  [21:15:33.704] Relaying remaining futures
  [21:15:33.704] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.704] - nx: 4
  [21:15:33.705] - relay: TRUE
  [21:15:33.705] - stdout: TRUE
  [21:15:33.705] - signal: TRUE
  [21:15:33.705] - resignal: FALSE
  [21:15:33.705] - force: TRUE
  [21:15:33.706] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.706] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.706] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.707] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.707] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.707] resolve() on list ... DONE
  [[1]]
  [1] 0
  
  [[2]]
  [1] 2
  
  [[3]]
  [1] 2
  
  [[4]]
  [1] 0
  
  [21:15:33.708] getGlobalsAndPackages() ...
  [21:15:33.709] Searching for globals...
  [21:15:33.710] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.711] Searching for globals ... DONE
  [21:15:33.711] Resolving globals: FALSE
  [21:15:33.712] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.712] - globals: [1] 'x'
  [21:15:33.712] 
  [21:15:33.713] getGlobalsAndPackages() ... DONE
  [21:15:33.714] Packages needed by the future expression (n = 0): <none>
  [21:15:33.715] Packages needed by future strategies (n = 0): <none>
  [21:15:33.719] {
  [21:15:33.719]     {
  [21:15:33.719]         ...future.startTime <- base::Sys.time()
  [21:15:33.719]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.719]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.719]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.719]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.719]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.719]         {
  [21:15:33.719]             {
  [21:15:33.719]                 base::local({
  [21:15:33.719]                   has_future <- base::requireNamespace("future", 
  [21:15:33.719]                     quietly = TRUE)
  [21:15:33.719]                   version <- if (has_future) 
  [21:15:33.719]                     utils::packageVersion("future")
  [21:15:33.719]                   else NULL
  [21:15:33.719]                   if (!has_future || version < "1.8.0") {
  [21:15:33.719]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.719]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.719]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.719]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.719]                         "release", "version")], collapse = " "), 
  [21:15:33.719]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.719]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.719]                       info)
  [21:15:33.719]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.719]                     if (!has_future) {
  [21:15:33.719]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.719]                         info)
  [21:15:33.719]                     }
  [21:15:33.719]                     else {
  [21:15:33.719]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.719]                         info, version)
  [21:15:33.719]                     }
  [21:15:33.719]                     base::stop(msg)
  [21:15:33.719]                   }
  [21:15:33.719]                 })
  [21:15:33.719]             }
  [21:15:33.719]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.719]         }
  [21:15:33.719]     }
  [21:15:33.719]     if (base::is.na(TRUE)) {
  [21:15:33.719]     }
  [21:15:33.719]     else {
  [21:15:33.719]         if (TRUE) {
  [21:15:33.719]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.719]                 open = "w")
  [21:15:33.719]         }
  [21:15:33.719]         else {
  [21:15:33.719]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.719]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.719]         }
  [21:15:33.719]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.719]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.719]             base::sink(type = "output", split = FALSE)
  [21:15:33.719]             base::close(...future.stdout)
  [21:15:33.719]         }, add = TRUE)
  [21:15:33.719]     }
  [21:15:33.719]     ...future.frame <- base::sys.nframe()
  [21:15:33.719]     ...future.conditions <- base::list()
  [21:15:33.719]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.719]     ...future.result <- base::tryCatch({
  [21:15:33.719]         base::withCallingHandlers({
  [21:15:33.719]             ...future.value <- base::withVisible(base::local({
  [21:15:33.719]                 sample(x, size = 1L)
  [21:15:33.719]             }))
  [21:15:33.719]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.719]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.719]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.719]                 version = "1.8")
  [21:15:33.719]         }, condition = base::local({
  [21:15:33.719]             c <- base::c
  [21:15:33.719]             inherits <- base::inherits
  [21:15:33.719]             invokeRestart <- base::invokeRestart
  [21:15:33.719]             length <- base::length
  [21:15:33.719]             list <- base::list
  [21:15:33.719]             seq.int <- base::seq.int
  [21:15:33.719]             signalCondition <- base::signalCondition
  [21:15:33.719]             sys.calls <- base::sys.calls
  [21:15:33.719]             Sys.time <- base::Sys.time
  [21:15:33.719]             `[[` <- base::`[[`
  [21:15:33.719]             `+` <- base::`+`
  [21:15:33.719]             `<<-` <- base::`<<-`
  [21:15:33.719]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.719]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.719]                   3L)]
  [21:15:33.719]             }
  [21:15:33.719]             function(cond) {
  [21:15:33.719]                 if (inherits(cond, "error")) {
  [21:15:33.719]                   sessionInformation <- function() {
  [21:15:33.719]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.719]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.719]                       search = base::search(), system = base::Sys.info())
  [21:15:33.719]                   }
  [21:15:33.719]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.719]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.719]                     cond$call), session = sessionInformation(), 
  [21:15:33.719]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.719]                   signalCondition(cond)
  [21:15:33.719]                 }
  [21:15:33.719]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.719]                 ))) {
  [21:15:33.719]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.719]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.719]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.719]                   if (!signal) {
  [21:15:33.719]                     muffleCondition <- function (cond) 
  [21:15:33.719]                     {
  [21:15:33.719]                       inherits <- base::inherits
  [21:15:33.719]                       invokeRestart <- base::invokeRestart
  [21:15:33.719]                       muffled <- FALSE
  [21:15:33.719]                       if (inherits(cond, "message")) {
  [21:15:33.719]                         invokeRestart("muffleMessage")
  [21:15:33.719]                         muffled <- TRUE
  [21:15:33.719]                       }
  [21:15:33.719]                       else if (inherits(cond, "warning")) {
  [21:15:33.719]                         invokeRestart("muffleWarning")
  [21:15:33.719]                         muffled <- TRUE
  [21:15:33.719]                       }
  [21:15:33.719]                       else if (inherits(cond, "condition")) {
  [21:15:33.719]                         computeRestarts <- base::computeRestarts
  [21:15:33.719]                         grepl <- base::grepl
  [21:15:33.719]                         is.null <- base::is.null
  [21:15:33.719]                         restarts <- computeRestarts(cond)
  [21:15:33.719]                         for (restart in restarts) {
  [21:15:33.719]                           name <- restart$name
  [21:15:33.719]                           if (is.null(name)) 
  [21:15:33.719]                             next
  [21:15:33.719]                           if (!grepl("^muffle", name)) 
  [21:15:33.719]                             next
  [21:15:33.719]                           invokeRestart(restart)
  [21:15:33.719]                           muffled <- TRUE
  [21:15:33.719]                           break
  [21:15:33.719]                         }
  [21:15:33.719]                       }
  [21:15:33.719]                       invisible(muffled)
  [21:15:33.719]                     }
  [21:15:33.719]                     muffleCondition(cond)
  [21:15:33.719]                   }
  [21:15:33.719]                 }
  [21:15:33.719]             }
  [21:15:33.719]         }))
  [21:15:33.719]     }, error = function(ex) {
  [21:15:33.719]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.719]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.719]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.719]     }, finally = {
  [21:15:33.719]         {
  [21:15:33.719]             NULL
  [21:15:33.719]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.719]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.719]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.719]                 label = NULL, ...) 
  [21:15:33.719]             {
  [21:15:33.719]                 if (substitute) 
  [21:15:33.719]                   expr <- substitute(expr)
  [21:15:33.719]                 local <- as.logical(local)
  [21:15:33.719]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.719]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.719]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.719]                   label = label, ...)
  [21:15:33.719]                 if (!future$lazy) 
  [21:15:33.719]                   future <- run(future)
  [21:15:33.719]                 invisible(future)
  [21:15:33.719]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.719]         }
  [21:15:33.719]         base::options(...future.oldOptions)
  [21:15:33.719]     })
  [21:15:33.719]     Sys.time
  [21:15:33.719]     if (base::is.na(TRUE)) {
  [21:15:33.719]     }
  [21:15:33.719]     else {
  [21:15:33.719]         base::sink(type = "output", split = FALSE)
  [21:15:33.719]         if (TRUE) {
  [21:15:33.719]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.719]         }
  [21:15:33.719]         else {
  [21:15:33.719]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.719]         }
  [21:15:33.719]         base::close(...future.stdout)
  [21:15:33.719]         ...future.stdout <- NULL
  [21:15:33.719]     }
  [21:15:33.719]     ...future.result$conditions <- ...future.conditions
  [21:15:33.719]     ...future.result
  [21:15:33.719] }
  [21:15:33.724] plan(): Setting new future strategy stack:
  [21:15:33.724] List of future strategies:
  [21:15:33.724] 1. sequential:
  [21:15:33.724]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.724]    - tweaked: FALSE
  [21:15:33.724]    - call: NULL
  [21:15:33.725] plan(): nbrOfWorkers() = 1
  [21:15:33.726] plan(): Setting new future strategy stack:
  [21:15:33.726] List of future strategies:
  [21:15:33.726] 1. sequential:
  [21:15:33.726]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.726]    - tweaked: FALSE
  [21:15:33.726]    - call: plan(strategy)
  [21:15:33.727] plan(): nbrOfWorkers() = 1
  [21:15:33.728] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-798024'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349b773c8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.729] getGlobalsAndPackages() ...
  [21:15:33.730] Searching for globals...
  [21:15:33.732] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.732] Searching for globals ... DONE
  [21:15:33.732] Resolving globals: FALSE
  [21:15:33.733] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.733] - globals: [1] 'x'
  [21:15:33.734] 
  [21:15:33.734] getGlobalsAndPackages() ... DONE
  [21:15:33.736] Packages needed by the future expression (n = 0): <none>
  [21:15:33.736] Packages needed by future strategies (n = 0): <none>
  [21:15:33.740] {
  [21:15:33.740]     {
  [21:15:33.740]         ...future.startTime <- base::Sys.time()
  [21:15:33.740]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.740]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.740]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.740]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.740]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.740]         {
  [21:15:33.740]             {
  [21:15:33.740]                 base::local({
  [21:15:33.740]                   has_future <- base::requireNamespace("future", 
  [21:15:33.740]                     quietly = TRUE)
  [21:15:33.740]                   version <- if (has_future) 
  [21:15:33.740]                     utils::packageVersion("future")
  [21:15:33.740]                   else NULL
  [21:15:33.740]                   if (!has_future || version < "1.8.0") {
  [21:15:33.740]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.740]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.740]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.740]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.740]                         "release", "version")], collapse = " "), 
  [21:15:33.740]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.740]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.740]                       info)
  [21:15:33.740]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.740]                     if (!has_future) {
  [21:15:33.740]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.740]                         info)
  [21:15:33.740]                     }
  [21:15:33.740]                     else {
  [21:15:33.740]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.740]                         info, version)
  [21:15:33.740]                     }
  [21:15:33.740]                     base::stop(msg)
  [21:15:33.740]                   }
  [21:15:33.740]                 })
  [21:15:33.740]             }
  [21:15:33.740]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.740]         }
  [21:15:33.740]     }
  [21:15:33.740]     if (base::is.na(TRUE)) {
  [21:15:33.740]     }
  [21:15:33.740]     else {
  [21:15:33.740]         if (TRUE) {
  [21:15:33.740]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.740]                 open = "w")
  [21:15:33.740]         }
  [21:15:33.740]         else {
  [21:15:33.740]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.740]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.740]         }
  [21:15:33.740]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.740]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.740]             base::sink(type = "output", split = FALSE)
  [21:15:33.740]             base::close(...future.stdout)
  [21:15:33.740]         }, add = TRUE)
  [21:15:33.740]     }
  [21:15:33.740]     ...future.frame <- base::sys.nframe()
  [21:15:33.740]     ...future.conditions <- base::list()
  [21:15:33.740]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.740]     ...future.result <- base::tryCatch({
  [21:15:33.740]         base::withCallingHandlers({
  [21:15:33.740]             ...future.value <- base::withVisible(base::local({
  [21:15:33.740]                 sample(x, size = 1L)
  [21:15:33.740]             }))
  [21:15:33.740]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.740]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.740]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.740]                 version = "1.8")
  [21:15:33.740]         }, condition = base::local({
  [21:15:33.740]             c <- base::c
  [21:15:33.740]             inherits <- base::inherits
  [21:15:33.740]             invokeRestart <- base::invokeRestart
  [21:15:33.740]             length <- base::length
  [21:15:33.740]             list <- base::list
  [21:15:33.740]             seq.int <- base::seq.int
  [21:15:33.740]             signalCondition <- base::signalCondition
  [21:15:33.740]             sys.calls <- base::sys.calls
  [21:15:33.740]             Sys.time <- base::Sys.time
  [21:15:33.740]             `[[` <- base::`[[`
  [21:15:33.740]             `+` <- base::`+`
  [21:15:33.740]             `<<-` <- base::`<<-`
  [21:15:33.740]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.740]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.740]                   3L)]
  [21:15:33.740]             }
  [21:15:33.740]             function(cond) {
  [21:15:33.740]                 if (inherits(cond, "error")) {
  [21:15:33.740]                   sessionInformation <- function() {
  [21:15:33.740]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.740]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.740]                       search = base::search(), system = base::Sys.info())
  [21:15:33.740]                   }
  [21:15:33.740]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.740]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.740]                     cond$call), session = sessionInformation(), 
  [21:15:33.740]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.740]                   signalCondition(cond)
  [21:15:33.740]                 }
  [21:15:33.740]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.740]                 ))) {
  [21:15:33.740]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.740]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.740]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.740]                   if (!signal) {
  [21:15:33.740]                     muffleCondition <- function (cond) 
  [21:15:33.740]                     {
  [21:15:33.740]                       inherits <- base::inherits
  [21:15:33.740]                       invokeRestart <- base::invokeRestart
  [21:15:33.740]                       muffled <- FALSE
  [21:15:33.740]                       if (inherits(cond, "message")) {
  [21:15:33.740]                         invokeRestart("muffleMessage")
  [21:15:33.740]                         muffled <- TRUE
  [21:15:33.740]                       }
  [21:15:33.740]                       else if (inherits(cond, "warning")) {
  [21:15:33.740]                         invokeRestart("muffleWarning")
  [21:15:33.740]                         muffled <- TRUE
  [21:15:33.740]                       }
  [21:15:33.740]                       else if (inherits(cond, "condition")) {
  [21:15:33.740]                         computeRestarts <- base::computeRestarts
  [21:15:33.740]                         grepl <- base::grepl
  [21:15:33.740]                         is.null <- base::is.null
  [21:15:33.740]                         restarts <- computeRestarts(cond)
  [21:15:33.740]                         for (restart in restarts) {
  [21:15:33.740]                           name <- restart$name
  [21:15:33.740]                           if (is.null(name)) 
  [21:15:33.740]                             next
  [21:15:33.740]                           if (!grepl("^muffle", name)) 
  [21:15:33.740]                             next
  [21:15:33.740]                           invokeRestart(restart)
  [21:15:33.740]                           muffled <- TRUE
  [21:15:33.740]                           break
  [21:15:33.740]                         }
  [21:15:33.740]                       }
  [21:15:33.740]                       invisible(muffled)
  [21:15:33.740]                     }
  [21:15:33.740]                     muffleCondition(cond)
  [21:15:33.740]                   }
  [21:15:33.740]                 }
  [21:15:33.740]             }
  [21:15:33.740]         }))
  [21:15:33.740]     }, error = function(ex) {
  [21:15:33.740]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.740]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.740]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.740]     }, finally = {
  [21:15:33.740]         {
  [21:15:33.740]             NULL
  [21:15:33.740]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.740]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.740]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.740]                 label = NULL, ...) 
  [21:15:33.740]             {
  [21:15:33.740]                 if (substitute) 
  [21:15:33.740]                   expr <- substitute(expr)
  [21:15:33.740]                 local <- as.logical(local)
  [21:15:33.740]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.740]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.740]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.740]                   label = label, ...)
  [21:15:33.740]                 if (!future$lazy) 
  [21:15:33.740]                   future <- run(future)
  [21:15:33.740]                 invisible(future)
  [21:15:33.740]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.740]         }
  [21:15:33.740]         base::options(...future.oldOptions)
  [21:15:33.740]     })
  [21:15:33.740]     Sys.time
  [21:15:33.740]     if (base::is.na(TRUE)) {
  [21:15:33.740]     }
  [21:15:33.740]     else {
  [21:15:33.740]         base::sink(type = "output", split = FALSE)
  [21:15:33.740]         if (TRUE) {
  [21:15:33.740]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.740]         }
  [21:15:33.740]         else {
  [21:15:33.740]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.740]         }
  [21:15:33.740]         base::close(...future.stdout)
  [21:15:33.740]         ...future.stdout <- NULL
  [21:15:33.740]     }
  [21:15:33.740]     ...future.result$conditions <- ...future.conditions
  [21:15:33.740]     ...future.result
  [21:15:33.740] }
  [21:15:33.745] plan(): Setting new future strategy stack:
  [21:15:33.745] List of future strategies:
  [21:15:33.745] 1. sequential:
  [21:15:33.745]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.745]    - tweaked: FALSE
  [21:15:33.745]    - call: NULL
  [21:15:33.746] plan(): nbrOfWorkers() = 1
  [21:15:33.747] plan(): Setting new future strategy stack:
  [21:15:33.748] List of future strategies:
  [21:15:33.748] 1. sequential:
  [21:15:33.748]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.748]    - tweaked: FALSE
  [21:15:33.748]    - call: plan(strategy)
  [21:15:33.748] plan(): nbrOfWorkers() = 1
  [21:15:33.749] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-885198'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349b773c8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.751] getGlobalsAndPackages() ...
  [21:15:33.751] Searching for globals...
  [21:15:33.753] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.753] Searching for globals ... DONE
  [21:15:33.754] Resolving globals: FALSE
  [21:15:33.755] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.755] - globals: [1] 'x'
  [21:15:33.758] 
  [21:15:33.759] getGlobalsAndPackages() ... DONE
  [21:15:33.760] Packages needed by the future expression (n = 0): <none>
  [21:15:33.761] Packages needed by future strategies (n = 0): <none>
  [21:15:33.765] {
  [21:15:33.765]     {
  [21:15:33.765]         ...future.startTime <- base::Sys.time()
  [21:15:33.765]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.765]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.765]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.765]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.765]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.765]         {
  [21:15:33.765]             {
  [21:15:33.765]                 base::local({
  [21:15:33.765]                   has_future <- base::requireNamespace("future", 
  [21:15:33.765]                     quietly = TRUE)
  [21:15:33.765]                   version <- if (has_future) 
  [21:15:33.765]                     utils::packageVersion("future")
  [21:15:33.765]                   else NULL
  [21:15:33.765]                   if (!has_future || version < "1.8.0") {
  [21:15:33.765]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.765]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.765]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.765]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.765]                         "release", "version")], collapse = " "), 
  [21:15:33.765]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.765]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.765]                       info)
  [21:15:33.765]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.765]                     if (!has_future) {
  [21:15:33.765]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.765]                         info)
  [21:15:33.765]                     }
  [21:15:33.765]                     else {
  [21:15:33.765]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.765]                         info, version)
  [21:15:33.765]                     }
  [21:15:33.765]                     base::stop(msg)
  [21:15:33.765]                   }
  [21:15:33.765]                 })
  [21:15:33.765]             }
  [21:15:33.765]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.765]         }
  [21:15:33.765]     }
  [21:15:33.765]     if (base::is.na(TRUE)) {
  [21:15:33.765]     }
  [21:15:33.765]     else {
  [21:15:33.765]         if (TRUE) {
  [21:15:33.765]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.765]                 open = "w")
  [21:15:33.765]         }
  [21:15:33.765]         else {
  [21:15:33.765]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.765]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.765]         }
  [21:15:33.765]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.765]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.765]             base::sink(type = "output", split = FALSE)
  [21:15:33.765]             base::close(...future.stdout)
  [21:15:33.765]         }, add = TRUE)
  [21:15:33.765]     }
  [21:15:33.765]     ...future.frame <- base::sys.nframe()
  [21:15:33.765]     ...future.conditions <- base::list()
  [21:15:33.765]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.765]     ...future.result <- base::tryCatch({
  [21:15:33.765]         base::withCallingHandlers({
  [21:15:33.765]             ...future.value <- base::withVisible(base::local({
  [21:15:33.765]                 sample(x, size = 1L)
  [21:15:33.765]             }))
  [21:15:33.765]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.765]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.765]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.765]                 version = "1.8")
  [21:15:33.765]         }, condition = base::local({
  [21:15:33.765]             c <- base::c
  [21:15:33.765]             inherits <- base::inherits
  [21:15:33.765]             invokeRestart <- base::invokeRestart
  [21:15:33.765]             length <- base::length
  [21:15:33.765]             list <- base::list
  [21:15:33.765]             seq.int <- base::seq.int
  [21:15:33.765]             signalCondition <- base::signalCondition
  [21:15:33.765]             sys.calls <- base::sys.calls
  [21:15:33.765]             Sys.time <- base::Sys.time
  [21:15:33.765]             `[[` <- base::`[[`
  [21:15:33.765]             `+` <- base::`+`
  [21:15:33.765]             `<<-` <- base::`<<-`
  [21:15:33.765]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.765]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.765]                   3L)]
  [21:15:33.765]             }
  [21:15:33.765]             function(cond) {
  [21:15:33.765]                 if (inherits(cond, "error")) {
  [21:15:33.765]                   sessionInformation <- function() {
  [21:15:33.765]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.765]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.765]                       search = base::search(), system = base::Sys.info())
  [21:15:33.765]                   }
  [21:15:33.765]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.765]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.765]                     cond$call), session = sessionInformation(), 
  [21:15:33.765]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.765]                   signalCondition(cond)
  [21:15:33.765]                 }
  [21:15:33.765]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.765]                 ))) {
  [21:15:33.765]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.765]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.765]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.765]                   if (!signal) {
  [21:15:33.765]                     muffleCondition <- function (cond) 
  [21:15:33.765]                     {
  [21:15:33.765]                       inherits <- base::inherits
  [21:15:33.765]                       invokeRestart <- base::invokeRestart
  [21:15:33.765]                       muffled <- FALSE
  [21:15:33.765]                       if (inherits(cond, "message")) {
  [21:15:33.765]                         invokeRestart("muffleMessage")
  [21:15:33.765]                         muffled <- TRUE
  [21:15:33.765]                       }
  [21:15:33.765]                       else if (inherits(cond, "warning")) {
  [21:15:33.765]                         invokeRestart("muffleWarning")
  [21:15:33.765]                         muffled <- TRUE
  [21:15:33.765]                       }
  [21:15:33.765]                       else if (inherits(cond, "condition")) {
  [21:15:33.765]                         computeRestarts <- base::computeRestarts
  [21:15:33.765]                         grepl <- base::grepl
  [21:15:33.765]                         is.null <- base::is.null
  [21:15:33.765]                         restarts <- computeRestarts(cond)
  [21:15:33.765]                         for (restart in restarts) {
  [21:15:33.765]                           name <- restart$name
  [21:15:33.765]                           if (is.null(name)) 
  [21:15:33.765]                             next
  [21:15:33.765]                           if (!grepl("^muffle", name)) 
  [21:15:33.765]                             next
  [21:15:33.765]                           invokeRestart(restart)
  [21:15:33.765]                           muffled <- TRUE
  [21:15:33.765]                           break
  [21:15:33.765]                         }
  [21:15:33.765]                       }
  [21:15:33.765]                       invisible(muffled)
  [21:15:33.765]                     }
  [21:15:33.765]                     muffleCondition(cond)
  [21:15:33.765]                   }
  [21:15:33.765]                 }
  [21:15:33.765]             }
  [21:15:33.765]         }))
  [21:15:33.765]     }, error = function(ex) {
  [21:15:33.765]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.765]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.765]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.765]     }, finally = {
  [21:15:33.765]         {
  [21:15:33.765]             NULL
  [21:15:33.765]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.765]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.765]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.765]                 label = NULL, ...) 
  [21:15:33.765]             {
  [21:15:33.765]                 if (substitute) 
  [21:15:33.765]                   expr <- substitute(expr)
  [21:15:33.765]                 local <- as.logical(local)
  [21:15:33.765]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.765]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.765]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.765]                   label = label, ...)
  [21:15:33.765]                 if (!future$lazy) 
  [21:15:33.765]                   future <- run(future)
  [21:15:33.765]                 invisible(future)
  [21:15:33.765]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.765]         }
  [21:15:33.765]         base::options(...future.oldOptions)
  [21:15:33.765]     })
  [21:15:33.765]     Sys.time
  [21:15:33.765]     if (base::is.na(TRUE)) {
  [21:15:33.765]     }
  [21:15:33.765]     else {
  [21:15:33.765]         base::sink(type = "output", split = FALSE)
  [21:15:33.765]         if (TRUE) {
  [21:15:33.765]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.765]         }
  [21:15:33.765]         else {
  [21:15:33.765]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.765]         }
  [21:15:33.765]         base::close(...future.stdout)
  [21:15:33.765]         ...future.stdout <- NULL
  [21:15:33.765]     }
  [21:15:33.765]     ...future.result$conditions <- ...future.conditions
  [21:15:33.765]     ...future.result
  [21:15:33.765] }
  [21:15:33.769] plan(): Setting new future strategy stack:
  [21:15:33.770] List of future strategies:
  [21:15:33.770] 1. sequential:
  [21:15:33.770]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.770]    - tweaked: FALSE
  [21:15:33.770]    - call: NULL
  [21:15:33.771] plan(): nbrOfWorkers() = 1
  [21:15:33.772] plan(): Setting new future strategy stack:
  [21:15:33.772] List of future strategies:
  [21:15:33.772] 1. sequential:
  [21:15:33.772]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.772]    - tweaked: FALSE
  [21:15:33.772]    - call: plan(strategy)
  [21:15:33.773] plan(): nbrOfWorkers() = 1
  [21:15:33.773] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-473739'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349b773c8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.775] getGlobalsAndPackages() ...
  [21:15:33.775] Searching for globals...
  [21:15:33.777] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.777] Searching for globals ... DONE
  [21:15:33.778] Resolving globals: FALSE
  [21:15:33.779] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.779] - globals: [1] 'x'
  [21:15:33.779] 
  [21:15:33.779] getGlobalsAndPackages() ... DONE
  [21:15:33.781] Packages needed by the future expression (n = 0): <none>
  [21:15:33.781] Packages needed by future strategies (n = 0): <none>
  [21:15:33.786] {
  [21:15:33.786]     {
  [21:15:33.786]         ...future.startTime <- base::Sys.time()
  [21:15:33.786]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.786]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.786]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.786]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.786]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.786]         {
  [21:15:33.786]             {
  [21:15:33.786]                 base::local({
  [21:15:33.786]                   has_future <- base::requireNamespace("future", 
  [21:15:33.786]                     quietly = TRUE)
  [21:15:33.786]                   version <- if (has_future) 
  [21:15:33.786]                     utils::packageVersion("future")
  [21:15:33.786]                   else NULL
  [21:15:33.786]                   if (!has_future || version < "1.8.0") {
  [21:15:33.786]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.786]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.786]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.786]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.786]                         "release", "version")], collapse = " "), 
  [21:15:33.786]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.786]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.786]                       info)
  [21:15:33.786]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.786]                     if (!has_future) {
  [21:15:33.786]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.786]                         info)
  [21:15:33.786]                     }
  [21:15:33.786]                     else {
  [21:15:33.786]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.786]                         info, version)
  [21:15:33.786]                     }
  [21:15:33.786]                     base::stop(msg)
  [21:15:33.786]                   }
  [21:15:33.786]                 })
  [21:15:33.786]             }
  [21:15:33.786]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.786]         }
  [21:15:33.786]     }
  [21:15:33.786]     if (base::is.na(TRUE)) {
  [21:15:33.786]     }
  [21:15:33.786]     else {
  [21:15:33.786]         if (TRUE) {
  [21:15:33.786]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.786]                 open = "w")
  [21:15:33.786]         }
  [21:15:33.786]         else {
  [21:15:33.786]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.786]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.786]         }
  [21:15:33.786]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.786]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.786]             base::sink(type = "output", split = FALSE)
  [21:15:33.786]             base::close(...future.stdout)
  [21:15:33.786]         }, add = TRUE)
  [21:15:33.786]     }
  [21:15:33.786]     ...future.frame <- base::sys.nframe()
  [21:15:33.786]     ...future.conditions <- base::list()
  [21:15:33.786]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.786]     ...future.result <- base::tryCatch({
  [21:15:33.786]         base::withCallingHandlers({
  [21:15:33.786]             ...future.value <- base::withVisible(base::local({
  [21:15:33.786]                 sample(x, size = 1L)
  [21:15:33.786]             }))
  [21:15:33.786]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.786]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.786]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.786]                 version = "1.8")
  [21:15:33.786]         }, condition = base::local({
  [21:15:33.786]             c <- base::c
  [21:15:33.786]             inherits <- base::inherits
  [21:15:33.786]             invokeRestart <- base::invokeRestart
  [21:15:33.786]             length <- base::length
  [21:15:33.786]             list <- base::list
  [21:15:33.786]             seq.int <- base::seq.int
  [21:15:33.786]             signalCondition <- base::signalCondition
  [21:15:33.786]             sys.calls <- base::sys.calls
  [21:15:33.786]             Sys.time <- base::Sys.time
  [21:15:33.786]             `[[` <- base::`[[`
  [21:15:33.786]             `+` <- base::`+`
  [21:15:33.786]             `<<-` <- base::`<<-`
  [21:15:33.786]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.786]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.786]                   3L)]
  [21:15:33.786]             }
  [21:15:33.786]             function(cond) {
  [21:15:33.786]                 if (inherits(cond, "error")) {
  [21:15:33.786]                   sessionInformation <- function() {
  [21:15:33.786]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.786]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.786]                       search = base::search(), system = base::Sys.info())
  [21:15:33.786]                   }
  [21:15:33.786]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.786]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.786]                     cond$call), session = sessionInformation(), 
  [21:15:33.786]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.786]                   signalCondition(cond)
  [21:15:33.786]                 }
  [21:15:33.786]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.786]                 ))) {
  [21:15:33.786]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.786]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.786]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.786]                   if (!signal) {
  [21:15:33.786]                     muffleCondition <- function (cond) 
  [21:15:33.786]                     {
  [21:15:33.786]                       inherits <- base::inherits
  [21:15:33.786]                       invokeRestart <- base::invokeRestart
  [21:15:33.786]                       muffled <- FALSE
  [21:15:33.786]                       if (inherits(cond, "message")) {
  [21:15:33.786]                         invokeRestart("muffleMessage")
  [21:15:33.786]                         muffled <- TRUE
  [21:15:33.786]                       }
  [21:15:33.786]                       else if (inherits(cond, "warning")) {
  [21:15:33.786]                         invokeRestart("muffleWarning")
  [21:15:33.786]                         muffled <- TRUE
  [21:15:33.786]                       }
  [21:15:33.786]                       else if (inherits(cond, "condition")) {
  [21:15:33.786]                         computeRestarts <- base::computeRestarts
  [21:15:33.786]                         grepl <- base::grepl
  [21:15:33.786]                         is.null <- base::is.null
  [21:15:33.786]                         restarts <- computeRestarts(cond)
  [21:15:33.786]                         for (restart in restarts) {
  [21:15:33.786]                           name <- restart$name
  [21:15:33.786]                           if (is.null(name)) 
  [21:15:33.786]                             next
  [21:15:33.786]                           if (!grepl("^muffle", name)) 
  [21:15:33.786]                             next
  [21:15:33.786]                           invokeRestart(restart)
  [21:15:33.786]                           muffled <- TRUE
  [21:15:33.786]                           break
  [21:15:33.786]                         }
  [21:15:33.786]                       }
  [21:15:33.786]                       invisible(muffled)
  [21:15:33.786]                     }
  [21:15:33.786]                     muffleCondition(cond)
  [21:15:33.786]                   }
  [21:15:33.786]                 }
  [21:15:33.786]             }
  [21:15:33.786]         }))
  [21:15:33.786]     }, error = function(ex) {
  [21:15:33.786]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.786]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.786]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.786]     }, finally = {
  [21:15:33.786]         {
  [21:15:33.786]             NULL
  [21:15:33.786]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.786]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.786]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.786]                 label = NULL, ...) 
  [21:15:33.786]             {
  [21:15:33.786]                 if (substitute) 
  [21:15:33.786]                   expr <- substitute(expr)
  [21:15:33.786]                 local <- as.logical(local)
  [21:15:33.786]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.786]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.786]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.786]                   label = label, ...)
  [21:15:33.786]                 if (!future$lazy) 
  [21:15:33.786]                   future <- run(future)
  [21:15:33.786]                 invisible(future)
  [21:15:33.786]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.786]         }
  [21:15:33.786]         base::options(...future.oldOptions)
  [21:15:33.786]     })
  [21:15:33.786]     Sys.time
  [21:15:33.786]     if (base::is.na(TRUE)) {
  [21:15:33.786]     }
  [21:15:33.786]     else {
  [21:15:33.786]         base::sink(type = "output", split = FALSE)
  [21:15:33.786]         if (TRUE) {
  [21:15:33.786]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.786]         }
  [21:15:33.786]         else {
  [21:15:33.786]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.786]         }
  [21:15:33.786]         base::close(...future.stdout)
  [21:15:33.786]         ...future.stdout <- NULL
  [21:15:33.786]     }
  [21:15:33.786]     ...future.result$conditions <- ...future.conditions
  [21:15:33.786]     ...future.result
  [21:15:33.786] }
  [21:15:33.790] plan(): Setting new future strategy stack:
  [21:15:33.791] List of future strategies:
  [21:15:33.791] 1. sequential:
  [21:15:33.791]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.791]    - tweaked: FALSE
  [21:15:33.791]    - call: NULL
  [21:15:33.791] plan(): nbrOfWorkers() = 1
  [21:15:33.793] plan(): Setting new future strategy stack:
  [21:15:33.793] List of future strategies:
  [21:15:33.793] 1. sequential:
  [21:15:33.793]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.793]    - tweaked: FALSE
  [21:15:33.793]    - call: plan(strategy)
  [21:15:33.794] plan(): nbrOfWorkers() = 1
  [21:15:33.794] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-932782'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349b773c8>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.796] resolve() on list ...
  [21:15:33.796]  recursive: 0
  [21:15:33.797]  length: 4
  [21:15:33.797] 
  [21:15:33.797] Future #1
  [21:15:33.798] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.798] - nx: 4
  [21:15:33.798] - relay: TRUE
  [21:15:33.799] - stdout: TRUE
  [21:15:33.799] - signal: TRUE
  [21:15:33.799] - resignal: FALSE
  [21:15:33.799] - force: TRUE
  [21:15:33.800] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.800] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.800]  - until=1
  [21:15:33.801]  - relaying element #1
  [21:15:33.801] signalConditions() ...
  [21:15:33.801]  - include = 'immediateCondition'
  [21:15:33.801]  - exclude = 
  [21:15:33.802]  - resignal = FALSE
  [21:15:33.802]  - Number of conditions: 1
  [21:15:33.802] signalConditions() ... done
  [21:15:33.803] signalConditions() ...
  [21:15:33.803]  - include = 'immediateCondition'
  [21:15:33.803]  - exclude = 
  [21:15:33.804]  - resignal = FALSE
  [21:15:33.804]  - Number of conditions: 1
  [21:15:33.804] signalConditions() ... done
  [21:15:33.805] signalConditions() ...
  [21:15:33.805]  - include = 'condition'
  [21:15:33.805]  - exclude = 'immediateCondition'
  [21:15:33.805]  - resignal = TRUE
  [21:15:33.806]  - Number of conditions: 1
  [21:15:33.806]  - Condition #1: 'simpleWarning', 'warning', 'condition'
  [21:15:33.807] signalConditions() ... done
  [21:15:33.807] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.807] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.807] signalConditionsASAP(SequentialFuture, pos=1) ... done
  <simpleWarning: UNRELIABLE VALUE: Future ('fsample_1-798024') unexpectedly generated random numbers without specifying argument '[future.]seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify argument argument '[future.]seed', e.g. 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, set option 'future.rng.onMisuse' to "ignore".>
  [21:15:33.808] getGlobalsAndPackages() ...
  [21:15:33.808] Searching for globals...
  [21:15:33.810] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.811] Searching for globals ... DONE
  [21:15:33.811] Resolving globals: FALSE
  [21:15:33.812] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.812] - globals: [1] 'x'
  [21:15:33.812] 
  [21:15:33.813] getGlobalsAndPackages() ... DONE
  [21:15:33.814] Packages needed by the future expression (n = 0): <none>
  [21:15:33.815] Packages needed by future strategies (n = 0): <none>
  [21:15:33.819] {
  [21:15:33.819]     {
  [21:15:33.819]         ...future.startTime <- base::Sys.time()
  [21:15:33.819]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.819]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.819]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.819]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.819]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.819]         {
  [21:15:33.819]             {
  [21:15:33.819]                 base::local({
  [21:15:33.819]                   has_future <- base::requireNamespace("future", 
  [21:15:33.819]                     quietly = TRUE)
  [21:15:33.819]                   version <- if (has_future) 
  [21:15:33.819]                     utils::packageVersion("future")
  [21:15:33.819]                   else NULL
  [21:15:33.819]                   if (!has_future || version < "1.8.0") {
  [21:15:33.819]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.819]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.819]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.819]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.819]                         "release", "version")], collapse = " "), 
  [21:15:33.819]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.819]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.819]                       info)
  [21:15:33.819]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.819]                     if (!has_future) {
  [21:15:33.819]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.819]                         info)
  [21:15:33.819]                     }
  [21:15:33.819]                     else {
  [21:15:33.819]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.819]                         info, version)
  [21:15:33.819]                     }
  [21:15:33.819]                     base::stop(msg)
  [21:15:33.819]                   }
  [21:15:33.819]                 })
  [21:15:33.819]             }
  [21:15:33.819]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.819]         }
  [21:15:33.819]     }
  [21:15:33.819]     if (base::is.na(TRUE)) {
  [21:15:33.819]     }
  [21:15:33.819]     else {
  [21:15:33.819]         if (TRUE) {
  [21:15:33.819]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.819]                 open = "w")
  [21:15:33.819]         }
  [21:15:33.819]         else {
  [21:15:33.819]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.819]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.819]         }
  [21:15:33.819]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.819]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.819]             base::sink(type = "output", split = FALSE)
  [21:15:33.819]             base::close(...future.stdout)
  [21:15:33.819]         }, add = TRUE)
  [21:15:33.819]     }
  [21:15:33.819]     ...future.frame <- base::sys.nframe()
  [21:15:33.819]     ...future.conditions <- base::list()
  [21:15:33.819]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.819]     ...future.result <- base::tryCatch({
  [21:15:33.819]         base::withCallingHandlers({
  [21:15:33.819]             ...future.value <- base::withVisible(base::local({
  [21:15:33.819]                 sample(x, size = 1L)
  [21:15:33.819]             }))
  [21:15:33.819]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.819]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.819]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.819]                 version = "1.8")
  [21:15:33.819]         }, condition = base::local({
  [21:15:33.819]             c <- base::c
  [21:15:33.819]             inherits <- base::inherits
  [21:15:33.819]             invokeRestart <- base::invokeRestart
  [21:15:33.819]             length <- base::length
  [21:15:33.819]             list <- base::list
  [21:15:33.819]             seq.int <- base::seq.int
  [21:15:33.819]             signalCondition <- base::signalCondition
  [21:15:33.819]             sys.calls <- base::sys.calls
  [21:15:33.819]             Sys.time <- base::Sys.time
  [21:15:33.819]             `[[` <- base::`[[`
  [21:15:33.819]             `+` <- base::`+`
  [21:15:33.819]             `<<-` <- base::`<<-`
  [21:15:33.819]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.819]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.819]                   3L)]
  [21:15:33.819]             }
  [21:15:33.819]             function(cond) {
  [21:15:33.819]                 if (inherits(cond, "error")) {
  [21:15:33.819]                   sessionInformation <- function() {
  [21:15:33.819]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.819]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.819]                       search = base::search(), system = base::Sys.info())
  [21:15:33.819]                   }
  [21:15:33.819]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.819]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.819]                     cond$call), session = sessionInformation(), 
  [21:15:33.819]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.819]                   signalCondition(cond)
  [21:15:33.819]                 }
  [21:15:33.819]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.819]                 ))) {
  [21:15:33.819]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.819]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.819]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.819]                   if (!signal) {
  [21:15:33.819]                     muffleCondition <- function (cond) 
  [21:15:33.819]                     {
  [21:15:33.819]                       inherits <- base::inherits
  [21:15:33.819]                       invokeRestart <- base::invokeRestart
  [21:15:33.819]                       muffled <- FALSE
  [21:15:33.819]                       if (inherits(cond, "message")) {
  [21:15:33.819]                         invokeRestart("muffleMessage")
  [21:15:33.819]                         muffled <- TRUE
  [21:15:33.819]                       }
  [21:15:33.819]                       else if (inherits(cond, "warning")) {
  [21:15:33.819]                         invokeRestart("muffleWarning")
  [21:15:33.819]                         muffled <- TRUE
  [21:15:33.819]                       }
  [21:15:33.819]                       else if (inherits(cond, "condition")) {
  [21:15:33.819]                         computeRestarts <- base::computeRestarts
  [21:15:33.819]                         grepl <- base::grepl
  [21:15:33.819]                         is.null <- base::is.null
  [21:15:33.819]                         restarts <- computeRestarts(cond)
  [21:15:33.819]                         for (restart in restarts) {
  [21:15:33.819]                           name <- restart$name
  [21:15:33.819]                           if (is.null(name)) 
  [21:15:33.819]                             next
  [21:15:33.819]                           if (!grepl("^muffle", name)) 
  [21:15:33.819]                             next
  [21:15:33.819]                           invokeRestart(restart)
  [21:15:33.819]                           muffled <- TRUE
  [21:15:33.819]                           break
  [21:15:33.819]                         }
  [21:15:33.819]                       }
  [21:15:33.819]                       invisible(muffled)
  [21:15:33.819]                     }
  [21:15:33.819]                     muffleCondition(cond)
  [21:15:33.819]                   }
  [21:15:33.819]                 }
  [21:15:33.819]             }
  [21:15:33.819]         }))
  [21:15:33.819]     }, error = function(ex) {
  [21:15:33.819]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.819]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.819]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.819]     }, finally = {
  [21:15:33.819]         {
  [21:15:33.819]             NULL
  [21:15:33.819]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.819]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.819]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.819]                 label = NULL, ...) 
  [21:15:33.819]             {
  [21:15:33.819]                 if (substitute) 
  [21:15:33.819]                   expr <- substitute(expr)
  [21:15:33.819]                 local <- as.logical(local)
  [21:15:33.819]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.819]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.819]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.819]                   label = label, ...)
  [21:15:33.819]                 if (!future$lazy) 
  [21:15:33.819]                   future <- run(future)
  [21:15:33.819]                 invisible(future)
  [21:15:33.819]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.819]         }
  [21:15:33.819]         base::options(...future.oldOptions)
  [21:15:33.819]     })
  [21:15:33.819]     Sys.time
  [21:15:33.819]     if (base::is.na(TRUE)) {
  [21:15:33.819]     }
  [21:15:33.819]     else {
  [21:15:33.819]         base::sink(type = "output", split = FALSE)
  [21:15:33.819]         if (TRUE) {
  [21:15:33.819]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.819]         }
  [21:15:33.819]         else {
  [21:15:33.819]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.819]         }
  [21:15:33.819]         base::close(...future.stdout)
  [21:15:33.819]         ...future.stdout <- NULL
  [21:15:33.819]     }
  [21:15:33.819]     ...future.result$conditions <- ...future.conditions
  [21:15:33.819]     ...future.result
  [21:15:33.819] }
  [21:15:33.823] plan(): Setting new future strategy stack:
  [21:15:33.824] List of future strategies:
  [21:15:33.824] 1. sequential:
  [21:15:33.824]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.824]    - tweaked: FALSE
  [21:15:33.824]    - call: NULL
  [21:15:33.824] plan(): nbrOfWorkers() = 1
  [21:15:33.829] plan(): Setting new future strategy stack:
  [21:15:33.829] List of future strategies:
  [21:15:33.829] 1. sequential:
  [21:15:33.829]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.829]    - tweaked: FALSE
  [21:15:33.829]    - call: plan(strategy)
  [21:15:33.830] plan(): nbrOfWorkers() = 1
  [21:15:33.831] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-506796'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ac0f800>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.832] getGlobalsAndPackages() ...
  [21:15:33.833] Searching for globals...
  [21:15:33.835] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.835] Searching for globals ... DONE
  [21:15:33.835] Resolving globals: FALSE
  [21:15:33.836] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.836] - globals: [1] 'x'
  [21:15:33.837] 
  [21:15:33.837] getGlobalsAndPackages() ... DONE
  [21:15:33.839] Packages needed by the future expression (n = 0): <none>
  [21:15:33.839] Packages needed by future strategies (n = 0): <none>
  [21:15:33.843] {
  [21:15:33.843]     {
  [21:15:33.843]         ...future.startTime <- base::Sys.time()
  [21:15:33.843]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.843]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.843]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.843]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.843]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.843]         {
  [21:15:33.843]             {
  [21:15:33.843]                 base::local({
  [21:15:33.843]                   has_future <- base::requireNamespace("future", 
  [21:15:33.843]                     quietly = TRUE)
  [21:15:33.843]                   version <- if (has_future) 
  [21:15:33.843]                     utils::packageVersion("future")
  [21:15:33.843]                   else NULL
  [21:15:33.843]                   if (!has_future || version < "1.8.0") {
  [21:15:33.843]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.843]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.843]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.843]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.843]                         "release", "version")], collapse = " "), 
  [21:15:33.843]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.843]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.843]                       info)
  [21:15:33.843]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.843]                     if (!has_future) {
  [21:15:33.843]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.843]                         info)
  [21:15:33.843]                     }
  [21:15:33.843]                     else {
  [21:15:33.843]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.843]                         info, version)
  [21:15:33.843]                     }
  [21:15:33.843]                     base::stop(msg)
  [21:15:33.843]                   }
  [21:15:33.843]                 })
  [21:15:33.843]             }
  [21:15:33.843]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.843]         }
  [21:15:33.843]     }
  [21:15:33.843]     if (base::is.na(TRUE)) {
  [21:15:33.843]     }
  [21:15:33.843]     else {
  [21:15:33.843]         if (TRUE) {
  [21:15:33.843]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.843]                 open = "w")
  [21:15:33.843]         }
  [21:15:33.843]         else {
  [21:15:33.843]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.843]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.843]         }
  [21:15:33.843]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.843]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.843]             base::sink(type = "output", split = FALSE)
  [21:15:33.843]             base::close(...future.stdout)
  [21:15:33.843]         }, add = TRUE)
  [21:15:33.843]     }
  [21:15:33.843]     ...future.frame <- base::sys.nframe()
  [21:15:33.843]     ...future.conditions <- base::list()
  [21:15:33.843]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.843]     ...future.result <- base::tryCatch({
  [21:15:33.843]         base::withCallingHandlers({
  [21:15:33.843]             ...future.value <- base::withVisible(base::local({
  [21:15:33.843]                 sample(x, size = 1L)
  [21:15:33.843]             }))
  [21:15:33.843]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.843]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.843]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.843]                 version = "1.8")
  [21:15:33.843]         }, condition = base::local({
  [21:15:33.843]             c <- base::c
  [21:15:33.843]             inherits <- base::inherits
  [21:15:33.843]             invokeRestart <- base::invokeRestart
  [21:15:33.843]             length <- base::length
  [21:15:33.843]             list <- base::list
  [21:15:33.843]             seq.int <- base::seq.int
  [21:15:33.843]             signalCondition <- base::signalCondition
  [21:15:33.843]             sys.calls <- base::sys.calls
  [21:15:33.843]             Sys.time <- base::Sys.time
  [21:15:33.843]             `[[` <- base::`[[`
  [21:15:33.843]             `+` <- base::`+`
  [21:15:33.843]             `<<-` <- base::`<<-`
  [21:15:33.843]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.843]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.843]                   3L)]
  [21:15:33.843]             }
  [21:15:33.843]             function(cond) {
  [21:15:33.843]                 if (inherits(cond, "error")) {
  [21:15:33.843]                   sessionInformation <- function() {
  [21:15:33.843]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.843]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.843]                       search = base::search(), system = base::Sys.info())
  [21:15:33.843]                   }
  [21:15:33.843]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.843]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.843]                     cond$call), session = sessionInformation(), 
  [21:15:33.843]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.843]                   signalCondition(cond)
  [21:15:33.843]                 }
  [21:15:33.843]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.843]                 ))) {
  [21:15:33.843]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.843]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.843]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.843]                   if (!signal) {
  [21:15:33.843]                     muffleCondition <- function (cond) 
  [21:15:33.843]                     {
  [21:15:33.843]                       inherits <- base::inherits
  [21:15:33.843]                       invokeRestart <- base::invokeRestart
  [21:15:33.843]                       muffled <- FALSE
  [21:15:33.843]                       if (inherits(cond, "message")) {
  [21:15:33.843]                         invokeRestart("muffleMessage")
  [21:15:33.843]                         muffled <- TRUE
  [21:15:33.843]                       }
  [21:15:33.843]                       else if (inherits(cond, "warning")) {
  [21:15:33.843]                         invokeRestart("muffleWarning")
  [21:15:33.843]                         muffled <- TRUE
  [21:15:33.843]                       }
  [21:15:33.843]                       else if (inherits(cond, "condition")) {
  [21:15:33.843]                         computeRestarts <- base::computeRestarts
  [21:15:33.843]                         grepl <- base::grepl
  [21:15:33.843]                         is.null <- base::is.null
  [21:15:33.843]                         restarts <- computeRestarts(cond)
  [21:15:33.843]                         for (restart in restarts) {
  [21:15:33.843]                           name <- restart$name
  [21:15:33.843]                           if (is.null(name)) 
  [21:15:33.843]                             next
  [21:15:33.843]                           if (!grepl("^muffle", name)) 
  [21:15:33.843]                             next
  [21:15:33.843]                           invokeRestart(restart)
  [21:15:33.843]                           muffled <- TRUE
  [21:15:33.843]                           break
  [21:15:33.843]                         }
  [21:15:33.843]                       }
  [21:15:33.843]                       invisible(muffled)
  [21:15:33.843]                     }
  [21:15:33.843]                     muffleCondition(cond)
  [21:15:33.843]                   }
  [21:15:33.843]                 }
  [21:15:33.843]             }
  [21:15:33.843]         }))
  [21:15:33.843]     }, error = function(ex) {
  [21:15:33.843]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.843]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.843]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.843]     }, finally = {
  [21:15:33.843]         {
  [21:15:33.843]             NULL
  [21:15:33.843]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.843]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.843]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.843]                 label = NULL, ...) 
  [21:15:33.843]             {
  [21:15:33.843]                 if (substitute) 
  [21:15:33.843]                   expr <- substitute(expr)
  [21:15:33.843]                 local <- as.logical(local)
  [21:15:33.843]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.843]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.843]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.843]                   label = label, ...)
  [21:15:33.843]                 if (!future$lazy) 
  [21:15:33.843]                   future <- run(future)
  [21:15:33.843]                 invisible(future)
  [21:15:33.843]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.843]         }
  [21:15:33.843]         base::options(...future.oldOptions)
  [21:15:33.843]     })
  [21:15:33.843]     Sys.time
  [21:15:33.843]     if (base::is.na(TRUE)) {
  [21:15:33.843]     }
  [21:15:33.843]     else {
  [21:15:33.843]         base::sink(type = "output", split = FALSE)
  [21:15:33.843]         if (TRUE) {
  [21:15:33.843]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.843]         }
  [21:15:33.843]         else {
  [21:15:33.843]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.843]         }
  [21:15:33.843]         base::close(...future.stdout)
  [21:15:33.843]         ...future.stdout <- NULL
  [21:15:33.843]     }
  [21:15:33.843]     ...future.result$conditions <- ...future.conditions
  [21:15:33.843]     ...future.result
  [21:15:33.843] }
  [21:15:33.848] plan(): Setting new future strategy stack:
  [21:15:33.848] List of future strategies:
  [21:15:33.848] 1. sequential:
  [21:15:33.848]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.848]    - tweaked: FALSE
  [21:15:33.848]    - call: NULL
  [21:15:33.849] plan(): nbrOfWorkers() = 1
  [21:15:33.850] plan(): Setting new future strategy stack:
  [21:15:33.850] List of future strategies:
  [21:15:33.850] 1. sequential:
  [21:15:33.850]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.850]    - tweaked: FALSE
  [21:15:33.850]    - call: plan(strategy)
  [21:15:33.851] plan(): nbrOfWorkers() = 1
  [21:15:33.852] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-245794'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ac0f800>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.853] getGlobalsAndPackages() ...
  [21:15:33.854] Searching for globals...
  [21:15:33.856] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.856] Searching for globals ... DONE
  [21:15:33.856] Resolving globals: FALSE
  [21:15:33.857] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.857] - globals: [1] 'x'
  [21:15:33.857] 
  [21:15:33.858] getGlobalsAndPackages() ... DONE
  [21:15:33.859] Packages needed by the future expression (n = 0): <none>
  [21:15:33.860] Packages needed by future strategies (n = 0): <none>
  [21:15:33.864] {
  [21:15:33.864]     {
  [21:15:33.864]         ...future.startTime <- base::Sys.time()
  [21:15:33.864]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.864]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.864]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.864]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.864]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.864]         {
  [21:15:33.864]             {
  [21:15:33.864]                 base::local({
  [21:15:33.864]                   has_future <- base::requireNamespace("future", 
  [21:15:33.864]                     quietly = TRUE)
  [21:15:33.864]                   version <- if (has_future) 
  [21:15:33.864]                     utils::packageVersion("future")
  [21:15:33.864]                   else NULL
  [21:15:33.864]                   if (!has_future || version < "1.8.0") {
  [21:15:33.864]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.864]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.864]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.864]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.864]                         "release", "version")], collapse = " "), 
  [21:15:33.864]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.864]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.864]                       info)
  [21:15:33.864]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.864]                     if (!has_future) {
  [21:15:33.864]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.864]                         info)
  [21:15:33.864]                     }
  [21:15:33.864]                     else {
  [21:15:33.864]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.864]                         info, version)
  [21:15:33.864]                     }
  [21:15:33.864]                     base::stop(msg)
  [21:15:33.864]                   }
  [21:15:33.864]                 })
  [21:15:33.864]             }
  [21:15:33.864]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.864]         }
  [21:15:33.864]     }
  [21:15:33.864]     if (base::is.na(TRUE)) {
  [21:15:33.864]     }
  [21:15:33.864]     else {
  [21:15:33.864]         if (TRUE) {
  [21:15:33.864]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.864]                 open = "w")
  [21:15:33.864]         }
  [21:15:33.864]         else {
  [21:15:33.864]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.864]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.864]         }
  [21:15:33.864]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.864]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.864]             base::sink(type = "output", split = FALSE)
  [21:15:33.864]             base::close(...future.stdout)
  [21:15:33.864]         }, add = TRUE)
  [21:15:33.864]     }
  [21:15:33.864]     ...future.frame <- base::sys.nframe()
  [21:15:33.864]     ...future.conditions <- base::list()
  [21:15:33.864]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.864]     ...future.result <- base::tryCatch({
  [21:15:33.864]         base::withCallingHandlers({
  [21:15:33.864]             ...future.value <- base::withVisible(base::local({
  [21:15:33.864]                 sample(x, size = 1L)
  [21:15:33.864]             }))
  [21:15:33.864]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.864]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.864]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.864]                 version = "1.8")
  [21:15:33.864]         }, condition = base::local({
  [21:15:33.864]             c <- base::c
  [21:15:33.864]             inherits <- base::inherits
  [21:15:33.864]             invokeRestart <- base::invokeRestart
  [21:15:33.864]             length <- base::length
  [21:15:33.864]             list <- base::list
  [21:15:33.864]             seq.int <- base::seq.int
  [21:15:33.864]             signalCondition <- base::signalCondition
  [21:15:33.864]             sys.calls <- base::sys.calls
  [21:15:33.864]             Sys.time <- base::Sys.time
  [21:15:33.864]             `[[` <- base::`[[`
  [21:15:33.864]             `+` <- base::`+`
  [21:15:33.864]             `<<-` <- base::`<<-`
  [21:15:33.864]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.864]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.864]                   3L)]
  [21:15:33.864]             }
  [21:15:33.864]             function(cond) {
  [21:15:33.864]                 if (inherits(cond, "error")) {
  [21:15:33.864]                   sessionInformation <- function() {
  [21:15:33.864]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.864]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.864]                       search = base::search(), system = base::Sys.info())
  [21:15:33.864]                   }
  [21:15:33.864]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.864]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.864]                     cond$call), session = sessionInformation(), 
  [21:15:33.864]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.864]                   signalCondition(cond)
  [21:15:33.864]                 }
  [21:15:33.864]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.864]                 ))) {
  [21:15:33.864]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.864]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.864]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.864]                   if (!signal) {
  [21:15:33.864]                     muffleCondition <- function (cond) 
  [21:15:33.864]                     {
  [21:15:33.864]                       inherits <- base::inherits
  [21:15:33.864]                       invokeRestart <- base::invokeRestart
  [21:15:33.864]                       muffled <- FALSE
  [21:15:33.864]                       if (inherits(cond, "message")) {
  [21:15:33.864]                         invokeRestart("muffleMessage")
  [21:15:33.864]                         muffled <- TRUE
  [21:15:33.864]                       }
  [21:15:33.864]                       else if (inherits(cond, "warning")) {
  [21:15:33.864]                         invokeRestart("muffleWarning")
  [21:15:33.864]                         muffled <- TRUE
  [21:15:33.864]                       }
  [21:15:33.864]                       else if (inherits(cond, "condition")) {
  [21:15:33.864]                         computeRestarts <- base::computeRestarts
  [21:15:33.864]                         grepl <- base::grepl
  [21:15:33.864]                         is.null <- base::is.null
  [21:15:33.864]                         restarts <- computeRestarts(cond)
  [21:15:33.864]                         for (restart in restarts) {
  [21:15:33.864]                           name <- restart$name
  [21:15:33.864]                           if (is.null(name)) 
  [21:15:33.864]                             next
  [21:15:33.864]                           if (!grepl("^muffle", name)) 
  [21:15:33.864]                             next
  [21:15:33.864]                           invokeRestart(restart)
  [21:15:33.864]                           muffled <- TRUE
  [21:15:33.864]                           break
  [21:15:33.864]                         }
  [21:15:33.864]                       }
  [21:15:33.864]                       invisible(muffled)
  [21:15:33.864]                     }
  [21:15:33.864]                     muffleCondition(cond)
  [21:15:33.864]                   }
  [21:15:33.864]                 }
  [21:15:33.864]             }
  [21:15:33.864]         }))
  [21:15:33.864]     }, error = function(ex) {
  [21:15:33.864]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.864]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.864]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.864]     }, finally = {
  [21:15:33.864]         {
  [21:15:33.864]             NULL
  [21:15:33.864]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.864]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.864]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.864]                 label = NULL, ...) 
  [21:15:33.864]             {
  [21:15:33.864]                 if (substitute) 
  [21:15:33.864]                   expr <- substitute(expr)
  [21:15:33.864]                 local <- as.logical(local)
  [21:15:33.864]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.864]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.864]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.864]                   label = label, ...)
  [21:15:33.864]                 if (!future$lazy) 
  [21:15:33.864]                   future <- run(future)
  [21:15:33.864]                 invisible(future)
  [21:15:33.864]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.864]         }
  [21:15:33.864]         base::options(...future.oldOptions)
  [21:15:33.864]     })
  [21:15:33.864]     Sys.time
  [21:15:33.864]     if (base::is.na(TRUE)) {
  [21:15:33.864]     }
  [21:15:33.864]     else {
  [21:15:33.864]         base::sink(type = "output", split = FALSE)
  [21:15:33.864]         if (TRUE) {
  [21:15:33.864]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.864]         }
  [21:15:33.864]         else {
  [21:15:33.864]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.864]         }
  [21:15:33.864]         base::close(...future.stdout)
  [21:15:33.864]         ...future.stdout <- NULL
  [21:15:33.864]     }
  [21:15:33.864]     ...future.result$conditions <- ...future.conditions
  [21:15:33.864]     ...future.result
  [21:15:33.864] }
  [21:15:33.868] plan(): Setting new future strategy stack:
  [21:15:33.868] List of future strategies:
  [21:15:33.868] 1. sequential:
  [21:15:33.868]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.868]    - tweaked: FALSE
  [21:15:33.868]    - call: NULL
  [21:15:33.869] plan(): nbrOfWorkers() = 1
  [21:15:33.870] plan(): Setting new future strategy stack:
  [21:15:33.871] List of future strategies:
  [21:15:33.871] 1. sequential:
  [21:15:33.871]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.871]    - tweaked: FALSE
  [21:15:33.871]    - call: plan(strategy)
  [21:15:33.871] plan(): nbrOfWorkers() = 1
  [21:15:33.872] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-758420'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ac0f800>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.874] getGlobalsAndPackages() ...
  [21:15:33.874] Searching for globals...
  [21:15:33.876] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.876] Searching for globals ... DONE
  [21:15:33.876] Resolving globals: FALSE
  [21:15:33.877] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.878] - globals: [1] 'x'
  [21:15:33.878] 
  [21:15:33.878] getGlobalsAndPackages() ... DONE
  [21:15:33.880] Packages needed by the future expression (n = 0): <none>
  [21:15:33.880] Packages needed by future strategies (n = 0): <none>
  [21:15:33.884] {
  [21:15:33.884]     {
  [21:15:33.884]         ...future.startTime <- base::Sys.time()
  [21:15:33.884]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.884]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.884]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.884]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.884]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.884]         {
  [21:15:33.884]             {
  [21:15:33.884]                 base::local({
  [21:15:33.884]                   has_future <- base::requireNamespace("future", 
  [21:15:33.884]                     quietly = TRUE)
  [21:15:33.884]                   version <- if (has_future) 
  [21:15:33.884]                     utils::packageVersion("future")
  [21:15:33.884]                   else NULL
  [21:15:33.884]                   if (!has_future || version < "1.8.0") {
  [21:15:33.884]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.884]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.884]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.884]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.884]                         "release", "version")], collapse = " "), 
  [21:15:33.884]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.884]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.884]                       info)
  [21:15:33.884]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.884]                     if (!has_future) {
  [21:15:33.884]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.884]                         info)
  [21:15:33.884]                     }
  [21:15:33.884]                     else {
  [21:15:33.884]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.884]                         info, version)
  [21:15:33.884]                     }
  [21:15:33.884]                     base::stop(msg)
  [21:15:33.884]                   }
  [21:15:33.884]                 })
  [21:15:33.884]             }
  [21:15:33.884]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.884]         }
  [21:15:33.884]     }
  [21:15:33.884]     if (base::is.na(TRUE)) {
  [21:15:33.884]     }
  [21:15:33.884]     else {
  [21:15:33.884]         if (TRUE) {
  [21:15:33.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.884]                 open = "w")
  [21:15:33.884]         }
  [21:15:33.884]         else {
  [21:15:33.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.884]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.884]         }
  [21:15:33.884]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.884]             base::sink(type = "output", split = FALSE)
  [21:15:33.884]             base::close(...future.stdout)
  [21:15:33.884]         }, add = TRUE)
  [21:15:33.884]     }
  [21:15:33.884]     ...future.frame <- base::sys.nframe()
  [21:15:33.884]     ...future.conditions <- base::list()
  [21:15:33.884]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.884]     ...future.result <- base::tryCatch({
  [21:15:33.884]         base::withCallingHandlers({
  [21:15:33.884]             ...future.value <- base::withVisible(base::local({
  [21:15:33.884]                 sample(x, size = 1L)
  [21:15:33.884]             }))
  [21:15:33.884]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.884]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.884]                 version = "1.8")
  [21:15:33.884]         }, condition = base::local({
  [21:15:33.884]             c <- base::c
  [21:15:33.884]             inherits <- base::inherits
  [21:15:33.884]             invokeRestart <- base::invokeRestart
  [21:15:33.884]             length <- base::length
  [21:15:33.884]             list <- base::list
  [21:15:33.884]             seq.int <- base::seq.int
  [21:15:33.884]             signalCondition <- base::signalCondition
  [21:15:33.884]             sys.calls <- base::sys.calls
  [21:15:33.884]             Sys.time <- base::Sys.time
  [21:15:33.884]             `[[` <- base::`[[`
  [21:15:33.884]             `+` <- base::`+`
  [21:15:33.884]             `<<-` <- base::`<<-`
  [21:15:33.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.884]                   3L)]
  [21:15:33.884]             }
  [21:15:33.884]             function(cond) {
  [21:15:33.884]                 if (inherits(cond, "error")) {
  [21:15:33.884]                   sessionInformation <- function() {
  [21:15:33.884]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.884]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.884]                       search = base::search(), system = base::Sys.info())
  [21:15:33.884]                   }
  [21:15:33.884]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.884]                     cond$call), session = sessionInformation(), 
  [21:15:33.884]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.884]                   signalCondition(cond)
  [21:15:33.884]                 }
  [21:15:33.884]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.884]                 ))) {
  [21:15:33.884]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.884]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.884]                   if (!signal) {
  [21:15:33.884]                     muffleCondition <- function (cond) 
  [21:15:33.884]                     {
  [21:15:33.884]                       inherits <- base::inherits
  [21:15:33.884]                       invokeRestart <- base::invokeRestart
  [21:15:33.884]                       muffled <- FALSE
  [21:15:33.884]                       if (inherits(cond, "message")) {
  [21:15:33.884]                         invokeRestart("muffleMessage")
  [21:15:33.884]                         muffled <- TRUE
  [21:15:33.884]                       }
  [21:15:33.884]                       else if (inherits(cond, "warning")) {
  [21:15:33.884]                         invokeRestart("muffleWarning")
  [21:15:33.884]                         muffled <- TRUE
  [21:15:33.884]                       }
  [21:15:33.884]                       else if (inherits(cond, "condition")) {
  [21:15:33.884]                         computeRestarts <- base::computeRestarts
  [21:15:33.884]                         grepl <- base::grepl
  [21:15:33.884]                         is.null <- base::is.null
  [21:15:33.884]                         restarts <- computeRestarts(cond)
  [21:15:33.884]                         for (restart in restarts) {
  [21:15:33.884]                           name <- restart$name
  [21:15:33.884]                           if (is.null(name)) 
  [21:15:33.884]                             next
  [21:15:33.884]                           if (!grepl("^muffle", name)) 
  [21:15:33.884]                             next
  [21:15:33.884]                           invokeRestart(restart)
  [21:15:33.884]                           muffled <- TRUE
  [21:15:33.884]                           break
  [21:15:33.884]                         }
  [21:15:33.884]                       }
  [21:15:33.884]                       invisible(muffled)
  [21:15:33.884]                     }
  [21:15:33.884]                     muffleCondition(cond)
  [21:15:33.884]                   }
  [21:15:33.884]                 }
  [21:15:33.884]             }
  [21:15:33.884]         }))
  [21:15:33.884]     }, error = function(ex) {
  [21:15:33.884]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.884]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.884]     }, finally = {
  [21:15:33.884]         {
  [21:15:33.884]             NULL
  [21:15:33.884]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.884]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.884]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.884]                 label = NULL, ...) 
  [21:15:33.884]             {
  [21:15:33.884]                 if (substitute) 
  [21:15:33.884]                   expr <- substitute(expr)
  [21:15:33.884]                 local <- as.logical(local)
  [21:15:33.884]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.884]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.884]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.884]                   label = label, ...)
  [21:15:33.884]                 if (!future$lazy) 
  [21:15:33.884]                   future <- run(future)
  [21:15:33.884]                 invisible(future)
  [21:15:33.884]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.884]         }
  [21:15:33.884]         base::options(...future.oldOptions)
  [21:15:33.884]     })
  [21:15:33.884]     Sys.time
  [21:15:33.884]     if (base::is.na(TRUE)) {
  [21:15:33.884]     }
  [21:15:33.884]     else {
  [21:15:33.884]         base::sink(type = "output", split = FALSE)
  [21:15:33.884]         if (TRUE) {
  [21:15:33.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.884]         }
  [21:15:33.884]         else {
  [21:15:33.884]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.884]         }
  [21:15:33.884]         base::close(...future.stdout)
  [21:15:33.884]         ...future.stdout <- NULL
  [21:15:33.884]     }
  [21:15:33.884]     ...future.result$conditions <- ...future.conditions
  [21:15:33.884]     ...future.result
  [21:15:33.884] }
  [21:15:33.889] plan(): Setting new future strategy stack:
  [21:15:33.889] List of future strategies:
  [21:15:33.889] 1. sequential:
  [21:15:33.889]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.889]    - tweaked: FALSE
  [21:15:33.889]    - call: NULL
  [21:15:33.890] plan(): nbrOfWorkers() = 1
  [21:15:33.891] plan(): Setting new future strategy stack:
  [21:15:33.891] List of future strategies:
  [21:15:33.891] 1. sequential:
  [21:15:33.891]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.891]    - tweaked: FALSE
  [21:15:33.891]    - call: plan(strategy)
  [21:15:33.892] plan(): nbrOfWorkers() = 1
  [21:15:33.896] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-728332'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ac0f800>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.898] resolve() on list ...
  [21:15:33.898]  recursive: 0
  [21:15:33.899]  length: 4
  [21:15:33.899] 
  [21:15:33.899] Future #1
  [21:15:33.899] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:33.900] - nx: 4
  [21:15:33.900] - relay: TRUE
  [21:15:33.900] - stdout: TRUE
  [21:15:33.900] - signal: TRUE
  [21:15:33.901] - resignal: FALSE
  [21:15:33.901] - force: TRUE
  [21:15:33.901] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.902] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:33.902]  - until=1
  [21:15:33.902]  - relaying element #1
  [21:15:33.903] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.903] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.903] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:33.903]  length: 3 (resolved future 1)
  [21:15:33.904] Future #2
  [21:15:33.904] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:33.904] - nx: 4
  [21:15:33.905] - relay: TRUE
  [21:15:33.905] - stdout: TRUE
  [21:15:33.905] - signal: TRUE
  [21:15:33.905] - resignal: FALSE
  [21:15:33.905] - force: TRUE
  [21:15:33.906] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.906] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:33.906]  - until=2
  [21:15:33.906]  - relaying element #2
  [21:15:33.907] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.907] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.907] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:33.908]  length: 2 (resolved future 2)
  [21:15:33.908] Future #3
  [21:15:33.908] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:33.909] - nx: 4
  [21:15:33.909] - relay: TRUE
  [21:15:33.909] - stdout: TRUE
  [21:15:33.909] - signal: TRUE
  [21:15:33.910] - resignal: FALSE
  [21:15:33.910] - force: TRUE
  [21:15:33.910] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.910] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:33.911]  - until=3
  [21:15:33.911]  - relaying element #3
  [21:15:33.911] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.911] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.912] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:33.912]  length: 1 (resolved future 3)
  [21:15:33.912] Future #4
  [21:15:33.913] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:33.913] - nx: 4
  [21:15:33.913] - relay: TRUE
  [21:15:33.913] - stdout: TRUE
  [21:15:33.914] - signal: TRUE
  [21:15:33.914] - resignal: FALSE
  [21:15:33.914] - force: TRUE
  [21:15:33.914] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.915] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:33.915]  - until=4
  [21:15:33.915]  - relaying element #4
  [21:15:33.916] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.916] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.916] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:33.916]  length: 0 (resolved future 4)
  [21:15:33.917] Relaying remaining futures
  [21:15:33.917] signalConditionsASAP(NULL, pos=0) ...
  [21:15:33.917] - nx: 4
  [21:15:33.917] - relay: TRUE
  [21:15:33.918] - stdout: TRUE
  [21:15:33.918] - signal: TRUE
  [21:15:33.918] - resignal: FALSE
  [21:15:33.918] - force: TRUE
  [21:15:33.918] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.919] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:33.919] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.919] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:33.920] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:33.920] resolve() on list ... DONE
  [[1]]
  [1] 2
  
  [[2]]
  [1] 3
  
  [[3]]
  [1] 1
  
  [[4]]
  [1] 0
  
  [21:15:33.921] getGlobalsAndPackages() ...
  [21:15:33.921] Searching for globals...
  [21:15:33.923] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.924] Searching for globals ... DONE
  [21:15:33.924] Resolving globals: FALSE
  [21:15:33.925] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.925] - globals: [1] 'x'
  [21:15:33.925] 
  [21:15:33.926] getGlobalsAndPackages() ... DONE
  [21:15:33.927] Packages needed by the future expression (n = 0): <none>
  [21:15:33.928] Packages needed by future strategies (n = 0): <none>
  [21:15:33.932] {
  [21:15:33.932]     {
  [21:15:33.932]         ...future.startTime <- base::Sys.time()
  [21:15:33.932]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.932]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.932]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.932]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.932]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.932]         {
  [21:15:33.932]             {
  [21:15:33.932]                 base::local({
  [21:15:33.932]                   has_future <- base::requireNamespace("future", 
  [21:15:33.932]                     quietly = TRUE)
  [21:15:33.932]                   version <- if (has_future) 
  [21:15:33.932]                     utils::packageVersion("future")
  [21:15:33.932]                   else NULL
  [21:15:33.932]                   if (!has_future || version < "1.8.0") {
  [21:15:33.932]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.932]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.932]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.932]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.932]                         "release", "version")], collapse = " "), 
  [21:15:33.932]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.932]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.932]                       info)
  [21:15:33.932]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.932]                     if (!has_future) {
  [21:15:33.932]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.932]                         info)
  [21:15:33.932]                     }
  [21:15:33.932]                     else {
  [21:15:33.932]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.932]                         info, version)
  [21:15:33.932]                     }
  [21:15:33.932]                     base::stop(msg)
  [21:15:33.932]                   }
  [21:15:33.932]                 })
  [21:15:33.932]             }
  [21:15:33.932]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.932]         }
  [21:15:33.932]     }
  [21:15:33.932]     if (base::is.na(TRUE)) {
  [21:15:33.932]     }
  [21:15:33.932]     else {
  [21:15:33.932]         if (TRUE) {
  [21:15:33.932]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.932]                 open = "w")
  [21:15:33.932]         }
  [21:15:33.932]         else {
  [21:15:33.932]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.932]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.932]         }
  [21:15:33.932]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.932]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.932]             base::sink(type = "output", split = FALSE)
  [21:15:33.932]             base::close(...future.stdout)
  [21:15:33.932]         }, add = TRUE)
  [21:15:33.932]     }
  [21:15:33.932]     ...future.frame <- base::sys.nframe()
  [21:15:33.932]     ...future.conditions <- base::list()
  [21:15:33.932]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.932]     ...future.result <- base::tryCatch({
  [21:15:33.932]         base::withCallingHandlers({
  [21:15:33.932]             ...future.value <- base::withVisible(base::local({
  [21:15:33.932]                 sample(x, size = 1L)
  [21:15:33.932]             }))
  [21:15:33.932]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.932]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.932]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.932]                 version = "1.8")
  [21:15:33.932]         }, condition = base::local({
  [21:15:33.932]             c <- base::c
  [21:15:33.932]             inherits <- base::inherits
  [21:15:33.932]             invokeRestart <- base::invokeRestart
  [21:15:33.932]             length <- base::length
  [21:15:33.932]             list <- base::list
  [21:15:33.932]             seq.int <- base::seq.int
  [21:15:33.932]             signalCondition <- base::signalCondition
  [21:15:33.932]             sys.calls <- base::sys.calls
  [21:15:33.932]             Sys.time <- base::Sys.time
  [21:15:33.932]             `[[` <- base::`[[`
  [21:15:33.932]             `+` <- base::`+`
  [21:15:33.932]             `<<-` <- base::`<<-`
  [21:15:33.932]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.932]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.932]                   3L)]
  [21:15:33.932]             }
  [21:15:33.932]             function(cond) {
  [21:15:33.932]                 if (inherits(cond, "error")) {
  [21:15:33.932]                   sessionInformation <- function() {
  [21:15:33.932]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.932]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.932]                       search = base::search(), system = base::Sys.info())
  [21:15:33.932]                   }
  [21:15:33.932]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.932]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.932]                     cond$call), session = sessionInformation(), 
  [21:15:33.932]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.932]                   signalCondition(cond)
  [21:15:33.932]                 }
  [21:15:33.932]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.932]                 ))) {
  [21:15:33.932]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.932]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.932]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.932]                   if (!signal) {
  [21:15:33.932]                     muffleCondition <- function (cond) 
  [21:15:33.932]                     {
  [21:15:33.932]                       inherits <- base::inherits
  [21:15:33.932]                       invokeRestart <- base::invokeRestart
  [21:15:33.932]                       muffled <- FALSE
  [21:15:33.932]                       if (inherits(cond, "message")) {
  [21:15:33.932]                         invokeRestart("muffleMessage")
  [21:15:33.932]                         muffled <- TRUE
  [21:15:33.932]                       }
  [21:15:33.932]                       else if (inherits(cond, "warning")) {
  [21:15:33.932]                         invokeRestart("muffleWarning")
  [21:15:33.932]                         muffled <- TRUE
  [21:15:33.932]                       }
  [21:15:33.932]                       else if (inherits(cond, "condition")) {
  [21:15:33.932]                         computeRestarts <- base::computeRestarts
  [21:15:33.932]                         grepl <- base::grepl
  [21:15:33.932]                         is.null <- base::is.null
  [21:15:33.932]                         restarts <- computeRestarts(cond)
  [21:15:33.932]                         for (restart in restarts) {
  [21:15:33.932]                           name <- restart$name
  [21:15:33.932]                           if (is.null(name)) 
  [21:15:33.932]                             next
  [21:15:33.932]                           if (!grepl("^muffle", name)) 
  [21:15:33.932]                             next
  [21:15:33.932]                           invokeRestart(restart)
  [21:15:33.932]                           muffled <- TRUE
  [21:15:33.932]                           break
  [21:15:33.932]                         }
  [21:15:33.932]                       }
  [21:15:33.932]                       invisible(muffled)
  [21:15:33.932]                     }
  [21:15:33.932]                     muffleCondition(cond)
  [21:15:33.932]                   }
  [21:15:33.932]                 }
  [21:15:33.932]             }
  [21:15:33.932]         }))
  [21:15:33.932]     }, error = function(ex) {
  [21:15:33.932]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.932]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.932]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.932]     }, finally = {
  [21:15:33.932]         {
  [21:15:33.932]             NULL
  [21:15:33.932]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.932]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.932]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.932]                 label = NULL, ...) 
  [21:15:33.932]             {
  [21:15:33.932]                 if (substitute) 
  [21:15:33.932]                   expr <- substitute(expr)
  [21:15:33.932]                 local <- as.logical(local)
  [21:15:33.932]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.932]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.932]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.932]                   label = label, ...)
  [21:15:33.932]                 if (!future$lazy) 
  [21:15:33.932]                   future <- run(future)
  [21:15:33.932]                 invisible(future)
  [21:15:33.932]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.932]         }
  [21:15:33.932]         base::options(...future.oldOptions)
  [21:15:33.932]     })
  [21:15:33.932]     Sys.time
  [21:15:33.932]     if (base::is.na(TRUE)) {
  [21:15:33.932]     }
  [21:15:33.932]     else {
  [21:15:33.932]         base::sink(type = "output", split = FALSE)
  [21:15:33.932]         if (TRUE) {
  [21:15:33.932]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.932]         }
  [21:15:33.932]         else {
  [21:15:33.932]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.932]         }
  [21:15:33.932]         base::close(...future.stdout)
  [21:15:33.932]         ...future.stdout <- NULL
  [21:15:33.932]     }
  [21:15:33.932]     ...future.result$conditions <- ...future.conditions
  [21:15:33.932]     ...future.result
  [21:15:33.932] }
  [21:15:33.937] plan(): Setting new future strategy stack:
  [21:15:33.937] List of future strategies:
  [21:15:33.937] 1. sequential:
  [21:15:33.937]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.937]    - tweaked: FALSE
  [21:15:33.937]    - call: NULL
  [21:15:33.938] plan(): nbrOfWorkers() = 1
  [21:15:33.939] plan(): Setting new future strategy stack:
  [21:15:33.940] List of future strategies:
  [21:15:33.940] 1. sequential:
  [21:15:33.940]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.940]    - tweaked: FALSE
  [21:15:33.940]    - call: plan(strategy)
  [21:15:33.941] plan(): nbrOfWorkers() = 1
  [21:15:33.941] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-547708'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349e795e0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.943] getGlobalsAndPackages() ...
  [21:15:33.943] Searching for globals...
  [21:15:33.945] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.945] Searching for globals ... DONE
  [21:15:33.946] Resolving globals: FALSE
  [21:15:33.947] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.947] - globals: [1] 'x'
  [21:15:33.947] 
  [21:15:33.948] getGlobalsAndPackages() ... DONE
  [21:15:33.949] Packages needed by the future expression (n = 0): <none>
  [21:15:33.949] Packages needed by future strategies (n = 0): <none>
  [21:15:33.954] {
  [21:15:33.954]     {
  [21:15:33.954]         ...future.startTime <- base::Sys.time()
  [21:15:33.954]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.954]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.954]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.954]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.954]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.954]         {
  [21:15:33.954]             {
  [21:15:33.954]                 base::local({
  [21:15:33.954]                   has_future <- base::requireNamespace("future", 
  [21:15:33.954]                     quietly = TRUE)
  [21:15:33.954]                   version <- if (has_future) 
  [21:15:33.954]                     utils::packageVersion("future")
  [21:15:33.954]                   else NULL
  [21:15:33.954]                   if (!has_future || version < "1.8.0") {
  [21:15:33.954]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.954]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.954]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.954]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.954]                         "release", "version")], collapse = " "), 
  [21:15:33.954]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.954]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.954]                       info)
  [21:15:33.954]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.954]                     if (!has_future) {
  [21:15:33.954]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.954]                         info)
  [21:15:33.954]                     }
  [21:15:33.954]                     else {
  [21:15:33.954]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.954]                         info, version)
  [21:15:33.954]                     }
  [21:15:33.954]                     base::stop(msg)
  [21:15:33.954]                   }
  [21:15:33.954]                 })
  [21:15:33.954]             }
  [21:15:33.954]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.954]         }
  [21:15:33.954]     }
  [21:15:33.954]     if (base::is.na(TRUE)) {
  [21:15:33.954]     }
  [21:15:33.954]     else {
  [21:15:33.954]         if (TRUE) {
  [21:15:33.954]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.954]                 open = "w")
  [21:15:33.954]         }
  [21:15:33.954]         else {
  [21:15:33.954]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.954]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.954]         }
  [21:15:33.954]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.954]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.954]             base::sink(type = "output", split = FALSE)
  [21:15:33.954]             base::close(...future.stdout)
  [21:15:33.954]         }, add = TRUE)
  [21:15:33.954]     }
  [21:15:33.954]     ...future.frame <- base::sys.nframe()
  [21:15:33.954]     ...future.conditions <- base::list()
  [21:15:33.954]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.954]     ...future.result <- base::tryCatch({
  [21:15:33.954]         base::withCallingHandlers({
  [21:15:33.954]             ...future.value <- base::withVisible(base::local({
  [21:15:33.954]                 sample(x, size = 1L)
  [21:15:33.954]             }))
  [21:15:33.954]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.954]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.954]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.954]                 version = "1.8")
  [21:15:33.954]         }, condition = base::local({
  [21:15:33.954]             c <- base::c
  [21:15:33.954]             inherits <- base::inherits
  [21:15:33.954]             invokeRestart <- base::invokeRestart
  [21:15:33.954]             length <- base::length
  [21:15:33.954]             list <- base::list
  [21:15:33.954]             seq.int <- base::seq.int
  [21:15:33.954]             signalCondition <- base::signalCondition
  [21:15:33.954]             sys.calls <- base::sys.calls
  [21:15:33.954]             Sys.time <- base::Sys.time
  [21:15:33.954]             `[[` <- base::`[[`
  [21:15:33.954]             `+` <- base::`+`
  [21:15:33.954]             `<<-` <- base::`<<-`
  [21:15:33.954]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.954]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.954]                   3L)]
  [21:15:33.954]             }
  [21:15:33.954]             function(cond) {
  [21:15:33.954]                 if (inherits(cond, "error")) {
  [21:15:33.954]                   sessionInformation <- function() {
  [21:15:33.954]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.954]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.954]                       search = base::search(), system = base::Sys.info())
  [21:15:33.954]                   }
  [21:15:33.954]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.954]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.954]                     cond$call), session = sessionInformation(), 
  [21:15:33.954]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.954]                   signalCondition(cond)
  [21:15:33.954]                 }
  [21:15:33.954]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.954]                 ))) {
  [21:15:33.954]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.954]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.954]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.954]                   if (!signal) {
  [21:15:33.954]                     muffleCondition <- function (cond) 
  [21:15:33.954]                     {
  [21:15:33.954]                       inherits <- base::inherits
  [21:15:33.954]                       invokeRestart <- base::invokeRestart
  [21:15:33.954]                       muffled <- FALSE
  [21:15:33.954]                       if (inherits(cond, "message")) {
  [21:15:33.954]                         invokeRestart("muffleMessage")
  [21:15:33.954]                         muffled <- TRUE
  [21:15:33.954]                       }
  [21:15:33.954]                       else if (inherits(cond, "warning")) {
  [21:15:33.954]                         invokeRestart("muffleWarning")
  [21:15:33.954]                         muffled <- TRUE
  [21:15:33.954]                       }
  [21:15:33.954]                       else if (inherits(cond, "condition")) {
  [21:15:33.954]                         computeRestarts <- base::computeRestarts
  [21:15:33.954]                         grepl <- base::grepl
  [21:15:33.954]                         is.null <- base::is.null
  [21:15:33.954]                         restarts <- computeRestarts(cond)
  [21:15:33.954]                         for (restart in restarts) {
  [21:15:33.954]                           name <- restart$name
  [21:15:33.954]                           if (is.null(name)) 
  [21:15:33.954]                             next
  [21:15:33.954]                           if (!grepl("^muffle", name)) 
  [21:15:33.954]                             next
  [21:15:33.954]                           invokeRestart(restart)
  [21:15:33.954]                           muffled <- TRUE
  [21:15:33.954]                           break
  [21:15:33.954]                         }
  [21:15:33.954]                       }
  [21:15:33.954]                       invisible(muffled)
  [21:15:33.954]                     }
  [21:15:33.954]                     muffleCondition(cond)
  [21:15:33.954]                   }
  [21:15:33.954]                 }
  [21:15:33.954]             }
  [21:15:33.954]         }))
  [21:15:33.954]     }, error = function(ex) {
  [21:15:33.954]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.954]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.954]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.954]     }, finally = {
  [21:15:33.954]         {
  [21:15:33.954]             NULL
  [21:15:33.954]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.954]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.954]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.954]                 label = NULL, ...) 
  [21:15:33.954]             {
  [21:15:33.954]                 if (substitute) 
  [21:15:33.954]                   expr <- substitute(expr)
  [21:15:33.954]                 local <- as.logical(local)
  [21:15:33.954]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.954]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.954]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.954]                   label = label, ...)
  [21:15:33.954]                 if (!future$lazy) 
  [21:15:33.954]                   future <- run(future)
  [21:15:33.954]                 invisible(future)
  [21:15:33.954]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.954]         }
  [21:15:33.954]         base::options(...future.oldOptions)
  [21:15:33.954]     })
  [21:15:33.954]     Sys.time
  [21:15:33.954]     if (base::is.na(TRUE)) {
  [21:15:33.954]     }
  [21:15:33.954]     else {
  [21:15:33.954]         base::sink(type = "output", split = FALSE)
  [21:15:33.954]         if (TRUE) {
  [21:15:33.954]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.954]         }
  [21:15:33.954]         else {
  [21:15:33.954]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.954]         }
  [21:15:33.954]         base::close(...future.stdout)
  [21:15:33.954]         ...future.stdout <- NULL
  [21:15:33.954]     }
  [21:15:33.954]     ...future.result$conditions <- ...future.conditions
  [21:15:33.954]     ...future.result
  [21:15:33.954] }
  [21:15:33.959] plan(): Setting new future strategy stack:
  [21:15:33.959] List of future strategies:
  [21:15:33.959] 1. sequential:
  [21:15:33.959]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.959]    - tweaked: FALSE
  [21:15:33.959]    - call: NULL
  [21:15:33.960] plan(): nbrOfWorkers() = 1
  [21:15:33.961] plan(): Setting new future strategy stack:
  [21:15:33.961] List of future strategies:
  [21:15:33.961] 1. sequential:
  [21:15:33.961]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.961]    - tweaked: FALSE
  [21:15:33.961]    - call: plan(strategy)
  [21:15:33.962] plan(): nbrOfWorkers() = 1
  [21:15:33.966] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-355538'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349e795e0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.968] getGlobalsAndPackages() ...
  [21:15:33.968] Searching for globals...
  [21:15:33.970] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.971] Searching for globals ... DONE
  [21:15:33.971] Resolving globals: FALSE
  [21:15:33.972] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.972] - globals: [1] 'x'
  [21:15:33.972] 
  [21:15:33.973] getGlobalsAndPackages() ... DONE
  [21:15:33.974] Packages needed by the future expression (n = 0): <none>
  [21:15:33.975] Packages needed by future strategies (n = 0): <none>
  [21:15:33.979] {
  [21:15:33.979]     {
  [21:15:33.979]         ...future.startTime <- base::Sys.time()
  [21:15:33.979]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:33.979]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:33.979]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:33.979]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:33.979]             future.resolve.recursive = NULL, width = 80L)
  [21:15:33.979]         {
  [21:15:33.979]             {
  [21:15:33.979]                 base::local({
  [21:15:33.979]                   has_future <- base::requireNamespace("future", 
  [21:15:33.979]                     quietly = TRUE)
  [21:15:33.979]                   version <- if (has_future) 
  [21:15:33.979]                     utils::packageVersion("future")
  [21:15:33.979]                   else NULL
  [21:15:33.979]                   if (!has_future || version < "1.8.0") {
  [21:15:33.979]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:33.979]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:33.979]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:33.979]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:33.979]                         "release", "version")], collapse = " "), 
  [21:15:33.979]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:33.979]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:33.979]                       info)
  [21:15:33.979]                     info <- base::paste(info, collapse = "; ")
  [21:15:33.979]                     if (!has_future) {
  [21:15:33.979]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:33.979]                         info)
  [21:15:33.979]                     }
  [21:15:33.979]                     else {
  [21:15:33.979]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:33.979]                         info, version)
  [21:15:33.979]                     }
  [21:15:33.979]                     base::stop(msg)
  [21:15:33.979]                   }
  [21:15:33.979]                 })
  [21:15:33.979]             }
  [21:15:33.979]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:33.979]         }
  [21:15:33.979]     }
  [21:15:33.979]     if (base::is.na(TRUE)) {
  [21:15:33.979]     }
  [21:15:33.979]     else {
  [21:15:33.979]         if (TRUE) {
  [21:15:33.979]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:33.979]                 open = "w")
  [21:15:33.979]         }
  [21:15:33.979]         else {
  [21:15:33.979]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:33.979]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:33.979]         }
  [21:15:33.979]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:33.979]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:33.979]             base::sink(type = "output", split = FALSE)
  [21:15:33.979]             base::close(...future.stdout)
  [21:15:33.979]         }, add = TRUE)
  [21:15:33.979]     }
  [21:15:33.979]     ...future.frame <- base::sys.nframe()
  [21:15:33.979]     ...future.conditions <- base::list()
  [21:15:33.979]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:33.979]     ...future.result <- base::tryCatch({
  [21:15:33.979]         base::withCallingHandlers({
  [21:15:33.979]             ...future.value <- base::withVisible(base::local({
  [21:15:33.979]                 sample(x, size = 1L)
  [21:15:33.979]             }))
  [21:15:33.979]             future::FutureResult(value = ...future.value$value, 
  [21:15:33.979]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.979]                   ...future.rng), started = ...future.startTime, 
  [21:15:33.979]                 version = "1.8")
  [21:15:33.979]         }, condition = base::local({
  [21:15:33.979]             c <- base::c
  [21:15:33.979]             inherits <- base::inherits
  [21:15:33.979]             invokeRestart <- base::invokeRestart
  [21:15:33.979]             length <- base::length
  [21:15:33.979]             list <- base::list
  [21:15:33.979]             seq.int <- base::seq.int
  [21:15:33.979]             signalCondition <- base::signalCondition
  [21:15:33.979]             sys.calls <- base::sys.calls
  [21:15:33.979]             Sys.time <- base::Sys.time
  [21:15:33.979]             `[[` <- base::`[[`
  [21:15:33.979]             `+` <- base::`+`
  [21:15:33.979]             `<<-` <- base::`<<-`
  [21:15:33.979]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:33.979]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:33.979]                   3L)]
  [21:15:33.979]             }
  [21:15:33.979]             function(cond) {
  [21:15:33.979]                 if (inherits(cond, "error")) {
  [21:15:33.979]                   sessionInformation <- function() {
  [21:15:33.979]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:33.979]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:33.979]                       search = base::search(), system = base::Sys.info())
  [21:15:33.979]                   }
  [21:15:33.979]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.979]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:33.979]                     cond$call), session = sessionInformation(), 
  [21:15:33.979]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:33.979]                   signalCondition(cond)
  [21:15:33.979]                 }
  [21:15:33.979]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:33.979]                 ))) {
  [21:15:33.979]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:33.979]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:33.979]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:33.979]                   if (!signal) {
  [21:15:33.979]                     muffleCondition <- function (cond) 
  [21:15:33.979]                     {
  [21:15:33.979]                       inherits <- base::inherits
  [21:15:33.979]                       invokeRestart <- base::invokeRestart
  [21:15:33.979]                       muffled <- FALSE
  [21:15:33.979]                       if (inherits(cond, "message")) {
  [21:15:33.979]                         invokeRestart("muffleMessage")
  [21:15:33.979]                         muffled <- TRUE
  [21:15:33.979]                       }
  [21:15:33.979]                       else if (inherits(cond, "warning")) {
  [21:15:33.979]                         invokeRestart("muffleWarning")
  [21:15:33.979]                         muffled <- TRUE
  [21:15:33.979]                       }
  [21:15:33.979]                       else if (inherits(cond, "condition")) {
  [21:15:33.979]                         computeRestarts <- base::computeRestarts
  [21:15:33.979]                         grepl <- base::grepl
  [21:15:33.979]                         is.null <- base::is.null
  [21:15:33.979]                         restarts <- computeRestarts(cond)
  [21:15:33.979]                         for (restart in restarts) {
  [21:15:33.979]                           name <- restart$name
  [21:15:33.979]                           if (is.null(name)) 
  [21:15:33.979]                             next
  [21:15:33.979]                           if (!grepl("^muffle", name)) 
  [21:15:33.979]                             next
  [21:15:33.979]                           invokeRestart(restart)
  [21:15:33.979]                           muffled <- TRUE
  [21:15:33.979]                           break
  [21:15:33.979]                         }
  [21:15:33.979]                       }
  [21:15:33.979]                       invisible(muffled)
  [21:15:33.979]                     }
  [21:15:33.979]                     muffleCondition(cond)
  [21:15:33.979]                   }
  [21:15:33.979]                 }
  [21:15:33.979]             }
  [21:15:33.979]         }))
  [21:15:33.979]     }, error = function(ex) {
  [21:15:33.979]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:33.979]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:33.979]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:33.979]     }, finally = {
  [21:15:33.979]         {
  [21:15:33.979]             NULL
  [21:15:33.979]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:33.979]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:33.979]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:33.979]                 label = NULL, ...) 
  [21:15:33.979]             {
  [21:15:33.979]                 if (substitute) 
  [21:15:33.979]                   expr <- substitute(expr)
  [21:15:33.979]                 local <- as.logical(local)
  [21:15:33.979]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:33.979]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:33.979]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:33.979]                   label = label, ...)
  [21:15:33.979]                 if (!future$lazy) 
  [21:15:33.979]                   future <- run(future)
  [21:15:33.979]                 invisible(future)
  [21:15:33.979]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:33.979]         }
  [21:15:33.979]         base::options(...future.oldOptions)
  [21:15:33.979]     })
  [21:15:33.979]     Sys.time
  [21:15:33.979]     if (base::is.na(TRUE)) {
  [21:15:33.979]     }
  [21:15:33.979]     else {
  [21:15:33.979]         base::sink(type = "output", split = FALSE)
  [21:15:33.979]         if (TRUE) {
  [21:15:33.979]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:33.979]         }
  [21:15:33.979]         else {
  [21:15:33.979]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:33.979]         }
  [21:15:33.979]         base::close(...future.stdout)
  [21:15:33.979]         ...future.stdout <- NULL
  [21:15:33.979]     }
  [21:15:33.979]     ...future.result$conditions <- ...future.conditions
  [21:15:33.979]     ...future.result
  [21:15:33.979] }
  [21:15:33.983] plan(): Setting new future strategy stack:
  [21:15:33.984] List of future strategies:
  [21:15:33.984] 1. sequential:
  [21:15:33.984]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.984]    - tweaked: FALSE
  [21:15:33.984]    - call: NULL
  [21:15:33.984] plan(): nbrOfWorkers() = 1
  [21:15:33.986] plan(): Setting new future strategy stack:
  [21:15:33.986] List of future strategies:
  [21:15:33.986] 1. sequential:
  [21:15:33.986]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:33.986]    - tweaked: FALSE
  [21:15:33.986]    - call: plan(strategy)
  [21:15:33.987] plan(): nbrOfWorkers() = 1
  [21:15:33.987] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-789349'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349e795e0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:33.989] getGlobalsAndPackages() ...
  [21:15:33.990] Searching for globals...
  [21:15:33.992] - globals found: [3] '{', 'sample', 'x'
  [21:15:33.992] Searching for globals ... DONE
  [21:15:33.992] Resolving globals: FALSE
  [21:15:33.993] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:33.993] - globals: [1] 'x'
  [21:15:33.994] 
  [21:15:33.994] getGlobalsAndPackages() ... DONE
  [21:15:33.996] Packages needed by the future expression (n = 0): <none>
  [21:15:33.996] Packages needed by future strategies (n = 0): <none>
  [21:15:34.000] {
  [21:15:34.000]     {
  [21:15:34.000]         ...future.startTime <- base::Sys.time()
  [21:15:34.000]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.000]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.000]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.000]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.000]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.000]         {
  [21:15:34.000]             {
  [21:15:34.000]                 base::local({
  [21:15:34.000]                   has_future <- base::requireNamespace("future", 
  [21:15:34.000]                     quietly = TRUE)
  [21:15:34.000]                   version <- if (has_future) 
  [21:15:34.000]                     utils::packageVersion("future")
  [21:15:34.000]                   else NULL
  [21:15:34.000]                   if (!has_future || version < "1.8.0") {
  [21:15:34.000]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.000]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.000]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.000]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.000]                         "release", "version")], collapse = " "), 
  [21:15:34.000]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.000]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.000]                       info)
  [21:15:34.000]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.000]                     if (!has_future) {
  [21:15:34.000]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.000]                         info)
  [21:15:34.000]                     }
  [21:15:34.000]                     else {
  [21:15:34.000]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.000]                         info, version)
  [21:15:34.000]                     }
  [21:15:34.000]                     base::stop(msg)
  [21:15:34.000]                   }
  [21:15:34.000]                 })
  [21:15:34.000]             }
  [21:15:34.000]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.000]         }
  [21:15:34.000]     }
  [21:15:34.000]     if (base::is.na(TRUE)) {
  [21:15:34.000]     }
  [21:15:34.000]     else {
  [21:15:34.000]         if (TRUE) {
  [21:15:34.000]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.000]                 open = "w")
  [21:15:34.000]         }
  [21:15:34.000]         else {
  [21:15:34.000]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.000]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.000]         }
  [21:15:34.000]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.000]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.000]             base::sink(type = "output", split = FALSE)
  [21:15:34.000]             base::close(...future.stdout)
  [21:15:34.000]         }, add = TRUE)
  [21:15:34.000]     }
  [21:15:34.000]     ...future.frame <- base::sys.nframe()
  [21:15:34.000]     ...future.conditions <- base::list()
  [21:15:34.000]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.000]     ...future.result <- base::tryCatch({
  [21:15:34.000]         base::withCallingHandlers({
  [21:15:34.000]             ...future.value <- base::withVisible(base::local({
  [21:15:34.000]                 sample(x, size = 1L)
  [21:15:34.000]             }))
  [21:15:34.000]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.000]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.000]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.000]                 version = "1.8")
  [21:15:34.000]         }, condition = base::local({
  [21:15:34.000]             c <- base::c
  [21:15:34.000]             inherits <- base::inherits
  [21:15:34.000]             invokeRestart <- base::invokeRestart
  [21:15:34.000]             length <- base::length
  [21:15:34.000]             list <- base::list
  [21:15:34.000]             seq.int <- base::seq.int
  [21:15:34.000]             signalCondition <- base::signalCondition
  [21:15:34.000]             sys.calls <- base::sys.calls
  [21:15:34.000]             Sys.time <- base::Sys.time
  [21:15:34.000]             `[[` <- base::`[[`
  [21:15:34.000]             `+` <- base::`+`
  [21:15:34.000]             `<<-` <- base::`<<-`
  [21:15:34.000]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.000]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.000]                   3L)]
  [21:15:34.000]             }
  [21:15:34.000]             function(cond) {
  [21:15:34.000]                 if (inherits(cond, "error")) {
  [21:15:34.000]                   sessionInformation <- function() {
  [21:15:34.000]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.000]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.000]                       search = base::search(), system = base::Sys.info())
  [21:15:34.000]                   }
  [21:15:34.000]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.000]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.000]                     cond$call), session = sessionInformation(), 
  [21:15:34.000]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.000]                   signalCondition(cond)
  [21:15:34.000]                 }
  [21:15:34.000]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.000]                 ))) {
  [21:15:34.000]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.000]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.000]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.000]                   if (!signal) {
  [21:15:34.000]                     muffleCondition <- function (cond) 
  [21:15:34.000]                     {
  [21:15:34.000]                       inherits <- base::inherits
  [21:15:34.000]                       invokeRestart <- base::invokeRestart
  [21:15:34.000]                       muffled <- FALSE
  [21:15:34.000]                       if (inherits(cond, "message")) {
  [21:15:34.000]                         invokeRestart("muffleMessage")
  [21:15:34.000]                         muffled <- TRUE
  [21:15:34.000]                       }
  [21:15:34.000]                       else if (inherits(cond, "warning")) {
  [21:15:34.000]                         invokeRestart("muffleWarning")
  [21:15:34.000]                         muffled <- TRUE
  [21:15:34.000]                       }
  [21:15:34.000]                       else if (inherits(cond, "condition")) {
  [21:15:34.000]                         computeRestarts <- base::computeRestarts
  [21:15:34.000]                         grepl <- base::grepl
  [21:15:34.000]                         is.null <- base::is.null
  [21:15:34.000]                         restarts <- computeRestarts(cond)
  [21:15:34.000]                         for (restart in restarts) {
  [21:15:34.000]                           name <- restart$name
  [21:15:34.000]                           if (is.null(name)) 
  [21:15:34.000]                             next
  [21:15:34.000]                           if (!grepl("^muffle", name)) 
  [21:15:34.000]                             next
  [21:15:34.000]                           invokeRestart(restart)
  [21:15:34.000]                           muffled <- TRUE
  [21:15:34.000]                           break
  [21:15:34.000]                         }
  [21:15:34.000]                       }
  [21:15:34.000]                       invisible(muffled)
  [21:15:34.000]                     }
  [21:15:34.000]                     muffleCondition(cond)
  [21:15:34.000]                   }
  [21:15:34.000]                 }
  [21:15:34.000]             }
  [21:15:34.000]         }))
  [21:15:34.000]     }, error = function(ex) {
  [21:15:34.000]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.000]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.000]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.000]     }, finally = {
  [21:15:34.000]         {
  [21:15:34.000]             NULL
  [21:15:34.000]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.000]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.000]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.000]                 label = NULL, ...) 
  [21:15:34.000]             {
  [21:15:34.000]                 if (substitute) 
  [21:15:34.000]                   expr <- substitute(expr)
  [21:15:34.000]                 local <- as.logical(local)
  [21:15:34.000]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.000]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.000]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.000]                   label = label, ...)
  [21:15:34.000]                 if (!future$lazy) 
  [21:15:34.000]                   future <- run(future)
  [21:15:34.000]                 invisible(future)
  [21:15:34.000]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.000]         }
  [21:15:34.000]         base::options(...future.oldOptions)
  [21:15:34.000]     })
  [21:15:34.000]     Sys.time
  [21:15:34.000]     if (base::is.na(TRUE)) {
  [21:15:34.000]     }
  [21:15:34.000]     else {
  [21:15:34.000]         base::sink(type = "output", split = FALSE)
  [21:15:34.000]         if (TRUE) {
  [21:15:34.000]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.000]         }
  [21:15:34.000]         else {
  [21:15:34.000]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.000]         }
  [21:15:34.000]         base::close(...future.stdout)
  [21:15:34.000]         ...future.stdout <- NULL
  [21:15:34.000]     }
  [21:15:34.000]     ...future.result$conditions <- ...future.conditions
  [21:15:34.000]     ...future.result
  [21:15:34.000] }
  [21:15:34.005] plan(): Setting new future strategy stack:
  [21:15:34.005] List of future strategies:
  [21:15:34.005] 1. sequential:
  [21:15:34.005]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.005]    - tweaked: FALSE
  [21:15:34.005]    - call: NULL
  [21:15:34.006] plan(): nbrOfWorkers() = 1
  [21:15:34.007] plan(): Setting new future strategy stack:
  [21:15:34.008] List of future strategies:
  [21:15:34.008] 1. sequential:
  [21:15:34.008]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.008]    - tweaked: FALSE
  [21:15:34.008]    - call: plan(strategy)
  [21:15:34.009] plan(): nbrOfWorkers() = 1
  [21:15:34.009] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-118552'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x563349e795e0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:34.011] resolve() on list ...
  [21:15:34.011]  recursive: 0
  [21:15:34.011]  length: 4
  [21:15:34.012] 
  [21:15:34.012] Future #1
  [21:15:34.013] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:34.013] - nx: 4
  [21:15:34.013] - relay: TRUE
  [21:15:34.013] - stdout: TRUE
  [21:15:34.014] - signal: TRUE
  [21:15:34.014] - resignal: FALSE
  [21:15:34.014] - force: TRUE
  [21:15:34.015] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:34.015] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:34.015]  - until=1
  [21:15:34.015]  - relaying element #1
  [21:15:34.016] signalConditions() ...
  [21:15:34.016]  - include = 'immediateCondition'
  [21:15:34.016]  - exclude = 
  [21:15:34.017]  - resignal = FALSE
  [21:15:34.017]  - Number of conditions: 1
  [21:15:34.017] signalConditions() ... done
  [21:15:34.018] signalConditions() ...
  [21:15:34.018]  - include = 'immediateCondition'
  [21:15:34.018]  - exclude = 
  [21:15:34.019]  - resignal = FALSE
  [21:15:34.019]  - Number of conditions: 1
  [21:15:34.019] signalConditions() ... done
  [21:15:34.019] signalConditions() ...
  [21:15:34.020]  - include = 'condition'
  [21:15:34.020]  - exclude = 'immediateCondition'
  [21:15:34.020]  - resignal = TRUE
  [21:15:34.021]  - Number of conditions: 1
  [21:15:34.021]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:15:34.021] signalConditions() ... done
  [21:15:34.021] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:34.022] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:34.022] signalConditionsASAP(SequentialFuture, pos=1) ... done
  <simpleError: UNRELIABLE VALUE: Future ('fsample_1-547708') unexpectedly generated random numbers without specifying argument '[future.]seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify argument argument '[future.]seed', e.g. 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, set option 'future.rng.onMisuse' to "ignore".>
  [21:15:34.023] getGlobalsAndPackages() ...
  [21:15:34.023] Searching for globals...
  [21:15:34.025] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.025] Searching for globals ... DONE
  [21:15:34.025] Resolving globals: FALSE
  [21:15:34.026] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.027] - globals: [1] 'x'
  [21:15:34.027] 
  [21:15:34.027] getGlobalsAndPackages() ... DONE
  [21:15:34.030] Packages needed by the future expression (n = 0): <none>
  [21:15:34.030] Packages needed by future strategies (n = 0): <none>
  [21:15:34.037] {
  [21:15:34.037]     {
  [21:15:34.037]         ...future.startTime <- base::Sys.time()
  [21:15:34.037]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.037]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.037]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.037]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.037]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.037]         {
  [21:15:34.037]             {
  [21:15:34.037]                 base::local({
  [21:15:34.037]                   has_future <- base::requireNamespace("future", 
  [21:15:34.037]                     quietly = TRUE)
  [21:15:34.037]                   version <- if (has_future) 
  [21:15:34.037]                     utils::packageVersion("future")
  [21:15:34.037]                   else NULL
  [21:15:34.037]                   if (!has_future || version < "1.8.0") {
  [21:15:34.037]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.037]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.037]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.037]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.037]                         "release", "version")], collapse = " "), 
  [21:15:34.037]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.037]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.037]                       info)
  [21:15:34.037]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.037]                     if (!has_future) {
  [21:15:34.037]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.037]                         info)
  [21:15:34.037]                     }
  [21:15:34.037]                     else {
  [21:15:34.037]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.037]                         info, version)
  [21:15:34.037]                     }
  [21:15:34.037]                     base::stop(msg)
  [21:15:34.037]                   }
  [21:15:34.037]                 })
  [21:15:34.037]             }
  [21:15:34.037]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.037]         }
  [21:15:34.037]     }
  [21:15:34.037]     if (base::is.na(TRUE)) {
  [21:15:34.037]     }
  [21:15:34.037]     else {
  [21:15:34.037]         if (TRUE) {
  [21:15:34.037]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.037]                 open = "w")
  [21:15:34.037]         }
  [21:15:34.037]         else {
  [21:15:34.037]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.037]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.037]         }
  [21:15:34.037]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.037]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.037]             base::sink(type = "output", split = FALSE)
  [21:15:34.037]             base::close(...future.stdout)
  [21:15:34.037]         }, add = TRUE)
  [21:15:34.037]     }
  [21:15:34.037]     ...future.frame <- base::sys.nframe()
  [21:15:34.037]     ...future.conditions <- base::list()
  [21:15:34.037]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.037]     ...future.result <- base::tryCatch({
  [21:15:34.037]         base::withCallingHandlers({
  [21:15:34.037]             ...future.value <- base::withVisible(base::local({
  [21:15:34.037]                 sample(x, size = 1L)
  [21:15:34.037]             }))
  [21:15:34.037]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.037]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.037]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.037]                 version = "1.8")
  [21:15:34.037]         }, condition = base::local({
  [21:15:34.037]             c <- base::c
  [21:15:34.037]             inherits <- base::inherits
  [21:15:34.037]             invokeRestart <- base::invokeRestart
  [21:15:34.037]             length <- base::length
  [21:15:34.037]             list <- base::list
  [21:15:34.037]             seq.int <- base::seq.int
  [21:15:34.037]             signalCondition <- base::signalCondition
  [21:15:34.037]             sys.calls <- base::sys.calls
  [21:15:34.037]             Sys.time <- base::Sys.time
  [21:15:34.037]             `[[` <- base::`[[`
  [21:15:34.037]             `+` <- base::`+`
  [21:15:34.037]             `<<-` <- base::`<<-`
  [21:15:34.037]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.037]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.037]                   3L)]
  [21:15:34.037]             }
  [21:15:34.037]             function(cond) {
  [21:15:34.037]                 if (inherits(cond, "error")) {
  [21:15:34.037]                   sessionInformation <- function() {
  [21:15:34.037]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.037]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.037]                       search = base::search(), system = base::Sys.info())
  [21:15:34.037]                   }
  [21:15:34.037]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.037]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.037]                     cond$call), session = sessionInformation(), 
  [21:15:34.037]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.037]                   signalCondition(cond)
  [21:15:34.037]                 }
  [21:15:34.037]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.037]                 ))) {
  [21:15:34.037]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.037]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.037]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.037]                   if (!signal) {
  [21:15:34.037]                     muffleCondition <- function (cond) 
  [21:15:34.037]                     {
  [21:15:34.037]                       inherits <- base::inherits
  [21:15:34.037]                       invokeRestart <- base::invokeRestart
  [21:15:34.037]                       muffled <- FALSE
  [21:15:34.037]                       if (inherits(cond, "message")) {
  [21:15:34.037]                         invokeRestart("muffleMessage")
  [21:15:34.037]                         muffled <- TRUE
  [21:15:34.037]                       }
  [21:15:34.037]                       else if (inherits(cond, "warning")) {
  [21:15:34.037]                         invokeRestart("muffleWarning")
  [21:15:34.037]                         muffled <- TRUE
  [21:15:34.037]                       }
  [21:15:34.037]                       else if (inherits(cond, "condition")) {
  [21:15:34.037]                         computeRestarts <- base::computeRestarts
  [21:15:34.037]                         grepl <- base::grepl
  [21:15:34.037]                         is.null <- base::is.null
  [21:15:34.037]                         restarts <- computeRestarts(cond)
  [21:15:34.037]                         for (restart in restarts) {
  [21:15:34.037]                           name <- restart$name
  [21:15:34.037]                           if (is.null(name)) 
  [21:15:34.037]                             next
  [21:15:34.037]                           if (!grepl("^muffle", name)) 
  [21:15:34.037]                             next
  [21:15:34.037]                           invokeRestart(restart)
  [21:15:34.037]                           muffled <- TRUE
  [21:15:34.037]                           break
  [21:15:34.037]                         }
  [21:15:34.037]                       }
  [21:15:34.037]                       invisible(muffled)
  [21:15:34.037]                     }
  [21:15:34.037]                     muffleCondition(cond)
  [21:15:34.037]                   }
  [21:15:34.037]                 }
  [21:15:34.037]             }
  [21:15:34.037]         }))
  [21:15:34.037]     }, error = function(ex) {
  [21:15:34.037]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.037]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.037]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.037]     }, finally = {
  [21:15:34.037]         {
  [21:15:34.037]             NULL
  [21:15:34.037]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.037]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.037]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.037]                 label = NULL, ...) 
  [21:15:34.037]             {
  [21:15:34.037]                 if (substitute) 
  [21:15:34.037]                   expr <- substitute(expr)
  [21:15:34.037]                 local <- as.logical(local)
  [21:15:34.037]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.037]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.037]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.037]                   label = label, ...)
  [21:15:34.037]                 if (!future$lazy) 
  [21:15:34.037]                   future <- run(future)
  [21:15:34.037]                 invisible(future)
  [21:15:34.037]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.037]         }
  [21:15:34.037]         base::options(...future.oldOptions)
  [21:15:34.037]     })
  [21:15:34.037]     Sys.time
  [21:15:34.037]     if (base::is.na(TRUE)) {
  [21:15:34.037]     }
  [21:15:34.037]     else {
  [21:15:34.037]         base::sink(type = "output", split = FALSE)
  [21:15:34.037]         if (TRUE) {
  [21:15:34.037]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.037]         }
  [21:15:34.037]         else {
  [21:15:34.037]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.037]         }
  [21:15:34.037]         base::close(...future.stdout)
  [21:15:34.037]         ...future.stdout <- NULL
  [21:15:34.037]     }
  [21:15:34.037]     ...future.result$conditions <- ...future.conditions
  [21:15:34.037]     ...future.result
  [21:15:34.037] }
  [21:15:34.042] plan(): Setting new future strategy stack:
  [21:15:34.042] List of future strategies:
  [21:15:34.042] 1. sequential:
  [21:15:34.042]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.042]    - tweaked: FALSE
  [21:15:34.042]    - call: NULL
  [21:15:34.043] plan(): nbrOfWorkers() = 1
  [21:15:34.044] plan(): Setting new future strategy stack:
  [21:15:34.044] List of future strategies:
  [21:15:34.044] 1. sequential:
  [21:15:34.044]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.044]    - tweaked: FALSE
  [21:15:34.044]    - call: plan(strategy)
  [21:15:34.045] plan(): nbrOfWorkers() = 1
  [21:15:34.046] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_1-824259'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ad3bde0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:34.047] getGlobalsAndPackages() ...
  [21:15:34.048] Searching for globals...
  [21:15:34.050] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.050] Searching for globals ... DONE
  [21:15:34.050] Resolving globals: FALSE
  [21:15:34.051] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.051] - globals: [1] 'x'
  [21:15:34.052] 
  [21:15:34.052] getGlobalsAndPackages() ... DONE
  [21:15:34.053] Packages needed by the future expression (n = 0): <none>
  [21:15:34.054] Packages needed by future strategies (n = 0): <none>
  [21:15:34.058] {
  [21:15:34.058]     {
  [21:15:34.058]         ...future.startTime <- base::Sys.time()
  [21:15:34.058]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.058]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.058]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.058]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.058]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.058]         {
  [21:15:34.058]             {
  [21:15:34.058]                 base::local({
  [21:15:34.058]                   has_future <- base::requireNamespace("future", 
  [21:15:34.058]                     quietly = TRUE)
  [21:15:34.058]                   version <- if (has_future) 
  [21:15:34.058]                     utils::packageVersion("future")
  [21:15:34.058]                   else NULL
  [21:15:34.058]                   if (!has_future || version < "1.8.0") {
  [21:15:34.058]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.058]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.058]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.058]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.058]                         "release", "version")], collapse = " "), 
  [21:15:34.058]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.058]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.058]                       info)
  [21:15:34.058]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.058]                     if (!has_future) {
  [21:15:34.058]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.058]                         info)
  [21:15:34.058]                     }
  [21:15:34.058]                     else {
  [21:15:34.058]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.058]                         info, version)
  [21:15:34.058]                     }
  [21:15:34.058]                     base::stop(msg)
  [21:15:34.058]                   }
  [21:15:34.058]                 })
  [21:15:34.058]             }
  [21:15:34.058]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.058]         }
  [21:15:34.058]     }
  [21:15:34.058]     if (base::is.na(TRUE)) {
  [21:15:34.058]     }
  [21:15:34.058]     else {
  [21:15:34.058]         if (TRUE) {
  [21:15:34.058]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.058]                 open = "w")
  [21:15:34.058]         }
  [21:15:34.058]         else {
  [21:15:34.058]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.058]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.058]         }
  [21:15:34.058]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.058]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.058]             base::sink(type = "output", split = FALSE)
  [21:15:34.058]             base::close(...future.stdout)
  [21:15:34.058]         }, add = TRUE)
  [21:15:34.058]     }
  [21:15:34.058]     ...future.frame <- base::sys.nframe()
  [21:15:34.058]     ...future.conditions <- base::list()
  [21:15:34.058]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.058]     ...future.result <- base::tryCatch({
  [21:15:34.058]         base::withCallingHandlers({
  [21:15:34.058]             ...future.value <- base::withVisible(base::local({
  [21:15:34.058]                 sample(x, size = 1L)
  [21:15:34.058]             }))
  [21:15:34.058]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.058]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.058]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.058]                 version = "1.8")
  [21:15:34.058]         }, condition = base::local({
  [21:15:34.058]             c <- base::c
  [21:15:34.058]             inherits <- base::inherits
  [21:15:34.058]             invokeRestart <- base::invokeRestart
  [21:15:34.058]             length <- base::length
  [21:15:34.058]             list <- base::list
  [21:15:34.058]             seq.int <- base::seq.int
  [21:15:34.058]             signalCondition <- base::signalCondition
  [21:15:34.058]             sys.calls <- base::sys.calls
  [21:15:34.058]             Sys.time <- base::Sys.time
  [21:15:34.058]             `[[` <- base::`[[`
  [21:15:34.058]             `+` <- base::`+`
  [21:15:34.058]             `<<-` <- base::`<<-`
  [21:15:34.058]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.058]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.058]                   3L)]
  [21:15:34.058]             }
  [21:15:34.058]             function(cond) {
  [21:15:34.058]                 if (inherits(cond, "error")) {
  [21:15:34.058]                   sessionInformation <- function() {
  [21:15:34.058]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.058]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.058]                       search = base::search(), system = base::Sys.info())
  [21:15:34.058]                   }
  [21:15:34.058]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.058]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.058]                     cond$call), session = sessionInformation(), 
  [21:15:34.058]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.058]                   signalCondition(cond)
  [21:15:34.058]                 }
  [21:15:34.058]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.058]                 ))) {
  [21:15:34.058]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.058]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.058]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.058]                   if (!signal) {
  [21:15:34.058]                     muffleCondition <- function (cond) 
  [21:15:34.058]                     {
  [21:15:34.058]                       inherits <- base::inherits
  [21:15:34.058]                       invokeRestart <- base::invokeRestart
  [21:15:34.058]                       muffled <- FALSE
  [21:15:34.058]                       if (inherits(cond, "message")) {
  [21:15:34.058]                         invokeRestart("muffleMessage")
  [21:15:34.058]                         muffled <- TRUE
  [21:15:34.058]                       }
  [21:15:34.058]                       else if (inherits(cond, "warning")) {
  [21:15:34.058]                         invokeRestart("muffleWarning")
  [21:15:34.058]                         muffled <- TRUE
  [21:15:34.058]                       }
  [21:15:34.058]                       else if (inherits(cond, "condition")) {
  [21:15:34.058]                         computeRestarts <- base::computeRestarts
  [21:15:34.058]                         grepl <- base::grepl
  [21:15:34.058]                         is.null <- base::is.null
  [21:15:34.058]                         restarts <- computeRestarts(cond)
  [21:15:34.058]                         for (restart in restarts) {
  [21:15:34.058]                           name <- restart$name
  [21:15:34.058]                           if (is.null(name)) 
  [21:15:34.058]                             next
  [21:15:34.058]                           if (!grepl("^muffle", name)) 
  [21:15:34.058]                             next
  [21:15:34.058]                           invokeRestart(restart)
  [21:15:34.058]                           muffled <- TRUE
  [21:15:34.058]                           break
  [21:15:34.058]                         }
  [21:15:34.058]                       }
  [21:15:34.058]                       invisible(muffled)
  [21:15:34.058]                     }
  [21:15:34.058]                     muffleCondition(cond)
  [21:15:34.058]                   }
  [21:15:34.058]                 }
  [21:15:34.058]             }
  [21:15:34.058]         }))
  [21:15:34.058]     }, error = function(ex) {
  [21:15:34.058]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.058]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.058]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.058]     }, finally = {
  [21:15:34.058]         {
  [21:15:34.058]             NULL
  [21:15:34.058]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.058]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.058]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.058]                 label = NULL, ...) 
  [21:15:34.058]             {
  [21:15:34.058]                 if (substitute) 
  [21:15:34.058]                   expr <- substitute(expr)
  [21:15:34.058]                 local <- as.logical(local)
  [21:15:34.058]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.058]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.058]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.058]                   label = label, ...)
  [21:15:34.058]                 if (!future$lazy) 
  [21:15:34.058]                   future <- run(future)
  [21:15:34.058]                 invisible(future)
  [21:15:34.058]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.058]         }
  [21:15:34.058]         base::options(...future.oldOptions)
  [21:15:34.058]     })
  [21:15:34.058]     Sys.time
  [21:15:34.058]     if (base::is.na(TRUE)) {
  [21:15:34.058]     }
  [21:15:34.058]     else {
  [21:15:34.058]         base::sink(type = "output", split = FALSE)
  [21:15:34.058]         if (TRUE) {
  [21:15:34.058]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.058]         }
  [21:15:34.058]         else {
  [21:15:34.058]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.058]         }
  [21:15:34.058]         base::close(...future.stdout)
  [21:15:34.058]         ...future.stdout <- NULL
  [21:15:34.058]     }
  [21:15:34.058]     ...future.result$conditions <- ...future.conditions
  [21:15:34.058]     ...future.result
  [21:15:34.058] }
  [21:15:34.062] plan(): Setting new future strategy stack:
  [21:15:34.062] List of future strategies:
  [21:15:34.062] 1. sequential:
  [21:15:34.062]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.062]    - tweaked: FALSE
  [21:15:34.062]    - call: NULL
  [21:15:34.063] plan(): nbrOfWorkers() = 1
  [21:15:34.064] plan(): Setting new future strategy stack:
  [21:15:34.064] List of future strategies:
  [21:15:34.064] 1. sequential:
  [21:15:34.064]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.064]    - tweaked: FALSE
  [21:15:34.064]    - call: plan(strategy)
  [21:15:34.065] plan(): nbrOfWorkers() = 1
  [21:15:34.066] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_2-686459'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ad3bde0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:34.068] getGlobalsAndPackages() ...
  [21:15:34.068] Searching for globals...
  [21:15:34.070] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.070] Searching for globals ... DONE
  [21:15:34.070] Resolving globals: FALSE
  [21:15:34.071] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.071] - globals: [1] 'x'
  [21:15:34.072] 
  [21:15:34.072] getGlobalsAndPackages() ... DONE
  [21:15:34.073] Packages needed by the future expression (n = 0): <none>
  [21:15:34.074] Packages needed by future strategies (n = 0): <none>
  [21:15:34.078] {
  [21:15:34.078]     {
  [21:15:34.078]         ...future.startTime <- base::Sys.time()
  [21:15:34.078]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.078]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.078]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.078]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.078]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.078]         {
  [21:15:34.078]             {
  [21:15:34.078]                 base::local({
  [21:15:34.078]                   has_future <- base::requireNamespace("future", 
  [21:15:34.078]                     quietly = TRUE)
  [21:15:34.078]                   version <- if (has_future) 
  [21:15:34.078]                     utils::packageVersion("future")
  [21:15:34.078]                   else NULL
  [21:15:34.078]                   if (!has_future || version < "1.8.0") {
  [21:15:34.078]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.078]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.078]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.078]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.078]                         "release", "version")], collapse = " "), 
  [21:15:34.078]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.078]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.078]                       info)
  [21:15:34.078]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.078]                     if (!has_future) {
  [21:15:34.078]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.078]                         info)
  [21:15:34.078]                     }
  [21:15:34.078]                     else {
  [21:15:34.078]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.078]                         info, version)
  [21:15:34.078]                     }
  [21:15:34.078]                     base::stop(msg)
  [21:15:34.078]                   }
  [21:15:34.078]                 })
  [21:15:34.078]             }
  [21:15:34.078]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.078]         }
  [21:15:34.078]     }
  [21:15:34.078]     if (base::is.na(TRUE)) {
  [21:15:34.078]     }
  [21:15:34.078]     else {
  [21:15:34.078]         if (TRUE) {
  [21:15:34.078]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.078]                 open = "w")
  [21:15:34.078]         }
  [21:15:34.078]         else {
  [21:15:34.078]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.078]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.078]         }
  [21:15:34.078]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.078]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.078]             base::sink(type = "output", split = FALSE)
  [21:15:34.078]             base::close(...future.stdout)
  [21:15:34.078]         }, add = TRUE)
  [21:15:34.078]     }
  [21:15:34.078]     ...future.frame <- base::sys.nframe()
  [21:15:34.078]     ...future.conditions <- base::list()
  [21:15:34.078]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.078]     ...future.result <- base::tryCatch({
  [21:15:34.078]         base::withCallingHandlers({
  [21:15:34.078]             ...future.value <- base::withVisible(base::local({
  [21:15:34.078]                 sample(x, size = 1L)
  [21:15:34.078]             }))
  [21:15:34.078]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.078]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.078]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.078]                 version = "1.8")
  [21:15:34.078]         }, condition = base::local({
  [21:15:34.078]             c <- base::c
  [21:15:34.078]             inherits <- base::inherits
  [21:15:34.078]             invokeRestart <- base::invokeRestart
  [21:15:34.078]             length <- base::length
  [21:15:34.078]             list <- base::list
  [21:15:34.078]             seq.int <- base::seq.int
  [21:15:34.078]             signalCondition <- base::signalCondition
  [21:15:34.078]             sys.calls <- base::sys.calls
  [21:15:34.078]             Sys.time <- base::Sys.time
  [21:15:34.078]             `[[` <- base::`[[`
  [21:15:34.078]             `+` <- base::`+`
  [21:15:34.078]             `<<-` <- base::`<<-`
  [21:15:34.078]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.078]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.078]                   3L)]
  [21:15:34.078]             }
  [21:15:34.078]             function(cond) {
  [21:15:34.078]                 if (inherits(cond, "error")) {
  [21:15:34.078]                   sessionInformation <- function() {
  [21:15:34.078]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.078]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.078]                       search = base::search(), system = base::Sys.info())
  [21:15:34.078]                   }
  [21:15:34.078]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.078]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.078]                     cond$call), session = sessionInformation(), 
  [21:15:34.078]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.078]                   signalCondition(cond)
  [21:15:34.078]                 }
  [21:15:34.078]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.078]                 ))) {
  [21:15:34.078]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.078]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.078]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.078]                   if (!signal) {
  [21:15:34.078]                     muffleCondition <- function (cond) 
  [21:15:34.078]                     {
  [21:15:34.078]                       inherits <- base::inherits
  [21:15:34.078]                       invokeRestart <- base::invokeRestart
  [21:15:34.078]                       muffled <- FALSE
  [21:15:34.078]                       if (inherits(cond, "message")) {
  [21:15:34.078]                         invokeRestart("muffleMessage")
  [21:15:34.078]                         muffled <- TRUE
  [21:15:34.078]                       }
  [21:15:34.078]                       else if (inherits(cond, "warning")) {
  [21:15:34.078]                         invokeRestart("muffleWarning")
  [21:15:34.078]                         muffled <- TRUE
  [21:15:34.078]                       }
  [21:15:34.078]                       else if (inherits(cond, "condition")) {
  [21:15:34.078]                         computeRestarts <- base::computeRestarts
  [21:15:34.078]                         grepl <- base::grepl
  [21:15:34.078]                         is.null <- base::is.null
  [21:15:34.078]                         restarts <- computeRestarts(cond)
  [21:15:34.078]                         for (restart in restarts) {
  [21:15:34.078]                           name <- restart$name
  [21:15:34.078]                           if (is.null(name)) 
  [21:15:34.078]                             next
  [21:15:34.078]                           if (!grepl("^muffle", name)) 
  [21:15:34.078]                             next
  [21:15:34.078]                           invokeRestart(restart)
  [21:15:34.078]                           muffled <- TRUE
  [21:15:34.078]                           break
  [21:15:34.078]                         }
  [21:15:34.078]                       }
  [21:15:34.078]                       invisible(muffled)
  [21:15:34.078]                     }
  [21:15:34.078]                     muffleCondition(cond)
  [21:15:34.078]                   }
  [21:15:34.078]                 }
  [21:15:34.078]             }
  [21:15:34.078]         }))
  [21:15:34.078]     }, error = function(ex) {
  [21:15:34.078]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.078]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.078]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.078]     }, finally = {
  [21:15:34.078]         {
  [21:15:34.078]             NULL
  [21:15:34.078]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.078]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.078]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.078]                 label = NULL, ...) 
  [21:15:34.078]             {
  [21:15:34.078]                 if (substitute) 
  [21:15:34.078]                   expr <- substitute(expr)
  [21:15:34.078]                 local <- as.logical(local)
  [21:15:34.078]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.078]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.078]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.078]                   label = label, ...)
  [21:15:34.078]                 if (!future$lazy) 
  [21:15:34.078]                   future <- run(future)
  [21:15:34.078]                 invisible(future)
  [21:15:34.078]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.078]         }
  [21:15:34.078]         base::options(...future.oldOptions)
  [21:15:34.078]     })
  [21:15:34.078]     Sys.time
  [21:15:34.078]     if (base::is.na(TRUE)) {
  [21:15:34.078]     }
  [21:15:34.078]     else {
  [21:15:34.078]         base::sink(type = "output", split = FALSE)
  [21:15:34.078]         if (TRUE) {
  [21:15:34.078]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.078]         }
  [21:15:34.078]         else {
  [21:15:34.078]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.078]         }
  [21:15:34.078]         base::close(...future.stdout)
  [21:15:34.078]         ...future.stdout <- NULL
  [21:15:34.078]     }
  [21:15:34.078]     ...future.result$conditions <- ...future.conditions
  [21:15:34.078]     ...future.result
  [21:15:34.078] }
  [21:15:34.082] plan(): Setting new future strategy stack:
  [21:15:34.082] List of future strategies:
  [21:15:34.082] 1. sequential:
  [21:15:34.082]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.082]    - tweaked: FALSE
  [21:15:34.082]    - call: NULL
  [21:15:34.083] plan(): nbrOfWorkers() = 1
  [21:15:34.084] plan(): Setting new future strategy stack:
  [21:15:34.084] List of future strategies:
  [21:15:34.084] 1. sequential:
  [21:15:34.084]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.084]    - tweaked: FALSE
  [21:15:34.084]    - call: plan(strategy)
  [21:15:34.085] plan(): nbrOfWorkers() = 1
  [21:15:34.086] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_3-437084'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ad3bde0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:34.088] getGlobalsAndPackages() ...
  [21:15:34.088] Searching for globals...
  [21:15:34.090] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.090] Searching for globals ... DONE
  [21:15:34.090] Resolving globals: FALSE
  [21:15:34.091] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.092] - globals: [1] 'x'
  [21:15:34.092] 
  [21:15:34.092] getGlobalsAndPackages() ... DONE
  [21:15:34.094] Packages needed by the future expression (n = 0): <none>
  [21:15:34.094] Packages needed by future strategies (n = 0): <none>
  [21:15:34.101] {
  [21:15:34.101]     {
  [21:15:34.101]         ...future.startTime <- base::Sys.time()
  [21:15:34.101]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.101]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.101]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.101]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.101]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.101]         {
  [21:15:34.101]             {
  [21:15:34.101]                 base::local({
  [21:15:34.101]                   has_future <- base::requireNamespace("future", 
  [21:15:34.101]                     quietly = TRUE)
  [21:15:34.101]                   version <- if (has_future) 
  [21:15:34.101]                     utils::packageVersion("future")
  [21:15:34.101]                   else NULL
  [21:15:34.101]                   if (!has_future || version < "1.8.0") {
  [21:15:34.101]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.101]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.101]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.101]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.101]                         "release", "version")], collapse = " "), 
  [21:15:34.101]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.101]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.101]                       info)
  [21:15:34.101]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.101]                     if (!has_future) {
  [21:15:34.101]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.101]                         info)
  [21:15:34.101]                     }
  [21:15:34.101]                     else {
  [21:15:34.101]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.101]                         info, version)
  [21:15:34.101]                     }
  [21:15:34.101]                     base::stop(msg)
  [21:15:34.101]                   }
  [21:15:34.101]                 })
  [21:15:34.101]             }
  [21:15:34.101]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.101]         }
  [21:15:34.101]     }
  [21:15:34.101]     if (base::is.na(TRUE)) {
  [21:15:34.101]     }
  [21:15:34.101]     else {
  [21:15:34.101]         if (TRUE) {
  [21:15:34.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.101]                 open = "w")
  [21:15:34.101]         }
  [21:15:34.101]         else {
  [21:15:34.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.101]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.101]         }
  [21:15:34.101]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.101]             base::sink(type = "output", split = FALSE)
  [21:15:34.101]             base::close(...future.stdout)
  [21:15:34.101]         }, add = TRUE)
  [21:15:34.101]     }
  [21:15:34.101]     ...future.frame <- base::sys.nframe()
  [21:15:34.101]     ...future.conditions <- base::list()
  [21:15:34.101]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.101]     ...future.result <- base::tryCatch({
  [21:15:34.101]         base::withCallingHandlers({
  [21:15:34.101]             ...future.value <- base::withVisible(base::local({
  [21:15:34.101]                 sample(x, size = 1L)
  [21:15:34.101]             }))
  [21:15:34.101]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.101]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.101]                 version = "1.8")
  [21:15:34.101]         }, condition = base::local({
  [21:15:34.101]             c <- base::c
  [21:15:34.101]             inherits <- base::inherits
  [21:15:34.101]             invokeRestart <- base::invokeRestart
  [21:15:34.101]             length <- base::length
  [21:15:34.101]             list <- base::list
  [21:15:34.101]             seq.int <- base::seq.int
  [21:15:34.101]             signalCondition <- base::signalCondition
  [21:15:34.101]             sys.calls <- base::sys.calls
  [21:15:34.101]             Sys.time <- base::Sys.time
  [21:15:34.101]             `[[` <- base::`[[`
  [21:15:34.101]             `+` <- base::`+`
  [21:15:34.101]             `<<-` <- base::`<<-`
  [21:15:34.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.101]                   3L)]
  [21:15:34.101]             }
  [21:15:34.101]             function(cond) {
  [21:15:34.101]                 if (inherits(cond, "error")) {
  [21:15:34.101]                   sessionInformation <- function() {
  [21:15:34.101]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.101]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.101]                       search = base::search(), system = base::Sys.info())
  [21:15:34.101]                   }
  [21:15:34.101]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.101]                     cond$call), session = sessionInformation(), 
  [21:15:34.101]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.101]                   signalCondition(cond)
  [21:15:34.101]                 }
  [21:15:34.101]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.101]                 ))) {
  [21:15:34.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.101]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.101]                   if (!signal) {
  [21:15:34.101]                     muffleCondition <- function (cond) 
  [21:15:34.101]                     {
  [21:15:34.101]                       inherits <- base::inherits
  [21:15:34.101]                       invokeRestart <- base::invokeRestart
  [21:15:34.101]                       muffled <- FALSE
  [21:15:34.101]                       if (inherits(cond, "message")) {
  [21:15:34.101]                         invokeRestart("muffleMessage")
  [21:15:34.101]                         muffled <- TRUE
  [21:15:34.101]                       }
  [21:15:34.101]                       else if (inherits(cond, "warning")) {
  [21:15:34.101]                         invokeRestart("muffleWarning")
  [21:15:34.101]                         muffled <- TRUE
  [21:15:34.101]                       }
  [21:15:34.101]                       else if (inherits(cond, "condition")) {
  [21:15:34.101]                         computeRestarts <- base::computeRestarts
  [21:15:34.101]                         grepl <- base::grepl
  [21:15:34.101]                         is.null <- base::is.null
  [21:15:34.101]                         restarts <- computeRestarts(cond)
  [21:15:34.101]                         for (restart in restarts) {
  [21:15:34.101]                           name <- restart$name
  [21:15:34.101]                           if (is.null(name)) 
  [21:15:34.101]                             next
  [21:15:34.101]                           if (!grepl("^muffle", name)) 
  [21:15:34.101]                             next
  [21:15:34.101]                           invokeRestart(restart)
  [21:15:34.101]                           muffled <- TRUE
  [21:15:34.101]                           break
  [21:15:34.101]                         }
  [21:15:34.101]                       }
  [21:15:34.101]                       invisible(muffled)
  [21:15:34.101]                     }
  [21:15:34.101]                     muffleCondition(cond)
  [21:15:34.101]                   }
  [21:15:34.101]                 }
  [21:15:34.101]             }
  [21:15:34.101]         }))
  [21:15:34.101]     }, error = function(ex) {
  [21:15:34.101]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.101]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.101]     }, finally = {
  [21:15:34.101]         {
  [21:15:34.101]             NULL
  [21:15:34.101]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.101]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.101]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.101]                 label = NULL, ...) 
  [21:15:34.101]             {
  [21:15:34.101]                 if (substitute) 
  [21:15:34.101]                   expr <- substitute(expr)
  [21:15:34.101]                 local <- as.logical(local)
  [21:15:34.101]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.101]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.101]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.101]                   label = label, ...)
  [21:15:34.101]                 if (!future$lazy) 
  [21:15:34.101]                   future <- run(future)
  [21:15:34.101]                 invisible(future)
  [21:15:34.101]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.101]         }
  [21:15:34.101]         base::options(...future.oldOptions)
  [21:15:34.101]     })
  [21:15:34.101]     Sys.time
  [21:15:34.101]     if (base::is.na(TRUE)) {
  [21:15:34.101]     }
  [21:15:34.101]     else {
  [21:15:34.101]         base::sink(type = "output", split = FALSE)
  [21:15:34.101]         if (TRUE) {
  [21:15:34.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.101]         }
  [21:15:34.101]         else {
  [21:15:34.101]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.101]         }
  [21:15:34.101]         base::close(...future.stdout)
  [21:15:34.101]         ...future.stdout <- NULL
  [21:15:34.101]     }
  [21:15:34.101]     ...future.result$conditions <- ...future.conditions
  [21:15:34.101]     ...future.result
  [21:15:34.101] }
  [21:15:34.106] plan(): Setting new future strategy stack:
  [21:15:34.106] List of future strategies:
  [21:15:34.106] 1. sequential:
  [21:15:34.106]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.106]    - tweaked: FALSE
  [21:15:34.106]    - call: NULL
  [21:15:34.107] plan(): nbrOfWorkers() = 1
  [21:15:34.108] plan(): Setting new future strategy stack:
  [21:15:34.108] List of future strategies:
  [21:15:34.108] 1. sequential:
  [21:15:34.108]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.108]    - tweaked: FALSE
  [21:15:34.108]    - call: plan(strategy)
  [21:15:34.109] plan(): nbrOfWorkers() = 1
  [21:15:34.110] SequentialFuture started (and completed)
  SequentialFuture:
  Label: 'fsample_4-458488'
  Expression:
  {
      sample(x, size = 1L)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: FALSE
  Local evaluation: TRUE
  Environment: <environment: 0x56334ad3bde0>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
  Resolved: TRUE
  Value: 56 bytes of class 'integer'
  Early signaling: FALSE
  Owner process: f132acf8-d992-b82d-8cf1-7e28277df77c
  Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
  [21:15:34.111] resolve() on list ...
  [21:15:34.112]  recursive: 0
  [21:15:34.112]  length: 4
  [21:15:34.112] 
  [21:15:34.112] Future #1
  [21:15:34.113] signalConditionsASAP(SequentialFuture, pos=1) ...
  [21:15:34.113] - nx: 4
  [21:15:34.113] - relay: TRUE
  [21:15:34.113] - stdout: TRUE
  [21:15:34.114] - signal: TRUE
  [21:15:34.114] - resignal: FALSE
  [21:15:34.114] - force: TRUE
  [21:15:34.114] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:34.115] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:34.115]  - until=1
  [21:15:34.115]  - relaying element #1
  [21:15:34.116] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:34.116] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:34.116] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [21:15:34.116]  length: 3 (resolved future 1)
  [21:15:34.117] Future #2
  [21:15:34.117] signalConditionsASAP(SequentialFuture, pos=2) ...
  [21:15:34.117] - nx: 4
  [21:15:34.118] - relay: TRUE
  [21:15:34.118] - stdout: TRUE
  [21:15:34.118] - signal: TRUE
  [21:15:34.118] - resignal: FALSE
  [21:15:34.119] - force: TRUE
  [21:15:34.119] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:34.119] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:34.119]  - until=2
  [21:15:34.120]  - relaying element #2
  [21:15:34.120] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:34.120] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:34.121] signalConditionsASAP(SequentialFuture, pos=2) ... done
  [21:15:34.121]  length: 2 (resolved future 2)
  [21:15:34.121] Future #3
  [21:15:34.122] signalConditionsASAP(SequentialFuture, pos=3) ...
  [21:15:34.122] - nx: 4
  [21:15:34.122] - relay: TRUE
  [21:15:34.122] - stdout: TRUE
  [21:15:34.123] - signal: TRUE
  [21:15:34.123] - resignal: FALSE
  [21:15:34.123] - force: TRUE
  [21:15:34.123] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:34.123] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:34.124]  - until=3
  [21:15:34.124]  - relaying element #3
  [21:15:34.124] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:34.125] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:34.125] signalConditionsASAP(SequentialFuture, pos=3) ... done
  [21:15:34.125]  length: 1 (resolved future 3)
  [21:15:34.126] Future #4
  [21:15:34.126] signalConditionsASAP(SequentialFuture, pos=4) ...
  [21:15:34.126] - nx: 4
  [21:15:34.126] - relay: TRUE
  [21:15:34.127] - stdout: TRUE
  [21:15:34.127] - signal: TRUE
  [21:15:34.127] - resignal: FALSE
  [21:15:34.127] - force: TRUE
  [21:15:34.127] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:34.128] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:34.128]  - until=4
  [21:15:34.128]  - relaying element #4
  [21:15:34.129] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:34.129] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:34.129] signalConditionsASAP(SequentialFuture, pos=4) ... done
  [21:15:34.129]  length: 0 (resolved future 4)
  [21:15:34.130] Relaying remaining futures
  [21:15:34.130] signalConditionsASAP(NULL, pos=0) ...
  [21:15:34.130] - nx: 4
  [21:15:34.130] - relay: TRUE
  [21:15:34.131] - stdout: TRUE
  [21:15:34.131] - signal: TRUE
  [21:15:34.131] - resignal: FALSE
  [21:15:34.131] - force: TRUE
  [21:15:34.131] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:34.132] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:34.132] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:34.132] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:34.133] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:34.133] resolve() on list ... DONE
  [[1]]
  [1] 0
  
  [[2]]
  [1] 2
  
  [[3]]
  [1] 2
  
  [[4]]
  [1] 2
  
  [21:15:34.137] getGlobalsAndPackages() ...
  [21:15:34.137] Searching for globals...
  [21:15:34.139] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.140] Searching for globals ... DONE
  [21:15:34.140] Resolving globals: FALSE
  [21:15:34.141] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.141] - globals: [1] 'x'
  [21:15:34.141] 
  [21:15:34.142] getGlobalsAndPackages() ... DONE
  [21:15:34.143] Packages needed by the future expression (n = 0): <none>
  [21:15:34.144] Packages needed by future strategies (n = 0): <none>
  [21:15:34.148] {
  [21:15:34.148]     {
  [21:15:34.148]         ...future.startTime <- base::Sys.time()
  [21:15:34.148]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.148]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.148]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.148]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.148]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.148]         {
  [21:15:34.148]             {
  [21:15:34.148]                 {
  [21:15:34.148]                   base::local({
  [21:15:34.148]                     has_future <- base::requireNamespace("future", 
  [21:15:34.148]                       quietly = TRUE)
  [21:15:34.148]                     version <- if (has_future) 
  [21:15:34.148]                       utils::packageVersion("future")
  [21:15:34.148]                     else NULL
  [21:15:34.148]                     if (!has_future || version < "1.8.0") {
  [21:15:34.148]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.148]                         "", base::R.version$version.string), 
  [21:15:34.148]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.148]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.148]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.148]                           "release", "version")], collapse = " "), 
  [21:15:34.148]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.148]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.148]                         info)
  [21:15:34.148]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.148]                       if (!has_future) {
  [21:15:34.148]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.148]                           info)
  [21:15:34.148]                       }
  [21:15:34.148]                       else {
  [21:15:34.148]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.148]                           info, version)
  [21:15:34.148]                       }
  [21:15:34.148]                       base::stop(msg)
  [21:15:34.148]                     }
  [21:15:34.148]                   })
  [21:15:34.148]                 }
  [21:15:34.148]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:34.148]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:34.148]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.148]             }
  [21:15:34.148]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.148]         }
  [21:15:34.148]     }
  [21:15:34.148]     if (base::is.na(TRUE)) {
  [21:15:34.148]     }
  [21:15:34.148]     else {
  [21:15:34.148]         if (TRUE) {
  [21:15:34.148]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.148]                 open = "w")
  [21:15:34.148]         }
  [21:15:34.148]         else {
  [21:15:34.148]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.148]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.148]         }
  [21:15:34.148]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.148]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.148]             base::sink(type = "output", split = FALSE)
  [21:15:34.148]             base::close(...future.stdout)
  [21:15:34.148]         }, add = TRUE)
  [21:15:34.148]     }
  [21:15:34.148]     ...future.frame <- base::sys.nframe()
  [21:15:34.148]     ...future.conditions <- base::list()
  [21:15:34.148]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.148]     ...future.result <- base::tryCatch({
  [21:15:34.148]         base::withCallingHandlers({
  [21:15:34.148]             ...future.value <- base::withVisible(base::local({
  [21:15:34.148]                 sample(x, size = 1L)
  [21:15:34.148]             }))
  [21:15:34.148]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.148]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.148]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.148]                 version = "1.8")
  [21:15:34.148]         }, condition = base::local({
  [21:15:34.148]             c <- base::c
  [21:15:34.148]             inherits <- base::inherits
  [21:15:34.148]             invokeRestart <- base::invokeRestart
  [21:15:34.148]             length <- base::length
  [21:15:34.148]             list <- base::list
  [21:15:34.148]             seq.int <- base::seq.int
  [21:15:34.148]             signalCondition <- base::signalCondition
  [21:15:34.148]             sys.calls <- base::sys.calls
  [21:15:34.148]             Sys.time <- base::Sys.time
  [21:15:34.148]             `[[` <- base::`[[`
  [21:15:34.148]             `+` <- base::`+`
  [21:15:34.148]             `<<-` <- base::`<<-`
  [21:15:34.148]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.148]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.148]                   3L)]
  [21:15:34.148]             }
  [21:15:34.148]             function(cond) {
  [21:15:34.148]                 if (inherits(cond, "error")) {
  [21:15:34.148]                   sessionInformation <- function() {
  [21:15:34.148]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.148]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.148]                       search = base::search(), system = base::Sys.info())
  [21:15:34.148]                   }
  [21:15:34.148]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.148]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.148]                     cond$call), session = sessionInformation(), 
  [21:15:34.148]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.148]                   signalCondition(cond)
  [21:15:34.148]                 }
  [21:15:34.148]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.148]                 ))) {
  [21:15:34.148]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.148]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.148]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.148]                   if (!signal) {
  [21:15:34.148]                     muffleCondition <- function (cond) 
  [21:15:34.148]                     {
  [21:15:34.148]                       inherits <- base::inherits
  [21:15:34.148]                       invokeRestart <- base::invokeRestart
  [21:15:34.148]                       muffled <- FALSE
  [21:15:34.148]                       if (inherits(cond, "message")) {
  [21:15:34.148]                         invokeRestart("muffleMessage")
  [21:15:34.148]                         muffled <- TRUE
  [21:15:34.148]                       }
  [21:15:34.148]                       else if (inherits(cond, "warning")) {
  [21:15:34.148]                         invokeRestart("muffleWarning")
  [21:15:34.148]                         muffled <- TRUE
  [21:15:34.148]                       }
  [21:15:34.148]                       else if (inherits(cond, "condition")) {
  [21:15:34.148]                         computeRestarts <- base::computeRestarts
  [21:15:34.148]                         grepl <- base::grepl
  [21:15:34.148]                         is.null <- base::is.null
  [21:15:34.148]                         restarts <- computeRestarts(cond)
  [21:15:34.148]                         for (restart in restarts) {
  [21:15:34.148]                           name <- restart$name
  [21:15:34.148]                           if (is.null(name)) 
  [21:15:34.148]                             next
  [21:15:34.148]                           if (!grepl("^muffle", name)) 
  [21:15:34.148]                             next
  [21:15:34.148]                           invokeRestart(restart)
  [21:15:34.148]                           muffled <- TRUE
  [21:15:34.148]                           break
  [21:15:34.148]                         }
  [21:15:34.148]                       }
  [21:15:34.148]                       invisible(muffled)
  [21:15:34.148]                     }
  [21:15:34.148]                     muffleCondition(cond)
  [21:15:34.148]                   }
  [21:15:34.148]                 }
  [21:15:34.148]             }
  [21:15:34.148]         }))
  [21:15:34.148]     }, error = function(ex) {
  [21:15:34.148]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.148]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.148]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.148]     }, finally = {
  [21:15:34.148]         {
  [21:15:34.148]             NULL
  [21:15:34.148]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.148]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.148]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.148]                 label = NULL, ...) 
  [21:15:34.148]             {
  [21:15:34.148]                 if (substitute) 
  [21:15:34.148]                   expr <- substitute(expr)
  [21:15:34.148]                 local <- as.logical(local)
  [21:15:34.148]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.148]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.148]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.148]                   label = label, ...)
  [21:15:34.148]                 if (!future$lazy) 
  [21:15:34.148]                   future <- run(future)
  [21:15:34.148]                 invisible(future)
  [21:15:34.148]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.148]         }
  [21:15:34.148]         base::options(...future.oldOptions)
  [21:15:34.148]     })
  [21:15:34.148]     Sys.time
  [21:15:34.148]     if (base::is.na(TRUE)) {
  [21:15:34.148]     }
  [21:15:34.148]     else {
  [21:15:34.148]         base::sink(type = "output", split = FALSE)
  [21:15:34.148]         if (TRUE) {
  [21:15:34.148]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.148]         }
  [21:15:34.148]         else {
  [21:15:34.148]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.148]         }
  [21:15:34.148]         base::close(...future.stdout)
  [21:15:34.148]         ...future.stdout <- NULL
  [21:15:34.148]     }
  [21:15:34.148]     ...future.result$conditions <- ...future.conditions
  [21:15:34.148]     ...future.result
  [21:15:34.148] }
  [21:15:34.152] plan(): Setting new future strategy stack:
  [21:15:34.153] List of future strategies:
  [21:15:34.153] 1. sequential:
  [21:15:34.153]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.153]    - tweaked: FALSE
  [21:15:34.153]    - call: NULL
  [21:15:34.154] plan(): nbrOfWorkers() = 1
  [21:15:34.155] plan(): Setting new future strategy stack:
  [21:15:34.155] List of future strategies:
  [21:15:34.155] 1. sequential:
  [21:15:34.155]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.155]    - tweaked: FALSE
  [21:15:34.155]    - call: plan(strategy)
  [21:15:34.156] plan(): nbrOfWorkers() = 1
  [21:15:34.156] SequentialFuture started (and completed)
  [21:15:34.158] getGlobalsAndPackages() ...
  [21:15:34.158] Searching for globals...
  [21:15:34.160] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.160] Searching for globals ... DONE
  [21:15:34.161] Resolving globals: FALSE
  [21:15:34.161] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.162] - globals: [1] 'x'
  [21:15:34.162] 
  [21:15:34.162] getGlobalsAndPackages() ... DONE
  [21:15:34.168] Packages needed by the future expression (n = 0): <none>
  [21:15:34.168] Packages needed by future strategies (n = 0): <none>
  [21:15:34.173] {
  [21:15:34.173]     {
  [21:15:34.173]         ...future.startTime <- base::Sys.time()
  [21:15:34.173]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.173]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.173]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.173]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.173]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.173]         {
  [21:15:34.173]             {
  [21:15:34.173]                 {
  [21:15:34.173]                   base::local({
  [21:15:34.173]                     has_future <- base::requireNamespace("future", 
  [21:15:34.173]                       quietly = TRUE)
  [21:15:34.173]                     version <- if (has_future) 
  [21:15:34.173]                       utils::packageVersion("future")
  [21:15:34.173]                     else NULL
  [21:15:34.173]                     if (!has_future || version < "1.8.0") {
  [21:15:34.173]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.173]                         "", base::R.version$version.string), 
  [21:15:34.173]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.173]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.173]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.173]                           "release", "version")], collapse = " "), 
  [21:15:34.173]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.173]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.173]                         info)
  [21:15:34.173]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.173]                       if (!has_future) {
  [21:15:34.173]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.173]                           info)
  [21:15:34.173]                       }
  [21:15:34.173]                       else {
  [21:15:34.173]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.173]                           info, version)
  [21:15:34.173]                       }
  [21:15:34.173]                       base::stop(msg)
  [21:15:34.173]                     }
  [21:15:34.173]                   })
  [21:15:34.173]                 }
  [21:15:34.173]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:34.173]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:34.173]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.173]             }
  [21:15:34.173]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.173]         }
  [21:15:34.173]     }
  [21:15:34.173]     if (base::is.na(TRUE)) {
  [21:15:34.173]     }
  [21:15:34.173]     else {
  [21:15:34.173]         if (TRUE) {
  [21:15:34.173]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.173]                 open = "w")
  [21:15:34.173]         }
  [21:15:34.173]         else {
  [21:15:34.173]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.173]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.173]         }
  [21:15:34.173]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.173]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.173]             base::sink(type = "output", split = FALSE)
  [21:15:34.173]             base::close(...future.stdout)
  [21:15:34.173]         }, add = TRUE)
  [21:15:34.173]     }
  [21:15:34.173]     ...future.frame <- base::sys.nframe()
  [21:15:34.173]     ...future.conditions <- base::list()
  [21:15:34.173]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.173]     ...future.result <- base::tryCatch({
  [21:15:34.173]         base::withCallingHandlers({
  [21:15:34.173]             ...future.value <- base::withVisible(base::local({
  [21:15:34.173]                 sample(x, size = 1L)
  [21:15:34.173]             }))
  [21:15:34.173]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.173]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.173]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.173]                 version = "1.8")
  [21:15:34.173]         }, condition = base::local({
  [21:15:34.173]             c <- base::c
  [21:15:34.173]             inherits <- base::inherits
  [21:15:34.173]             invokeRestart <- base::invokeRestart
  [21:15:34.173]             length <- base::length
  [21:15:34.173]             list <- base::list
  [21:15:34.173]             seq.int <- base::seq.int
  [21:15:34.173]             signalCondition <- base::signalCondition
  [21:15:34.173]             sys.calls <- base::sys.calls
  [21:15:34.173]             Sys.time <- base::Sys.time
  [21:15:34.173]             `[[` <- base::`[[`
  [21:15:34.173]             `+` <- base::`+`
  [21:15:34.173]             `<<-` <- base::`<<-`
  [21:15:34.173]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.173]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.173]                   3L)]
  [21:15:34.173]             }
  [21:15:34.173]             function(cond) {
  [21:15:34.173]                 if (inherits(cond, "error")) {
  [21:15:34.173]                   sessionInformation <- function() {
  [21:15:34.173]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.173]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.173]                       search = base::search(), system = base::Sys.info())
  [21:15:34.173]                   }
  [21:15:34.173]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.173]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.173]                     cond$call), session = sessionInformation(), 
  [21:15:34.173]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.173]                   signalCondition(cond)
  [21:15:34.173]                 }
  [21:15:34.173]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.173]                 ))) {
  [21:15:34.173]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.173]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.173]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.173]                   if (!signal) {
  [21:15:34.173]                     muffleCondition <- function (cond) 
  [21:15:34.173]                     {
  [21:15:34.173]                       inherits <- base::inherits
  [21:15:34.173]                       invokeRestart <- base::invokeRestart
  [21:15:34.173]                       muffled <- FALSE
  [21:15:34.173]                       if (inherits(cond, "message")) {
  [21:15:34.173]                         invokeRestart("muffleMessage")
  [21:15:34.173]                         muffled <- TRUE
  [21:15:34.173]                       }
  [21:15:34.173]                       else if (inherits(cond, "warning")) {
  [21:15:34.173]                         invokeRestart("muffleWarning")
  [21:15:34.173]                         muffled <- TRUE
  [21:15:34.173]                       }
  [21:15:34.173]                       else if (inherits(cond, "condition")) {
  [21:15:34.173]                         computeRestarts <- base::computeRestarts
  [21:15:34.173]                         grepl <- base::grepl
  [21:15:34.173]                         is.null <- base::is.null
  [21:15:34.173]                         restarts <- computeRestarts(cond)
  [21:15:34.173]                         for (restart in restarts) {
  [21:15:34.173]                           name <- restart$name
  [21:15:34.173]                           if (is.null(name)) 
  [21:15:34.173]                             next
  [21:15:34.173]                           if (!grepl("^muffle", name)) 
  [21:15:34.173]                             next
  [21:15:34.173]                           invokeRestart(restart)
  [21:15:34.173]                           muffled <- TRUE
  [21:15:34.173]                           break
  [21:15:34.173]                         }
  [21:15:34.173]                       }
  [21:15:34.173]                       invisible(muffled)
  [21:15:34.173]                     }
  [21:15:34.173]                     muffleCondition(cond)
  [21:15:34.173]                   }
  [21:15:34.173]                 }
  [21:15:34.173]             }
  [21:15:34.173]         }))
  [21:15:34.173]     }, error = function(ex) {
  [21:15:34.173]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.173]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.173]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.173]     }, finally = {
  [21:15:34.173]         {
  [21:15:34.173]             NULL
  [21:15:34.173]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.173]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.173]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.173]                 label = NULL, ...) 
  [21:15:34.173]             {
  [21:15:34.173]                 if (substitute) 
  [21:15:34.173]                   expr <- substitute(expr)
  [21:15:34.173]                 local <- as.logical(local)
  [21:15:34.173]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.173]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.173]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.173]                   label = label, ...)
  [21:15:34.173]                 if (!future$lazy) 
  [21:15:34.173]                   future <- run(future)
  [21:15:34.173]                 invisible(future)
  [21:15:34.173]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.173]         }
  [21:15:34.173]         base::options(...future.oldOptions)
  [21:15:34.173]     })
  [21:15:34.173]     Sys.time
  [21:15:34.173]     if (base::is.na(TRUE)) {
  [21:15:34.173]     }
  [21:15:34.173]     else {
  [21:15:34.173]         base::sink(type = "output", split = FALSE)
  [21:15:34.173]         if (TRUE) {
  [21:15:34.173]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.173]         }
  [21:15:34.173]         else {
  [21:15:34.173]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.173]         }
  [21:15:34.173]         base::close(...future.stdout)
  [21:15:34.173]         ...future.stdout <- NULL
  [21:15:34.173]     }
  [21:15:34.173]     ...future.result$conditions <- ...future.conditions
  [21:15:34.173]     ...future.result
  [21:15:34.173] }
  [21:15:34.177] plan(): Setting new future strategy stack:
  [21:15:34.178] List of future strategies:
  [21:15:34.178] 1. sequential:
  [21:15:34.178]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.178]    - tweaked: FALSE
  [21:15:34.178]    - call: NULL
  [21:15:34.179] plan(): nbrOfWorkers() = 1
  [21:15:34.180] plan(): Setting new future strategy stack:
  [21:15:34.180] List of future strategies:
  [21:15:34.180] 1. sequential:
  [21:15:34.180]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.180]    - tweaked: FALSE
  [21:15:34.180]    - call: plan(strategy)
  [21:15:34.181] plan(): nbrOfWorkers() = 1
  [21:15:34.182] SequentialFuture started (and completed)
  [21:15:34.191] getGlobalsAndPackages() ...
  [21:15:34.191] Searching for globals...
  [21:15:34.193] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.194] Searching for globals ... DONE
  [21:15:34.194] Resolving globals: FALSE
  [21:15:34.195] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.195] - globals: [1] 'x'
  [21:15:34.195] 
  [21:15:34.196] getGlobalsAndPackages() ... DONE
  [21:15:34.198] Packages needed by the future expression (n = 0): <none>
  [21:15:34.214] Packages needed by future strategies (n = 0): <none>
  [21:15:34.218] {
  [21:15:34.218]     {
  [21:15:34.218]         ...future.startTime <- base::Sys.time()
  [21:15:34.218]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.218]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.218]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.218]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.218]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.218]         {
  [21:15:34.218]             {
  [21:15:34.218]                 {
  [21:15:34.218]                   base::local({
  [21:15:34.218]                     has_future <- base::requireNamespace("future", 
  [21:15:34.218]                       quietly = TRUE)
  [21:15:34.218]                     version <- if (has_future) 
  [21:15:34.218]                       utils::packageVersion("future")
  [21:15:34.218]                     else NULL
  [21:15:34.218]                     if (!has_future || version < "1.8.0") {
  [21:15:34.218]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.218]                         "", base::R.version$version.string), 
  [21:15:34.218]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.218]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.218]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.218]                           "release", "version")], collapse = " "), 
  [21:15:34.218]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.218]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.218]                         info)
  [21:15:34.218]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.218]                       if (!has_future) {
  [21:15:34.218]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.218]                           info)
  [21:15:34.218]                       }
  [21:15:34.218]                       else {
  [21:15:34.218]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.218]                           info, version)
  [21:15:34.218]                       }
  [21:15:34.218]                       base::stop(msg)
  [21:15:34.218]                     }
  [21:15:34.218]                   })
  [21:15:34.218]                 }
  [21:15:34.218]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:34.218]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:34.218]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.218]             }
  [21:15:34.218]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.218]         }
  [21:15:34.218]     }
  [21:15:34.218]     if (base::is.na(TRUE)) {
  [21:15:34.218]     }
  [21:15:34.218]     else {
  [21:15:34.218]         if (TRUE) {
  [21:15:34.218]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.218]                 open = "w")
  [21:15:34.218]         }
  [21:15:34.218]         else {
  [21:15:34.218]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.218]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.218]         }
  [21:15:34.218]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.218]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.218]             base::sink(type = "output", split = FALSE)
  [21:15:34.218]             base::close(...future.stdout)
  [21:15:34.218]         }, add = TRUE)
  [21:15:34.218]     }
  [21:15:34.218]     ...future.frame <- base::sys.nframe()
  [21:15:34.218]     ...future.conditions <- base::list()
  [21:15:34.218]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.218]     ...future.result <- base::tryCatch({
  [21:15:34.218]         base::withCallingHandlers({
  [21:15:34.218]             ...future.value <- base::withVisible(base::local({
  [21:15:34.218]                 sample(x, size = 1L)
  [21:15:34.218]             }))
  [21:15:34.218]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.218]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.218]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.218]                 version = "1.8")
  [21:15:34.218]         }, condition = base::local({
  [21:15:34.218]             c <- base::c
  [21:15:34.218]             inherits <- base::inherits
  [21:15:34.218]             invokeRestart <- base::invokeRestart
  [21:15:34.218]             length <- base::length
  [21:15:34.218]             list <- base::list
  [21:15:34.218]             seq.int <- base::seq.int
  [21:15:34.218]             signalCondition <- base::signalCondition
  [21:15:34.218]             sys.calls <- base::sys.calls
  [21:15:34.218]             Sys.time <- base::Sys.time
  [21:15:34.218]             `[[` <- base::`[[`
  [21:15:34.218]             `+` <- base::`+`
  [21:15:34.218]             `<<-` <- base::`<<-`
  [21:15:34.218]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.218]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.218]                   3L)]
  [21:15:34.218]             }
  [21:15:34.218]             function(cond) {
  [21:15:34.218]                 if (inherits(cond, "error")) {
  [21:15:34.218]                   sessionInformation <- function() {
  [21:15:34.218]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.218]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.218]                       search = base::search(), system = base::Sys.info())
  [21:15:34.218]                   }
  [21:15:34.218]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.218]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.218]                     cond$call), session = sessionInformation(), 
  [21:15:34.218]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.218]                   signalCondition(cond)
  [21:15:34.218]                 }
  [21:15:34.218]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.218]                 ))) {
  [21:15:34.218]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.218]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.218]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.218]                   if (!signal) {
  [21:15:34.218]                     muffleCondition <- function (cond) 
  [21:15:34.218]                     {
  [21:15:34.218]                       inherits <- base::inherits
  [21:15:34.218]                       invokeRestart <- base::invokeRestart
  [21:15:34.218]                       muffled <- FALSE
  [21:15:34.218]                       if (inherits(cond, "message")) {
  [21:15:34.218]                         invokeRestart("muffleMessage")
  [21:15:34.218]                         muffled <- TRUE
  [21:15:34.218]                       }
  [21:15:34.218]                       else if (inherits(cond, "warning")) {
  [21:15:34.218]                         invokeRestart("muffleWarning")
  [21:15:34.218]                         muffled <- TRUE
  [21:15:34.218]                       }
  [21:15:34.218]                       else if (inherits(cond, "condition")) {
  [21:15:34.218]                         computeRestarts <- base::computeRestarts
  [21:15:34.218]                         grepl <- base::grepl
  [21:15:34.218]                         is.null <- base::is.null
  [21:15:34.218]                         restarts <- computeRestarts(cond)
  [21:15:34.218]                         for (restart in restarts) {
  [21:15:34.218]                           name <- restart$name
  [21:15:34.218]                           if (is.null(name)) 
  [21:15:34.218]                             next
  [21:15:34.218]                           if (!grepl("^muffle", name)) 
  [21:15:34.218]                             next
  [21:15:34.218]                           invokeRestart(restart)
  [21:15:34.218]                           muffled <- TRUE
  [21:15:34.218]                           break
  [21:15:34.218]                         }
  [21:15:34.218]                       }
  [21:15:34.218]                       invisible(muffled)
  [21:15:34.218]                     }
  [21:15:34.218]                     muffleCondition(cond)
  [21:15:34.218]                   }
  [21:15:34.218]                 }
  [21:15:34.218]             }
  [21:15:34.218]         }))
  [21:15:34.218]     }, error = function(ex) {
  [21:15:34.218]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.218]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.218]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.218]     }, finally = {
  [21:15:34.218]         {
  [21:15:34.218]             NULL
  [21:15:34.218]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.218]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.218]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.218]                 label = NULL, ...) 
  [21:15:34.218]             {
  [21:15:34.218]                 if (substitute) 
  [21:15:34.218]                   expr <- substitute(expr)
  [21:15:34.218]                 local <- as.logical(local)
  [21:15:34.218]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.218]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.218]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.218]                   label = label, ...)
  [21:15:34.218]                 if (!future$lazy) 
  [21:15:34.218]                   future <- run(future)
  [21:15:34.218]                 invisible(future)
  [21:15:34.218]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.218]         }
  [21:15:34.218]         base::options(...future.oldOptions)
  [21:15:34.218]     })
  [21:15:34.218]     Sys.time
  [21:15:34.218]     if (base::is.na(TRUE)) {
  [21:15:34.218]     }
  [21:15:34.218]     else {
  [21:15:34.218]         base::sink(type = "output", split = FALSE)
  [21:15:34.218]         if (TRUE) {
  [21:15:34.218]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.218]         }
  [21:15:34.218]         else {
  [21:15:34.218]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.218]         }
  [21:15:34.218]         base::close(...future.stdout)
  [21:15:34.218]         ...future.stdout <- NULL
  [21:15:34.218]     }
  [21:15:34.218]     ...future.result$conditions <- ...future.conditions
  [21:15:34.218]     ...future.result
  [21:15:34.218] }
  [21:15:34.223] plan(): Setting new future strategy stack:
  [21:15:34.223] List of future strategies:
  [21:15:34.223] 1. sequential:
  [21:15:34.223]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.223]    - tweaked: FALSE
  [21:15:34.223]    - call: NULL
  [21:15:34.224] plan(): nbrOfWorkers() = 1
  [21:15:34.225] plan(): Setting new future strategy stack:
  [21:15:34.226] List of future strategies:
  [21:15:34.226] 1. sequential:
  [21:15:34.226]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.226]    - tweaked: FALSE
  [21:15:34.226]    - call: plan(strategy)
  [21:15:34.227] plan(): nbrOfWorkers() = 1
  [21:15:34.227] SequentialFuture started (and completed)
  [21:15:34.228] getGlobalsAndPackages() ...
  [21:15:34.228] Searching for globals...
  [21:15:34.230] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.231] Searching for globals ... DONE
  [21:15:34.231] Resolving globals: FALSE
  [21:15:34.232] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.232] - globals: [1] 'x'
  [21:15:34.233] 
  [21:15:34.233] getGlobalsAndPackages() ... DONE
  [21:15:34.235] Packages needed by the future expression (n = 0): <none>
  [21:15:34.235] Packages needed by future strategies (n = 0): <none>
  [21:15:34.255] {
  [21:15:34.255]     {
  [21:15:34.255]         ...future.startTime <- base::Sys.time()
  [21:15:34.255]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.255]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.255]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.255]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.255]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.255]         {
  [21:15:34.255]             {
  [21:15:34.255]                 {
  [21:15:34.255]                   base::local({
  [21:15:34.255]                     has_future <- base::requireNamespace("future", 
  [21:15:34.255]                       quietly = TRUE)
  [21:15:34.255]                     version <- if (has_future) 
  [21:15:34.255]                       utils::packageVersion("future")
  [21:15:34.255]                     else NULL
  [21:15:34.255]                     if (!has_future || version < "1.8.0") {
  [21:15:34.255]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.255]                         "", base::R.version$version.string), 
  [21:15:34.255]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.255]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.255]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.255]                           "release", "version")], collapse = " "), 
  [21:15:34.255]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.255]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.255]                         info)
  [21:15:34.255]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.255]                       if (!has_future) {
  [21:15:34.255]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.255]                           info)
  [21:15:34.255]                       }
  [21:15:34.255]                       else {
  [21:15:34.255]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.255]                           info, version)
  [21:15:34.255]                       }
  [21:15:34.255]                       base::stop(msg)
  [21:15:34.255]                     }
  [21:15:34.255]                   })
  [21:15:34.255]                 }
  [21:15:34.255]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:34.255]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:34.255]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.255]             }
  [21:15:34.255]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.255]         }
  [21:15:34.255]     }
  [21:15:34.255]     if (base::is.na(TRUE)) {
  [21:15:34.255]     }
  [21:15:34.255]     else {
  [21:15:34.255]         if (TRUE) {
  [21:15:34.255]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.255]                 open = "w")
  [21:15:34.255]         }
  [21:15:34.255]         else {
  [21:15:34.255]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.255]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.255]         }
  [21:15:34.255]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.255]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.255]             base::sink(type = "output", split = FALSE)
  [21:15:34.255]             base::close(...future.stdout)
  [21:15:34.255]         }, add = TRUE)
  [21:15:34.255]     }
  [21:15:34.255]     ...future.frame <- base::sys.nframe()
  [21:15:34.255]     ...future.conditions <- base::list()
  [21:15:34.255]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.255]     ...future.result <- base::tryCatch({
  [21:15:34.255]         base::withCallingHandlers({
  [21:15:34.255]             ...future.value <- base::withVisible(base::local({
  [21:15:34.255]                 sample(x, size = 1L)
  [21:15:34.255]             }))
  [21:15:34.255]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.255]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.255]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.255]                 version = "1.8")
  [21:15:34.255]         }, condition = base::local({
  [21:15:34.255]             c <- base::c
  [21:15:34.255]             inherits <- base::inherits
  [21:15:34.255]             invokeRestart <- base::invokeRestart
  [21:15:34.255]             length <- base::length
  [21:15:34.255]             list <- base::list
  [21:15:34.255]             seq.int <- base::seq.int
  [21:15:34.255]             signalCondition <- base::signalCondition
  [21:15:34.255]             sys.calls <- base::sys.calls
  [21:15:34.255]             Sys.time <- base::Sys.time
  [21:15:34.255]             `[[` <- base::`[[`
  [21:15:34.255]             `+` <- base::`+`
  [21:15:34.255]             `<<-` <- base::`<<-`
  [21:15:34.255]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.255]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.255]                   3L)]
  [21:15:34.255]             }
  [21:15:34.255]             function(cond) {
  [21:15:34.255]                 if (inherits(cond, "error")) {
  [21:15:34.255]                   sessionInformation <- function() {
  [21:15:34.255]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.255]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.255]                       search = base::search(), system = base::Sys.info())
  [21:15:34.255]                   }
  [21:15:34.255]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.255]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.255]                     cond$call), session = sessionInformation(), 
  [21:15:34.255]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.255]                   signalCondition(cond)
  [21:15:34.255]                 }
  [21:15:34.255]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.255]                 ))) {
  [21:15:34.255]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.255]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.255]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.255]                   if (!signal) {
  [21:15:34.255]                     muffleCondition <- function (cond) 
  [21:15:34.255]                     {
  [21:15:34.255]                       inherits <- base::inherits
  [21:15:34.255]                       invokeRestart <- base::invokeRestart
  [21:15:34.255]                       muffled <- FALSE
  [21:15:34.255]                       if (inherits(cond, "message")) {
  [21:15:34.255]                         invokeRestart("muffleMessage")
  [21:15:34.255]                         muffled <- TRUE
  [21:15:34.255]                       }
  [21:15:34.255]                       else if (inherits(cond, "warning")) {
  [21:15:34.255]                         invokeRestart("muffleWarning")
  [21:15:34.255]                         muffled <- TRUE
  [21:15:34.255]                       }
  [21:15:34.255]                       else if (inherits(cond, "condition")) {
  [21:15:34.255]                         computeRestarts <- base::computeRestarts
  [21:15:34.255]                         grepl <- base::grepl
  [21:15:34.255]                         is.null <- base::is.null
  [21:15:34.255]                         restarts <- computeRestarts(cond)
  [21:15:34.255]                         for (restart in restarts) {
  [21:15:34.255]                           name <- restart$name
  [21:15:34.255]                           if (is.null(name)) 
  [21:15:34.255]                             next
  [21:15:34.255]                           if (!grepl("^muffle", name)) 
  [21:15:34.255]                             next
  [21:15:34.255]                           invokeRestart(restart)
  [21:15:34.255]                           muffled <- TRUE
  [21:15:34.255]                           break
  [21:15:34.255]                         }
  [21:15:34.255]                       }
  [21:15:34.255]                       invisible(muffled)
  [21:15:34.255]                     }
  [21:15:34.255]                     muffleCondition(cond)
  [21:15:34.255]                   }
  [21:15:34.255]                 }
  [21:15:34.255]             }
  [21:15:34.255]         }))
  [21:15:34.255]     }, error = function(ex) {
  [21:15:34.255]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.255]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.255]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.255]     }, finally = {
  [21:15:34.255]         {
  [21:15:34.255]             NULL
  [21:15:34.255]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.255]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.255]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.255]                 label = NULL, ...) 
  [21:15:34.255]             {
  [21:15:34.255]                 if (substitute) 
  [21:15:34.255]                   expr <- substitute(expr)
  [21:15:34.255]                 local <- as.logical(local)
  [21:15:34.255]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.255]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.255]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.255]                   label = label, ...)
  [21:15:34.255]                 if (!future$lazy) 
  [21:15:34.255]                   future <- run(future)
  [21:15:34.255]                 invisible(future)
  [21:15:34.255]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.255]         }
  [21:15:34.255]         base::options(...future.oldOptions)
  [21:15:34.255]     })
  [21:15:34.255]     Sys.time
  [21:15:34.255]     if (base::is.na(TRUE)) {
  [21:15:34.255]     }
  [21:15:34.255]     else {
  [21:15:34.255]         base::sink(type = "output", split = FALSE)
  [21:15:34.255]         if (TRUE) {
  [21:15:34.255]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.255]         }
  [21:15:34.255]         else {
  [21:15:34.255]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.255]         }
  [21:15:34.255]         base::close(...future.stdout)
  [21:15:34.255]         ...future.stdout <- NULL
  [21:15:34.255]     }
  [21:15:34.255]     ...future.result$conditions <- ...future.conditions
  [21:15:34.255]     ...future.result
  [21:15:34.255] }
  [21:15:34.260] plan(): Setting new future strategy stack:
  [21:15:34.261] List of future strategies:
  [21:15:34.261] 1. sequential:
  [21:15:34.261]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.261]    - tweaked: FALSE
  [21:15:34.261]    - call: NULL
  [21:15:34.261] plan(): nbrOfWorkers() = 1
  [21:15:34.263] plan(): Setting new future strategy stack:
  [21:15:34.263] List of future strategies:
  [21:15:34.263] 1. sequential:
  [21:15:34.263]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.263]    - tweaked: FALSE
  [21:15:34.263]    - call: plan(strategy)
  [21:15:34.264] plan(): nbrOfWorkers() = 1
  [21:15:34.264] SequentialFuture started (and completed)
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 1
  
  [21:15:34.267] getGlobalsAndPackages() ...
  [21:15:34.267] Searching for globals...
  [21:15:34.269] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.269] Searching for globals ... DONE
  [21:15:34.286] Resolving globals: FALSE
  [21:15:34.290] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.291] - globals: [1] 'x'
  [21:15:34.291] 
  [21:15:34.291] getGlobalsAndPackages() ... DONE
  [21:15:34.293] Packages needed by the future expression (n = 0): <none>
  [21:15:34.294] Packages needed by future strategies (n = 0): <none>
  [21:15:34.298] {
  [21:15:34.298]     {
  [21:15:34.298]         ...future.startTime <- base::Sys.time()
  [21:15:34.298]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.298]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.298]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.298]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.298]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.298]         {
  [21:15:34.298]             {
  [21:15:34.298]                 {
  [21:15:34.298]                   base::local({
  [21:15:34.298]                     has_future <- base::requireNamespace("future", 
  [21:15:34.298]                       quietly = TRUE)
  [21:15:34.298]                     version <- if (has_future) 
  [21:15:34.298]                       utils::packageVersion("future")
  [21:15:34.298]                     else NULL
  [21:15:34.298]                     if (!has_future || version < "1.8.0") {
  [21:15:34.298]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.298]                         "", base::R.version$version.string), 
  [21:15:34.298]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.298]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.298]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.298]                           "release", "version")], collapse = " "), 
  [21:15:34.298]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.298]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.298]                         info)
  [21:15:34.298]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.298]                       if (!has_future) {
  [21:15:34.298]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.298]                           info)
  [21:15:34.298]                       }
  [21:15:34.298]                       else {
  [21:15:34.298]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.298]                           info, version)
  [21:15:34.298]                       }
  [21:15:34.298]                       base::stop(msg)
  [21:15:34.298]                     }
  [21:15:34.298]                   })
  [21:15:34.298]                 }
  [21:15:34.298]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:34.298]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:34.298]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.298]             }
  [21:15:34.298]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.298]         }
  [21:15:34.298]     }
  [21:15:34.298]     if (base::is.na(TRUE)) {
  [21:15:34.298]     }
  [21:15:34.298]     else {
  [21:15:34.298]         if (TRUE) {
  [21:15:34.298]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.298]                 open = "w")
  [21:15:34.298]         }
  [21:15:34.298]         else {
  [21:15:34.298]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.298]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.298]         }
  [21:15:34.298]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.298]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.298]             base::sink(type = "output", split = FALSE)
  [21:15:34.298]             base::close(...future.stdout)
  [21:15:34.298]         }, add = TRUE)
  [21:15:34.298]     }
  [21:15:34.298]     ...future.frame <- base::sys.nframe()
  [21:15:34.298]     ...future.conditions <- base::list()
  [21:15:34.298]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.298]     ...future.result <- base::tryCatch({
  [21:15:34.298]         base::withCallingHandlers({
  [21:15:34.298]             ...future.value <- base::withVisible(base::local({
  [21:15:34.298]                 sample(x, size = 1L)
  [21:15:34.298]             }))
  [21:15:34.298]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.298]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.298]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.298]                 version = "1.8")
  [21:15:34.298]         }, condition = base::local({
  [21:15:34.298]             c <- base::c
  [21:15:34.298]             inherits <- base::inherits
  [21:15:34.298]             invokeRestart <- base::invokeRestart
  [21:15:34.298]             length <- base::length
  [21:15:34.298]             list <- base::list
  [21:15:34.298]             seq.int <- base::seq.int
  [21:15:34.298]             signalCondition <- base::signalCondition
  [21:15:34.298]             sys.calls <- base::sys.calls
  [21:15:34.298]             Sys.time <- base::Sys.time
  [21:15:34.298]             `[[` <- base::`[[`
  [21:15:34.298]             `+` <- base::`+`
  [21:15:34.298]             `<<-` <- base::`<<-`
  [21:15:34.298]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.298]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.298]                   3L)]
  [21:15:34.298]             }
  [21:15:34.298]             function(cond) {
  [21:15:34.298]                 if (inherits(cond, "error")) {
  [21:15:34.298]                   sessionInformation <- function() {
  [21:15:34.298]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.298]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.298]                       search = base::search(), system = base::Sys.info())
  [21:15:34.298]                   }
  [21:15:34.298]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.298]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.298]                     cond$call), session = sessionInformation(), 
  [21:15:34.298]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.298]                   signalCondition(cond)
  [21:15:34.298]                 }
  [21:15:34.298]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.298]                 ))) {
  [21:15:34.298]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.298]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.298]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.298]                   if (!signal) {
  [21:15:34.298]                     muffleCondition <- function (cond) 
  [21:15:34.298]                     {
  [21:15:34.298]                       inherits <- base::inherits
  [21:15:34.298]                       invokeRestart <- base::invokeRestart
  [21:15:34.298]                       muffled <- FALSE
  [21:15:34.298]                       if (inherits(cond, "message")) {
  [21:15:34.298]                         invokeRestart("muffleMessage")
  [21:15:34.298]                         muffled <- TRUE
  [21:15:34.298]                       }
  [21:15:34.298]                       else if (inherits(cond, "warning")) {
  [21:15:34.298]                         invokeRestart("muffleWarning")
  [21:15:34.298]                         muffled <- TRUE
  [21:15:34.298]                       }
  [21:15:34.298]                       else if (inherits(cond, "condition")) {
  [21:15:34.298]                         computeRestarts <- base::computeRestarts
  [21:15:34.298]                         grepl <- base::grepl
  [21:15:34.298]                         is.null <- base::is.null
  [21:15:34.298]                         restarts <- computeRestarts(cond)
  [21:15:34.298]                         for (restart in restarts) {
  [21:15:34.298]                           name <- restart$name
  [21:15:34.298]                           if (is.null(name)) 
  [21:15:34.298]                             next
  [21:15:34.298]                           if (!grepl("^muffle", name)) 
  [21:15:34.298]                             next
  [21:15:34.298]                           invokeRestart(restart)
  [21:15:34.298]                           muffled <- TRUE
  [21:15:34.298]                           break
  [21:15:34.298]                         }
  [21:15:34.298]                       }
  [21:15:34.298]                       invisible(muffled)
  [21:15:34.298]                     }
  [21:15:34.298]                     muffleCondition(cond)
  [21:15:34.298]                   }
  [21:15:34.298]                 }
  [21:15:34.298]             }
  [21:15:34.298]         }))
  [21:15:34.298]     }, error = function(ex) {
  [21:15:34.298]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.298]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.298]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.298]     }, finally = {
  [21:15:34.298]         {
  [21:15:34.298]             NULL
  [21:15:34.298]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.298]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.298]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.298]                 label = NULL, ...) 
  [21:15:34.298]             {
  [21:15:34.298]                 if (substitute) 
  [21:15:34.298]                   expr <- substitute(expr)
  [21:15:34.298]                 local <- as.logical(local)
  [21:15:34.298]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.298]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.298]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.298]                   label = label, ...)
  [21:15:34.298]                 if (!future$lazy) 
  [21:15:34.298]                   future <- run(future)
  [21:15:34.298]                 invisible(future)
  [21:15:34.298]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.298]         }
  [21:15:34.298]         base::options(...future.oldOptions)
  [21:15:34.298]     })
  [21:15:34.298]     Sys.time
  [21:15:34.298]     if (base::is.na(TRUE)) {
  [21:15:34.298]     }
  [21:15:34.298]     else {
  [21:15:34.298]         base::sink(type = "output", split = FALSE)
  [21:15:34.298]         if (TRUE) {
  [21:15:34.298]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.298]         }
  [21:15:34.298]         else {
  [21:15:34.298]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.298]         }
  [21:15:34.298]         base::close(...future.stdout)
  [21:15:34.298]         ...future.stdout <- NULL
  [21:15:34.298]     }
  [21:15:34.298]     ...future.result$conditions <- ...future.conditions
  [21:15:34.298]     ...future.result
  [21:15:34.298] }
  [21:15:34.319] plan(): Setting new future strategy stack:
  [21:15:34.319] List of future strategies:
  [21:15:34.319] 1. sequential:
  [21:15:34.319]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.319]    - tweaked: FALSE
  [21:15:34.319]    - call: NULL
  [21:15:34.320] plan(): nbrOfWorkers() = 1
  [21:15:34.321] plan(): Setting new future strategy stack:
  [21:15:34.322] List of future strategies:
  [21:15:34.322] 1. sequential:
  [21:15:34.322]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.322]    - tweaked: FALSE
  [21:15:34.322]    - call: plan(strategy)
  [21:15:34.323] plan(): nbrOfWorkers() = 1
  [21:15:34.323] SequentialFuture started (and completed)
  [21:15:34.324] getGlobalsAndPackages() ...
  [21:15:34.325] Searching for globals...
  [21:15:34.327] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.327] Searching for globals ... DONE
  [21:15:34.327] Resolving globals: FALSE
  [21:15:34.328] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.329] - globals: [1] 'x'
  [21:15:34.329] 
  [21:15:34.329] getGlobalsAndPackages() ... DONE
  [21:15:34.331] Packages needed by the future expression (n = 0): <none>
  [21:15:34.331] Packages needed by future strategies (n = 0): <none>
  [21:15:34.351] {
  [21:15:34.351]     {
  [21:15:34.351]         ...future.startTime <- base::Sys.time()
  [21:15:34.351]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.351]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.351]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.351]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.351]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.351]         {
  [21:15:34.351]             {
  [21:15:34.351]                 {
  [21:15:34.351]                   base::local({
  [21:15:34.351]                     has_future <- base::requireNamespace("future", 
  [21:15:34.351]                       quietly = TRUE)
  [21:15:34.351]                     version <- if (has_future) 
  [21:15:34.351]                       utils::packageVersion("future")
  [21:15:34.351]                     else NULL
  [21:15:34.351]                     if (!has_future || version < "1.8.0") {
  [21:15:34.351]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.351]                         "", base::R.version$version.string), 
  [21:15:34.351]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.351]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.351]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.351]                           "release", "version")], collapse = " "), 
  [21:15:34.351]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.351]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.351]                         info)
  [21:15:34.351]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.351]                       if (!has_future) {
  [21:15:34.351]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.351]                           info)
  [21:15:34.351]                       }
  [21:15:34.351]                       else {
  [21:15:34.351]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.351]                           info, version)
  [21:15:34.351]                       }
  [21:15:34.351]                       base::stop(msg)
  [21:15:34.351]                     }
  [21:15:34.351]                   })
  [21:15:34.351]                 }
  [21:15:34.351]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:34.351]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:34.351]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.351]             }
  [21:15:34.351]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.351]         }
  [21:15:34.351]     }
  [21:15:34.351]     if (base::is.na(TRUE)) {
  [21:15:34.351]     }
  [21:15:34.351]     else {
  [21:15:34.351]         if (TRUE) {
  [21:15:34.351]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.351]                 open = "w")
  [21:15:34.351]         }
  [21:15:34.351]         else {
  [21:15:34.351]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.351]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.351]         }
  [21:15:34.351]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.351]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.351]             base::sink(type = "output", split = FALSE)
  [21:15:34.351]             base::close(...future.stdout)
  [21:15:34.351]         }, add = TRUE)
  [21:15:34.351]     }
  [21:15:34.351]     ...future.frame <- base::sys.nframe()
  [21:15:34.351]     ...future.conditions <- base::list()
  [21:15:34.351]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.351]     ...future.result <- base::tryCatch({
  [21:15:34.351]         base::withCallingHandlers({
  [21:15:34.351]             ...future.value <- base::withVisible(base::local({
  [21:15:34.351]                 sample(x, size = 1L)
  [21:15:34.351]             }))
  [21:15:34.351]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.351]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.351]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.351]                 version = "1.8")
  [21:15:34.351]         }, condition = base::local({
  [21:15:34.351]             c <- base::c
  [21:15:34.351]             inherits <- base::inherits
  [21:15:34.351]             invokeRestart <- base::invokeRestart
  [21:15:34.351]             length <- base::length
  [21:15:34.351]             list <- base::list
  [21:15:34.351]             seq.int <- base::seq.int
  [21:15:34.351]             signalCondition <- base::signalCondition
  [21:15:34.351]             sys.calls <- base::sys.calls
  [21:15:34.351]             Sys.time <- base::Sys.time
  [21:15:34.351]             `[[` <- base::`[[`
  [21:15:34.351]             `+` <- base::`+`
  [21:15:34.351]             `<<-` <- base::`<<-`
  [21:15:34.351]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.351]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.351]                   3L)]
  [21:15:34.351]             }
  [21:15:34.351]             function(cond) {
  [21:15:34.351]                 if (inherits(cond, "error")) {
  [21:15:34.351]                   sessionInformation <- function() {
  [21:15:34.351]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.351]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.351]                       search = base::search(), system = base::Sys.info())
  [21:15:34.351]                   }
  [21:15:34.351]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.351]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.351]                     cond$call), session = sessionInformation(), 
  [21:15:34.351]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.351]                   signalCondition(cond)
  [21:15:34.351]                 }
  [21:15:34.351]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.351]                 ))) {
  [21:15:34.351]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.351]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.351]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.351]                   if (!signal) {
  [21:15:34.351]                     muffleCondition <- function (cond) 
  [21:15:34.351]                     {
  [21:15:34.351]                       inherits <- base::inherits
  [21:15:34.351]                       invokeRestart <- base::invokeRestart
  [21:15:34.351]                       muffled <- FALSE
  [21:15:34.351]                       if (inherits(cond, "message")) {
  [21:15:34.351]                         invokeRestart("muffleMessage")
  [21:15:34.351]                         muffled <- TRUE
  [21:15:34.351]                       }
  [21:15:34.351]                       else if (inherits(cond, "warning")) {
  [21:15:34.351]                         invokeRestart("muffleWarning")
  [21:15:34.351]                         muffled <- TRUE
  [21:15:34.351]                       }
  [21:15:34.351]                       else if (inherits(cond, "condition")) {
  [21:15:34.351]                         computeRestarts <- base::computeRestarts
  [21:15:34.351]                         grepl <- base::grepl
  [21:15:34.351]                         is.null <- base::is.null
  [21:15:34.351]                         restarts <- computeRestarts(cond)
  [21:15:34.351]                         for (restart in restarts) {
  [21:15:34.351]                           name <- restart$name
  [21:15:34.351]                           if (is.null(name)) 
  [21:15:34.351]                             next
  [21:15:34.351]                           if (!grepl("^muffle", name)) 
  [21:15:34.351]                             next
  [21:15:34.351]                           invokeRestart(restart)
  [21:15:34.351]                           muffled <- TRUE
  [21:15:34.351]                           break
  [21:15:34.351]                         }
  [21:15:34.351]                       }
  [21:15:34.351]                       invisible(muffled)
  [21:15:34.351]                     }
  [21:15:34.351]                     muffleCondition(cond)
  [21:15:34.351]                   }
  [21:15:34.351]                 }
  [21:15:34.351]             }
  [21:15:34.351]         }))
  [21:15:34.351]     }, error = function(ex) {
  [21:15:34.351]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.351]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.351]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.351]     }, finally = {
  [21:15:34.351]         {
  [21:15:34.351]             NULL
  [21:15:34.351]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.351]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.351]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.351]                 label = NULL, ...) 
  [21:15:34.351]             {
  [21:15:34.351]                 if (substitute) 
  [21:15:34.351]                   expr <- substitute(expr)
  [21:15:34.351]                 local <- as.logical(local)
  [21:15:34.351]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.351]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.351]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.351]                   label = label, ...)
  [21:15:34.351]                 if (!future$lazy) 
  [21:15:34.351]                   future <- run(future)
  [21:15:34.351]                 invisible(future)
  [21:15:34.351]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.351]         }
  [21:15:34.351]         base::options(...future.oldOptions)
  [21:15:34.351]     })
  [21:15:34.351]     Sys.time
  [21:15:34.351]     if (base::is.na(TRUE)) {
  [21:15:34.351]     }
  [21:15:34.351]     else {
  [21:15:34.351]         base::sink(type = "output", split = FALSE)
  [21:15:34.351]         if (TRUE) {
  [21:15:34.351]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.351]         }
  [21:15:34.351]         else {
  [21:15:34.351]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.351]         }
  [21:15:34.351]         base::close(...future.stdout)
  [21:15:34.351]         ...future.stdout <- NULL
  [21:15:34.351]     }
  [21:15:34.351]     ...future.result$conditions <- ...future.conditions
  [21:15:34.351]     ...future.result
  [21:15:34.351] }
  [21:15:34.356] plan(): Setting new future strategy stack:
  [21:15:34.356] List of future strategies:
  [21:15:34.356] 1. sequential:
  [21:15:34.356]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.356]    - tweaked: FALSE
  [21:15:34.356]    - call: NULL
  [21:15:34.357] plan(): nbrOfWorkers() = 1
  [21:15:34.358] plan(): Setting new future strategy stack:
  [21:15:34.358] List of future strategies:
  [21:15:34.358] 1. sequential:
  [21:15:34.358]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.358]    - tweaked: FALSE
  [21:15:34.358]    - call: plan(strategy)
  [21:15:34.359] plan(): nbrOfWorkers() = 1
  [21:15:34.360] SequentialFuture started (and completed)
  [21:15:34.361] getGlobalsAndPackages() ...
  [21:15:34.361] Searching for globals...
  [21:15:34.363] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.363] Searching for globals ... DONE
  [21:15:34.364] Resolving globals: FALSE
  [21:15:34.364] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.365] - globals: [1] 'x'
  [21:15:34.365] 
  [21:15:34.365] getGlobalsAndPackages() ... DONE
  [21:15:34.383] Packages needed by the future expression (n = 0): <none>
  [21:15:34.384] Packages needed by future strategies (n = 0): <none>
  [21:15:34.388] {
  [21:15:34.388]     {
  [21:15:34.388]         ...future.startTime <- base::Sys.time()
  [21:15:34.388]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.388]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.388]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.388]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.388]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.388]         {
  [21:15:34.388]             {
  [21:15:34.388]                 {
  [21:15:34.388]                   base::local({
  [21:15:34.388]                     has_future <- base::requireNamespace("future", 
  [21:15:34.388]                       quietly = TRUE)
  [21:15:34.388]                     version <- if (has_future) 
  [21:15:34.388]                       utils::packageVersion("future")
  [21:15:34.388]                     else NULL
  [21:15:34.388]                     if (!has_future || version < "1.8.0") {
  [21:15:34.388]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.388]                         "", base::R.version$version.string), 
  [21:15:34.388]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.388]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.388]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.388]                           "release", "version")], collapse = " "), 
  [21:15:34.388]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.388]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.388]                         info)
  [21:15:34.388]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.388]                       if (!has_future) {
  [21:15:34.388]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.388]                           info)
  [21:15:34.388]                       }
  [21:15:34.388]                       else {
  [21:15:34.388]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.388]                           info, version)
  [21:15:34.388]                       }
  [21:15:34.388]                       base::stop(msg)
  [21:15:34.388]                     }
  [21:15:34.388]                   })
  [21:15:34.388]                 }
  [21:15:34.388]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:34.388]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:34.388]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.388]             }
  [21:15:34.388]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.388]         }
  [21:15:34.388]     }
  [21:15:34.388]     if (base::is.na(TRUE)) {
  [21:15:34.388]     }
  [21:15:34.388]     else {
  [21:15:34.388]         if (TRUE) {
  [21:15:34.388]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.388]                 open = "w")
  [21:15:34.388]         }
  [21:15:34.388]         else {
  [21:15:34.388]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.388]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.388]         }
  [21:15:34.388]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.388]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.388]             base::sink(type = "output", split = FALSE)
  [21:15:34.388]             base::close(...future.stdout)
  [21:15:34.388]         }, add = TRUE)
  [21:15:34.388]     }
  [21:15:34.388]     ...future.frame <- base::sys.nframe()
  [21:15:34.388]     ...future.conditions <- base::list()
  [21:15:34.388]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.388]     ...future.result <- base::tryCatch({
  [21:15:34.388]         base::withCallingHandlers({
  [21:15:34.388]             ...future.value <- base::withVisible(base::local({
  [21:15:34.388]                 sample(x, size = 1L)
  [21:15:34.388]             }))
  [21:15:34.388]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.388]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.388]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.388]                 version = "1.8")
  [21:15:34.388]         }, condition = base::local({
  [21:15:34.388]             c <- base::c
  [21:15:34.388]             inherits <- base::inherits
  [21:15:34.388]             invokeRestart <- base::invokeRestart
  [21:15:34.388]             length <- base::length
  [21:15:34.388]             list <- base::list
  [21:15:34.388]             seq.int <- base::seq.int
  [21:15:34.388]             signalCondition <- base::signalCondition
  [21:15:34.388]             sys.calls <- base::sys.calls
  [21:15:34.388]             Sys.time <- base::Sys.time
  [21:15:34.388]             `[[` <- base::`[[`
  [21:15:34.388]             `+` <- base::`+`
  [21:15:34.388]             `<<-` <- base::`<<-`
  [21:15:34.388]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.388]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.388]                   3L)]
  [21:15:34.388]             }
  [21:15:34.388]             function(cond) {
  [21:15:34.388]                 if (inherits(cond, "error")) {
  [21:15:34.388]                   sessionInformation <- function() {
  [21:15:34.388]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.388]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.388]                       search = base::search(), system = base::Sys.info())
  [21:15:34.388]                   }
  [21:15:34.388]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.388]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.388]                     cond$call), session = sessionInformation(), 
  [21:15:34.388]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.388]                   signalCondition(cond)
  [21:15:34.388]                 }
  [21:15:34.388]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.388]                 ))) {
  [21:15:34.388]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.388]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.388]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.388]                   if (!signal) {
  [21:15:34.388]                     muffleCondition <- function (cond) 
  [21:15:34.388]                     {
  [21:15:34.388]                       inherits <- base::inherits
  [21:15:34.388]                       invokeRestart <- base::invokeRestart
  [21:15:34.388]                       muffled <- FALSE
  [21:15:34.388]                       if (inherits(cond, "message")) {
  [21:15:34.388]                         invokeRestart("muffleMessage")
  [21:15:34.388]                         muffled <- TRUE
  [21:15:34.388]                       }
  [21:15:34.388]                       else if (inherits(cond, "warning")) {
  [21:15:34.388]                         invokeRestart("muffleWarning")
  [21:15:34.388]                         muffled <- TRUE
  [21:15:34.388]                       }
  [21:15:34.388]                       else if (inherits(cond, "condition")) {
  [21:15:34.388]                         computeRestarts <- base::computeRestarts
  [21:15:34.388]                         grepl <- base::grepl
  [21:15:34.388]                         is.null <- base::is.null
  [21:15:34.388]                         restarts <- computeRestarts(cond)
  [21:15:34.388]                         for (restart in restarts) {
  [21:15:34.388]                           name <- restart$name
  [21:15:34.388]                           if (is.null(name)) 
  [21:15:34.388]                             next
  [21:15:34.388]                           if (!grepl("^muffle", name)) 
  [21:15:34.388]                             next
  [21:15:34.388]                           invokeRestart(restart)
  [21:15:34.388]                           muffled <- TRUE
  [21:15:34.388]                           break
  [21:15:34.388]                         }
  [21:15:34.388]                       }
  [21:15:34.388]                       invisible(muffled)
  [21:15:34.388]                     }
  [21:15:34.388]                     muffleCondition(cond)
  [21:15:34.388]                   }
  [21:15:34.388]                 }
  [21:15:34.388]             }
  [21:15:34.388]         }))
  [21:15:34.388]     }, error = function(ex) {
  [21:15:34.388]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.388]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.388]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.388]     }, finally = {
  [21:15:34.388]         {
  [21:15:34.388]             NULL
  [21:15:34.388]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.388]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.388]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.388]                 label = NULL, ...) 
  [21:15:34.388]             {
  [21:15:34.388]                 if (substitute) 
  [21:15:34.388]                   expr <- substitute(expr)
  [21:15:34.388]                 local <- as.logical(local)
  [21:15:34.388]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.388]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.388]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.388]                   label = label, ...)
  [21:15:34.388]                 if (!future$lazy) 
  [21:15:34.388]                   future <- run(future)
  [21:15:34.388]                 invisible(future)
  [21:15:34.388]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.388]         }
  [21:15:34.388]         base::options(...future.oldOptions)
  [21:15:34.388]     })
  [21:15:34.388]     Sys.time
  [21:15:34.388]     if (base::is.na(TRUE)) {
  [21:15:34.388]     }
  [21:15:34.388]     else {
  [21:15:34.388]         base::sink(type = "output", split = FALSE)
  [21:15:34.388]         if (TRUE) {
  [21:15:34.388]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.388]         }
  [21:15:34.388]         else {
  [21:15:34.388]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.388]         }
  [21:15:34.388]         base::close(...future.stdout)
  [21:15:34.388]         ...future.stdout <- NULL
  [21:15:34.388]     }
  [21:15:34.388]     ...future.result$conditions <- ...future.conditions
  [21:15:34.388]     ...future.result
  [21:15:34.388] }
  [21:15:34.393] plan(): Setting new future strategy stack:
  [21:15:34.393] List of future strategies:
  [21:15:34.393] 1. sequential:
  [21:15:34.393]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.393]    - tweaked: FALSE
  [21:15:34.393]    - call: NULL
  [21:15:34.394] plan(): nbrOfWorkers() = 1
  [21:15:34.395] plan(): Setting new future strategy stack:
  [21:15:34.395] List of future strategies:
  [21:15:34.395] 1. sequential:
  [21:15:34.395]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.395]    - tweaked: FALSE
  [21:15:34.395]    - call: plan(strategy)
  [21:15:34.396] plan(): nbrOfWorkers() = 1
  [21:15:34.397] SequentialFuture started (and completed)
  [21:15:34.414] getGlobalsAndPackages() ...
  [21:15:34.414] Searching for globals...
  [21:15:34.420] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.420] Searching for globals ... DONE
  [21:15:34.421] Resolving globals: FALSE
  [21:15:34.421] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.422] - globals: [1] 'x'
  [21:15:34.422] 
  [21:15:34.422] getGlobalsAndPackages() ... DONE
  [21:15:34.424] Packages needed by the future expression (n = 0): <none>
  [21:15:34.425] Packages needed by future strategies (n = 0): <none>
  [21:15:34.429] {
  [21:15:34.429]     {
  [21:15:34.429]         ...future.startTime <- base::Sys.time()
  [21:15:34.429]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.429]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.429]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.429]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.429]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.429]         {
  [21:15:34.429]             {
  [21:15:34.429]                 {
  [21:15:34.429]                   base::local({
  [21:15:34.429]                     has_future <- base::requireNamespace("future", 
  [21:15:34.429]                       quietly = TRUE)
  [21:15:34.429]                     version <- if (has_future) 
  [21:15:34.429]                       utils::packageVersion("future")
  [21:15:34.429]                     else NULL
  [21:15:34.429]                     if (!has_future || version < "1.8.0") {
  [21:15:34.429]                       info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.429]                         "", base::R.version$version.string), 
  [21:15:34.429]                         platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.429]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.429]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.429]                           "release", "version")], collapse = " "), 
  [21:15:34.429]                         hostname = base::Sys.info()[["nodename"]])
  [21:15:34.429]                       info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.429]                         info)
  [21:15:34.429]                       info <- base::paste(info, collapse = "; ")
  [21:15:34.429]                       if (!has_future) {
  [21:15:34.429]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.429]                           info)
  [21:15:34.429]                       }
  [21:15:34.429]                       else {
  [21:15:34.429]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.429]                           info, version)
  [21:15:34.429]                       }
  [21:15:34.429]                       base::stop(msg)
  [21:15:34.429]                     }
  [21:15:34.429]                   })
  [21:15:34.429]                 }
  [21:15:34.429]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:34.429]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:34.429]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:34.429]             }
  [21:15:34.429]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.429]         }
  [21:15:34.429]     }
  [21:15:34.429]     if (base::is.na(TRUE)) {
  [21:15:34.429]     }
  [21:15:34.429]     else {
  [21:15:34.429]         if (TRUE) {
  [21:15:34.429]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.429]                 open = "w")
  [21:15:34.429]         }
  [21:15:34.429]         else {
  [21:15:34.429]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.429]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.429]         }
  [21:15:34.429]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.429]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.429]             base::sink(type = "output", split = FALSE)
  [21:15:34.429]             base::close(...future.stdout)
  [21:15:34.429]         }, add = TRUE)
  [21:15:34.429]     }
  [21:15:34.429]     ...future.frame <- base::sys.nframe()
  [21:15:34.429]     ...future.conditions <- base::list()
  [21:15:34.429]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.429]     ...future.result <- base::tryCatch({
  [21:15:34.429]         base::withCallingHandlers({
  [21:15:34.429]             ...future.value <- base::withVisible(base::local({
  [21:15:34.429]                 sample(x, size = 1L)
  [21:15:34.429]             }))
  [21:15:34.429]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.429]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.429]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.429]                 version = "1.8")
  [21:15:34.429]         }, condition = base::local({
  [21:15:34.429]             c <- base::c
  [21:15:34.429]             inherits <- base::inherits
  [21:15:34.429]             invokeRestart <- base::invokeRestart
  [21:15:34.429]             length <- base::length
  [21:15:34.429]             list <- base::list
  [21:15:34.429]             seq.int <- base::seq.int
  [21:15:34.429]             signalCondition <- base::signalCondition
  [21:15:34.429]             sys.calls <- base::sys.calls
  [21:15:34.429]             Sys.time <- base::Sys.time
  [21:15:34.429]             `[[` <- base::`[[`
  [21:15:34.429]             `+` <- base::`+`
  [21:15:34.429]             `<<-` <- base::`<<-`
  [21:15:34.429]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.429]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.429]                   3L)]
  [21:15:34.429]             }
  [21:15:34.429]             function(cond) {
  [21:15:34.429]                 if (inherits(cond, "error")) {
  [21:15:34.429]                   sessionInformation <- function() {
  [21:15:34.429]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.429]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.429]                       search = base::search(), system = base::Sys.info())
  [21:15:34.429]                   }
  [21:15:34.429]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.429]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.429]                     cond$call), session = sessionInformation(), 
  [21:15:34.429]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.429]                   signalCondition(cond)
  [21:15:34.429]                 }
  [21:15:34.429]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.429]                 ))) {
  [21:15:34.429]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.429]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.429]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.429]                   if (!signal) {
  [21:15:34.429]                     muffleCondition <- function (cond) 
  [21:15:34.429]                     {
  [21:15:34.429]                       inherits <- base::inherits
  [21:15:34.429]                       invokeRestart <- base::invokeRestart
  [21:15:34.429]                       muffled <- FALSE
  [21:15:34.429]                       if (inherits(cond, "message")) {
  [21:15:34.429]                         invokeRestart("muffleMessage")
  [21:15:34.429]                         muffled <- TRUE
  [21:15:34.429]                       }
  [21:15:34.429]                       else if (inherits(cond, "warning")) {
  [21:15:34.429]                         invokeRestart("muffleWarning")
  [21:15:34.429]                         muffled <- TRUE
  [21:15:34.429]                       }
  [21:15:34.429]                       else if (inherits(cond, "condition")) {
  [21:15:34.429]                         computeRestarts <- base::computeRestarts
  [21:15:34.429]                         grepl <- base::grepl
  [21:15:34.429]                         is.null <- base::is.null
  [21:15:34.429]                         restarts <- computeRestarts(cond)
  [21:15:34.429]                         for (restart in restarts) {
  [21:15:34.429]                           name <- restart$name
  [21:15:34.429]                           if (is.null(name)) 
  [21:15:34.429]                             next
  [21:15:34.429]                           if (!grepl("^muffle", name)) 
  [21:15:34.429]                             next
  [21:15:34.429]                           invokeRestart(restart)
  [21:15:34.429]                           muffled <- TRUE
  [21:15:34.429]                           break
  [21:15:34.429]                         }
  [21:15:34.429]                       }
  [21:15:34.429]                       invisible(muffled)
  [21:15:34.429]                     }
  [21:15:34.429]                     muffleCondition(cond)
  [21:15:34.429]                   }
  [21:15:34.429]                 }
  [21:15:34.429]             }
  [21:15:34.429]         }))
  [21:15:34.429]     }, error = function(ex) {
  [21:15:34.429]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.429]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.429]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.429]     }, finally = {
  [21:15:34.429]         {
  [21:15:34.429]             NULL
  [21:15:34.429]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.429]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.429]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.429]                 label = NULL, ...) 
  [21:15:34.429]             {
  [21:15:34.429]                 if (substitute) 
  [21:15:34.429]                   expr <- substitute(expr)
  [21:15:34.429]                 local <- as.logical(local)
  [21:15:34.429]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.429]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.429]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.429]                   label = label, ...)
  [21:15:34.429]                 if (!future$lazy) 
  [21:15:34.429]                   future <- run(future)
  [21:15:34.429]                 invisible(future)
  [21:15:34.429]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.429]         }
  [21:15:34.429]         base::options(...future.oldOptions)
  [21:15:34.429]     })
  [21:15:34.429]     Sys.time
  [21:15:34.429]     if (base::is.na(TRUE)) {
  [21:15:34.429]     }
  [21:15:34.429]     else {
  [21:15:34.429]         base::sink(type = "output", split = FALSE)
  [21:15:34.429]         if (TRUE) {
  [21:15:34.429]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.429]         }
  [21:15:34.429]         else {
  [21:15:34.429]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.429]         }
  [21:15:34.429]         base::close(...future.stdout)
  [21:15:34.429]         ...future.stdout <- NULL
  [21:15:34.429]     }
  [21:15:34.429]     ...future.result$conditions <- ...future.conditions
  [21:15:34.429]     ...future.result
  [21:15:34.429] }
  [21:15:34.445] plan(): Setting new future strategy stack:
  [21:15:34.446] List of future strategies:
  [21:15:34.446] 1. sequential:
  [21:15:34.446]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.446]    - tweaked: FALSE
  [21:15:34.446]    - call: NULL
  [21:15:34.447] plan(): nbrOfWorkers() = 1
  [21:15:34.448] plan(): Setting new future strategy stack:
  [21:15:34.448] List of future strategies:
  [21:15:34.448] 1. sequential:
  [21:15:34.448]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.448]    - tweaked: FALSE
  [21:15:34.448]    - call: plan(strategy)
  [21:15:34.449] plan(): nbrOfWorkers() = 1
  [21:15:34.449] SequentialFuture started (and completed)
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 1
  
  [21:15:34.452] getGlobalsAndPackages() ...
  [21:15:34.452] Searching for globals...
  [21:15:34.482] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.483] Searching for globals ... DONE
  [21:15:34.483] Resolving globals: FALSE
  [21:15:34.484] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.484] - globals: [1] 'x'
  [21:15:34.485] 
  [21:15:34.485] getGlobalsAndPackages() ... DONE
  [21:15:34.487] Packages needed by the future expression (n = 0): <none>
  [21:15:34.487] Packages needed by future strategies (n = 0): <none>
  [21:15:34.492] {
  [21:15:34.492]     {
  [21:15:34.492]         ...future.startTime <- base::Sys.time()
  [21:15:34.492]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.492]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.492]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.492]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.492]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.492]         {
  [21:15:34.492]             {
  [21:15:34.492]                 base::local({
  [21:15:34.492]                   has_future <- base::requireNamespace("future", 
  [21:15:34.492]                     quietly = TRUE)
  [21:15:34.492]                   version <- if (has_future) 
  [21:15:34.492]                     utils::packageVersion("future")
  [21:15:34.492]                   else NULL
  [21:15:34.492]                   if (!has_future || version < "1.8.0") {
  [21:15:34.492]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.492]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.492]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.492]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.492]                         "release", "version")], collapse = " "), 
  [21:15:34.492]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.492]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.492]                       info)
  [21:15:34.492]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.492]                     if (!has_future) {
  [21:15:34.492]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.492]                         info)
  [21:15:34.492]                     }
  [21:15:34.492]                     else {
  [21:15:34.492]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.492]                         info, version)
  [21:15:34.492]                     }
  [21:15:34.492]                     base::stop(msg)
  [21:15:34.492]                   }
  [21:15:34.492]                 })
  [21:15:34.492]             }
  [21:15:34.492]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.492]         }
  [21:15:34.492]     }
  [21:15:34.492]     if (base::is.na(TRUE)) {
  [21:15:34.492]     }
  [21:15:34.492]     else {
  [21:15:34.492]         if (TRUE) {
  [21:15:34.492]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.492]                 open = "w")
  [21:15:34.492]         }
  [21:15:34.492]         else {
  [21:15:34.492]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.492]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.492]         }
  [21:15:34.492]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.492]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.492]             base::sink(type = "output", split = FALSE)
  [21:15:34.492]             base::close(...future.stdout)
  [21:15:34.492]         }, add = TRUE)
  [21:15:34.492]     }
  [21:15:34.492]     ...future.frame <- base::sys.nframe()
  [21:15:34.492]     ...future.conditions <- base::list()
  [21:15:34.492]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.492]     ...future.result <- base::tryCatch({
  [21:15:34.492]         base::withCallingHandlers({
  [21:15:34.492]             ...future.value <- base::withVisible(base::local({
  [21:15:34.492]                 sample(x, size = 1L)
  [21:15:34.492]             }))
  [21:15:34.492]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.492]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.492]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.492]                 version = "1.8")
  [21:15:34.492]         }, condition = base::local({
  [21:15:34.492]             c <- base::c
  [21:15:34.492]             inherits <- base::inherits
  [21:15:34.492]             invokeRestart <- base::invokeRestart
  [21:15:34.492]             length <- base::length
  [21:15:34.492]             list <- base::list
  [21:15:34.492]             seq.int <- base::seq.int
  [21:15:34.492]             signalCondition <- base::signalCondition
  [21:15:34.492]             sys.calls <- base::sys.calls
  [21:15:34.492]             Sys.time <- base::Sys.time
  [21:15:34.492]             `[[` <- base::`[[`
  [21:15:34.492]             `+` <- base::`+`
  [21:15:34.492]             `<<-` <- base::`<<-`
  [21:15:34.492]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.492]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.492]                   3L)]
  [21:15:34.492]             }
  [21:15:34.492]             function(cond) {
  [21:15:34.492]                 if (inherits(cond, "error")) {
  [21:15:34.492]                   sessionInformation <- function() {
  [21:15:34.492]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.492]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.492]                       search = base::search(), system = base::Sys.info())
  [21:15:34.492]                   }
  [21:15:34.492]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.492]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.492]                     cond$call), session = sessionInformation(), 
  [21:15:34.492]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.492]                   signalCondition(cond)
  [21:15:34.492]                 }
  [21:15:34.492]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.492]                 ))) {
  [21:15:34.492]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.492]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.492]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.492]                   if (!signal) {
  [21:15:34.492]                     muffleCondition <- function (cond) 
  [21:15:34.492]                     {
  [21:15:34.492]                       inherits <- base::inherits
  [21:15:34.492]                       invokeRestart <- base::invokeRestart
  [21:15:34.492]                       muffled <- FALSE
  [21:15:34.492]                       if (inherits(cond, "message")) {
  [21:15:34.492]                         invokeRestart("muffleMessage")
  [21:15:34.492]                         muffled <- TRUE
  [21:15:34.492]                       }
  [21:15:34.492]                       else if (inherits(cond, "warning")) {
  [21:15:34.492]                         invokeRestart("muffleWarning")
  [21:15:34.492]                         muffled <- TRUE
  [21:15:34.492]                       }
  [21:15:34.492]                       else if (inherits(cond, "condition")) {
  [21:15:34.492]                         computeRestarts <- base::computeRestarts
  [21:15:34.492]                         grepl <- base::grepl
  [21:15:34.492]                         is.null <- base::is.null
  [21:15:34.492]                         restarts <- computeRestarts(cond)
  [21:15:34.492]                         for (restart in restarts) {
  [21:15:34.492]                           name <- restart$name
  [21:15:34.492]                           if (is.null(name)) 
  [21:15:34.492]                             next
  [21:15:34.492]                           if (!grepl("^muffle", name)) 
  [21:15:34.492]                             next
  [21:15:34.492]                           invokeRestart(restart)
  [21:15:34.492]                           muffled <- TRUE
  [21:15:34.492]                           break
  [21:15:34.492]                         }
  [21:15:34.492]                       }
  [21:15:34.492]                       invisible(muffled)
  [21:15:34.492]                     }
  [21:15:34.492]                     muffleCondition(cond)
  [21:15:34.492]                   }
  [21:15:34.492]                 }
  [21:15:34.492]             }
  [21:15:34.492]         }))
  [21:15:34.492]     }, error = function(ex) {
  [21:15:34.492]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.492]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.492]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.492]     }, finally = {
  [21:15:34.492]         {
  [21:15:34.492]             NULL
  [21:15:34.492]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.492]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.492]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.492]                 label = NULL, ...) 
  [21:15:34.492]             {
  [21:15:34.492]                 if (substitute) 
  [21:15:34.492]                   expr <- substitute(expr)
  [21:15:34.492]                 local <- as.logical(local)
  [21:15:34.492]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.492]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.492]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.492]                   label = label, ...)
  [21:15:34.492]                 if (!future$lazy) 
  [21:15:34.492]                   future <- run(future)
  [21:15:34.492]                 invisible(future)
  [21:15:34.492]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.492]         }
  [21:15:34.492]         base::options(...future.oldOptions)
  [21:15:34.492]     })
  [21:15:34.492]     Sys.time
  [21:15:34.492]     if (base::is.na(TRUE)) {
  [21:15:34.492]     }
  [21:15:34.492]     else {
  [21:15:34.492]         base::sink(type = "output", split = FALSE)
  [21:15:34.492]         if (TRUE) {
  [21:15:34.492]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.492]         }
  [21:15:34.492]         else {
  [21:15:34.492]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.492]         }
  [21:15:34.492]         base::close(...future.stdout)
  [21:15:34.492]         ...future.stdout <- NULL
  [21:15:34.492]     }
  [21:15:34.492]     ...future.result$conditions <- ...future.conditions
  [21:15:34.492]     ...future.result
  [21:15:34.492] }
  [21:15:34.496] plan(): Setting new future strategy stack:
  [21:15:34.497] List of future strategies:
  [21:15:34.497] 1. sequential:
  [21:15:34.497]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.497]    - tweaked: FALSE
  [21:15:34.497]    - call: NULL
  [21:15:34.498] plan(): nbrOfWorkers() = 1
  [21:15:34.515] plan(): Setting new future strategy stack:
  [21:15:34.515] List of future strategies:
  [21:15:34.515] 1. sequential:
  [21:15:34.515]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.515]    - tweaked: FALSE
  [21:15:34.515]    - call: plan(strategy)
  [21:15:34.516] plan(): nbrOfWorkers() = 1
  [21:15:34.517] SequentialFuture started (and completed)
  [21:15:34.518] getGlobalsAndPackages() ...
  [21:15:34.518] Searching for globals...
  [21:15:34.520] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.520] Searching for globals ... DONE
  [21:15:34.521] Resolving globals: FALSE
  [21:15:34.522] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.522] - globals: [1] 'x'
  [21:15:34.522] 
  [21:15:34.523] getGlobalsAndPackages() ... DONE
  [21:15:34.524] Packages needed by the future expression (n = 0): <none>
  [21:15:34.525] Packages needed by future strategies (n = 0): <none>
  [21:15:34.529] {
  [21:15:34.529]     {
  [21:15:34.529]         ...future.startTime <- base::Sys.time()
  [21:15:34.529]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.529]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.529]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.529]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.529]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.529]         {
  [21:15:34.529]             {
  [21:15:34.529]                 base::local({
  [21:15:34.529]                   has_future <- base::requireNamespace("future", 
  [21:15:34.529]                     quietly = TRUE)
  [21:15:34.529]                   version <- if (has_future) 
  [21:15:34.529]                     utils::packageVersion("future")
  [21:15:34.529]                   else NULL
  [21:15:34.529]                   if (!has_future || version < "1.8.0") {
  [21:15:34.529]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.529]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.529]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.529]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.529]                         "release", "version")], collapse = " "), 
  [21:15:34.529]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.529]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.529]                       info)
  [21:15:34.529]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.529]                     if (!has_future) {
  [21:15:34.529]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.529]                         info)
  [21:15:34.529]                     }
  [21:15:34.529]                     else {
  [21:15:34.529]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.529]                         info, version)
  [21:15:34.529]                     }
  [21:15:34.529]                     base::stop(msg)
  [21:15:34.529]                   }
  [21:15:34.529]                 })
  [21:15:34.529]             }
  [21:15:34.529]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.529]         }
  [21:15:34.529]     }
  [21:15:34.529]     if (base::is.na(TRUE)) {
  [21:15:34.529]     }
  [21:15:34.529]     else {
  [21:15:34.529]         if (TRUE) {
  [21:15:34.529]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.529]                 open = "w")
  [21:15:34.529]         }
  [21:15:34.529]         else {
  [21:15:34.529]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.529]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.529]         }
  [21:15:34.529]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.529]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.529]             base::sink(type = "output", split = FALSE)
  [21:15:34.529]             base::close(...future.stdout)
  [21:15:34.529]         }, add = TRUE)
  [21:15:34.529]     }
  [21:15:34.529]     ...future.frame <- base::sys.nframe()
  [21:15:34.529]     ...future.conditions <- base::list()
  [21:15:34.529]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.529]     ...future.result <- base::tryCatch({
  [21:15:34.529]         base::withCallingHandlers({
  [21:15:34.529]             ...future.value <- base::withVisible(base::local({
  [21:15:34.529]                 sample(x, size = 1L)
  [21:15:34.529]             }))
  [21:15:34.529]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.529]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.529]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.529]                 version = "1.8")
  [21:15:34.529]         }, condition = base::local({
  [21:15:34.529]             c <- base::c
  [21:15:34.529]             inherits <- base::inherits
  [21:15:34.529]             invokeRestart <- base::invokeRestart
  [21:15:34.529]             length <- base::length
  [21:15:34.529]             list <- base::list
  [21:15:34.529]             seq.int <- base::seq.int
  [21:15:34.529]             signalCondition <- base::signalCondition
  [21:15:34.529]             sys.calls <- base::sys.calls
  [21:15:34.529]             Sys.time <- base::Sys.time
  [21:15:34.529]             `[[` <- base::`[[`
  [21:15:34.529]             `+` <- base::`+`
  [21:15:34.529]             `<<-` <- base::`<<-`
  [21:15:34.529]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.529]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.529]                   3L)]
  [21:15:34.529]             }
  [21:15:34.529]             function(cond) {
  [21:15:34.529]                 if (inherits(cond, "error")) {
  [21:15:34.529]                   sessionInformation <- function() {
  [21:15:34.529]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.529]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.529]                       search = base::search(), system = base::Sys.info())
  [21:15:34.529]                   }
  [21:15:34.529]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.529]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.529]                     cond$call), session = sessionInformation(), 
  [21:15:34.529]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.529]                   signalCondition(cond)
  [21:15:34.529]                 }
  [21:15:34.529]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.529]                 ))) {
  [21:15:34.529]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.529]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.529]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.529]                   if (!signal) {
  [21:15:34.529]                     muffleCondition <- function (cond) 
  [21:15:34.529]                     {
  [21:15:34.529]                       inherits <- base::inherits
  [21:15:34.529]                       invokeRestart <- base::invokeRestart
  [21:15:34.529]                       muffled <- FALSE
  [21:15:34.529]                       if (inherits(cond, "message")) {
  [21:15:34.529]                         invokeRestart("muffleMessage")
  [21:15:34.529]                         muffled <- TRUE
  [21:15:34.529]                       }
  [21:15:34.529]                       else if (inherits(cond, "warning")) {
  [21:15:34.529]                         invokeRestart("muffleWarning")
  [21:15:34.529]                         muffled <- TRUE
  [21:15:34.529]                       }
  [21:15:34.529]                       else if (inherits(cond, "condition")) {
  [21:15:34.529]                         computeRestarts <- base::computeRestarts
  [21:15:34.529]                         grepl <- base::grepl
  [21:15:34.529]                         is.null <- base::is.null
  [21:15:34.529]                         restarts <- computeRestarts(cond)
  [21:15:34.529]                         for (restart in restarts) {
  [21:15:34.529]                           name <- restart$name
  [21:15:34.529]                           if (is.null(name)) 
  [21:15:34.529]                             next
  [21:15:34.529]                           if (!grepl("^muffle", name)) 
  [21:15:34.529]                             next
  [21:15:34.529]                           invokeRestart(restart)
  [21:15:34.529]                           muffled <- TRUE
  [21:15:34.529]                           break
  [21:15:34.529]                         }
  [21:15:34.529]                       }
  [21:15:34.529]                       invisible(muffled)
  [21:15:34.529]                     }
  [21:15:34.529]                     muffleCondition(cond)
  [21:15:34.529]                   }
  [21:15:34.529]                 }
  [21:15:34.529]             }
  [21:15:34.529]         }))
  [21:15:34.529]     }, error = function(ex) {
  [21:15:34.529]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.529]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.529]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.529]     }, finally = {
  [21:15:34.529]         {
  [21:15:34.529]             NULL
  [21:15:34.529]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.529]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.529]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.529]                 label = NULL, ...) 
  [21:15:34.529]             {
  [21:15:34.529]                 if (substitute) 
  [21:15:34.529]                   expr <- substitute(expr)
  [21:15:34.529]                 local <- as.logical(local)
  [21:15:34.529]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.529]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.529]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.529]                   label = label, ...)
  [21:15:34.529]                 if (!future$lazy) 
  [21:15:34.529]                   future <- run(future)
  [21:15:34.529]                 invisible(future)
  [21:15:34.529]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.529]         }
  [21:15:34.529]         base::options(...future.oldOptions)
  [21:15:34.529]     })
  [21:15:34.529]     Sys.time
  [21:15:34.529]     if (base::is.na(TRUE)) {
  [21:15:34.529]     }
  [21:15:34.529]     else {
  [21:15:34.529]         base::sink(type = "output", split = FALSE)
  [21:15:34.529]         if (TRUE) {
  [21:15:34.529]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.529]         }
  [21:15:34.529]         else {
  [21:15:34.529]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.529]         }
  [21:15:34.529]         base::close(...future.stdout)
  [21:15:34.529]         ...future.stdout <- NULL
  [21:15:34.529]     }
  [21:15:34.529]     ...future.result$conditions <- ...future.conditions
  [21:15:34.529]     ...future.result
  [21:15:34.529] }
  [21:15:34.550] plan(): Setting new future strategy stack:
  [21:15:34.550] List of future strategies:
  [21:15:34.550] 1. sequential:
  [21:15:34.550]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.550]    - tweaked: FALSE
  [21:15:34.550]    - call: NULL
  [21:15:34.551] plan(): nbrOfWorkers() = 1
  [21:15:34.608] plan(): Setting new future strategy stack:
  [21:15:34.608] List of future strategies:
  [21:15:34.608] 1. sequential:
  [21:15:34.608]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.608]    - tweaked: FALSE
  [21:15:34.608]    - call: plan(strategy)
  [21:15:34.609] plan(): nbrOfWorkers() = 1
  [21:15:34.610] SequentialFuture started (and completed)
  [21:15:34.611] getGlobalsAndPackages() ...
  [21:15:34.612] Searching for globals...
  [21:15:34.614] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.614] Searching for globals ... DONE
  [21:15:34.615] Resolving globals: FALSE
  [21:15:34.616] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.616] - globals: [1] 'x'
  [21:15:34.616] 
  [21:15:34.617] getGlobalsAndPackages() ... DONE
  [21:15:34.618] Packages needed by the future expression (n = 0): <none>
  [21:15:34.619] Packages needed by future strategies (n = 0): <none>
  [21:15:34.623] {
  [21:15:34.623]     {
  [21:15:34.623]         ...future.startTime <- base::Sys.time()
  [21:15:34.623]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.623]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.623]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.623]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.623]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.623]         {
  [21:15:34.623]             {
  [21:15:34.623]                 base::local({
  [21:15:34.623]                   has_future <- base::requireNamespace("future", 
  [21:15:34.623]                     quietly = TRUE)
  [21:15:34.623]                   version <- if (has_future) 
  [21:15:34.623]                     utils::packageVersion("future")
  [21:15:34.623]                   else NULL
  [21:15:34.623]                   if (!has_future || version < "1.8.0") {
  [21:15:34.623]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.623]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.623]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.623]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.623]                         "release", "version")], collapse = " "), 
  [21:15:34.623]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.623]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.623]                       info)
  [21:15:34.623]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.623]                     if (!has_future) {
  [21:15:34.623]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.623]                         info)
  [21:15:34.623]                     }
  [21:15:34.623]                     else {
  [21:15:34.623]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.623]                         info, version)
  [21:15:34.623]                     }
  [21:15:34.623]                     base::stop(msg)
  [21:15:34.623]                   }
  [21:15:34.623]                 })
  [21:15:34.623]             }
  [21:15:34.623]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.623]         }
  [21:15:34.623]     }
  [21:15:34.623]     if (base::is.na(TRUE)) {
  [21:15:34.623]     }
  [21:15:34.623]     else {
  [21:15:34.623]         if (TRUE) {
  [21:15:34.623]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.623]                 open = "w")
  [21:15:34.623]         }
  [21:15:34.623]         else {
  [21:15:34.623]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.623]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.623]         }
  [21:15:34.623]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.623]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.623]             base::sink(type = "output", split = FALSE)
  [21:15:34.623]             base::close(...future.stdout)
  [21:15:34.623]         }, add = TRUE)
  [21:15:34.623]     }
  [21:15:34.623]     ...future.frame <- base::sys.nframe()
  [21:15:34.623]     ...future.conditions <- base::list()
  [21:15:34.623]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.623]     ...future.result <- base::tryCatch({
  [21:15:34.623]         base::withCallingHandlers({
  [21:15:34.623]             ...future.value <- base::withVisible(base::local({
  [21:15:34.623]                 sample(x, size = 1L)
  [21:15:34.623]             }))
  [21:15:34.623]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.623]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.623]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.623]                 version = "1.8")
  [21:15:34.623]         }, condition = base::local({
  [21:15:34.623]             c <- base::c
  [21:15:34.623]             inherits <- base::inherits
  [21:15:34.623]             invokeRestart <- base::invokeRestart
  [21:15:34.623]             length <- base::length
  [21:15:34.623]             list <- base::list
  [21:15:34.623]             seq.int <- base::seq.int
  [21:15:34.623]             signalCondition <- base::signalCondition
  [21:15:34.623]             sys.calls <- base::sys.calls
  [21:15:34.623]             Sys.time <- base::Sys.time
  [21:15:34.623]             `[[` <- base::`[[`
  [21:15:34.623]             `+` <- base::`+`
  [21:15:34.623]             `<<-` <- base::`<<-`
  [21:15:34.623]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.623]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.623]                   3L)]
  [21:15:34.623]             }
  [21:15:34.623]             function(cond) {
  [21:15:34.623]                 if (inherits(cond, "error")) {
  [21:15:34.623]                   sessionInformation <- function() {
  [21:15:34.623]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.623]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.623]                       search = base::search(), system = base::Sys.info())
  [21:15:34.623]                   }
  [21:15:34.623]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.623]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.623]                     cond$call), session = sessionInformation(), 
  [21:15:34.623]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.623]                   signalCondition(cond)
  [21:15:34.623]                 }
  [21:15:34.623]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.623]                 ))) {
  [21:15:34.623]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.623]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.623]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.623]                   if (!signal) {
  [21:15:34.623]                     muffleCondition <- function (cond) 
  [21:15:34.623]                     {
  [21:15:34.623]                       inherits <- base::inherits
  [21:15:34.623]                       invokeRestart <- base::invokeRestart
  [21:15:34.623]                       muffled <- FALSE
  [21:15:34.623]                       if (inherits(cond, "message")) {
  [21:15:34.623]                         invokeRestart("muffleMessage")
  [21:15:34.623]                         muffled <- TRUE
  [21:15:34.623]                       }
  [21:15:34.623]                       else if (inherits(cond, "warning")) {
  [21:15:34.623]                         invokeRestart("muffleWarning")
  [21:15:34.623]                         muffled <- TRUE
  [21:15:34.623]                       }
  [21:15:34.623]                       else if (inherits(cond, "condition")) {
  [21:15:34.623]                         computeRestarts <- base::computeRestarts
  [21:15:34.623]                         grepl <- base::grepl
  [21:15:34.623]                         is.null <- base::is.null
  [21:15:34.623]                         restarts <- computeRestarts(cond)
  [21:15:34.623]                         for (restart in restarts) {
  [21:15:34.623]                           name <- restart$name
  [21:15:34.623]                           if (is.null(name)) 
  [21:15:34.623]                             next
  [21:15:34.623]                           if (!grepl("^muffle", name)) 
  [21:15:34.623]                             next
  [21:15:34.623]                           invokeRestart(restart)
  [21:15:34.623]                           muffled <- TRUE
  [21:15:34.623]                           break
  [21:15:34.623]                         }
  [21:15:34.623]                       }
  [21:15:34.623]                       invisible(muffled)
  [21:15:34.623]                     }
  [21:15:34.623]                     muffleCondition(cond)
  [21:15:34.623]                   }
  [21:15:34.623]                 }
  [21:15:34.623]             }
  [21:15:34.623]         }))
  [21:15:34.623]     }, error = function(ex) {
  [21:15:34.623]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.623]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.623]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.623]     }, finally = {
  [21:15:34.623]         {
  [21:15:34.623]             NULL
  [21:15:34.623]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.623]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.623]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.623]                 label = NULL, ...) 
  [21:15:34.623]             {
  [21:15:34.623]                 if (substitute) 
  [21:15:34.623]                   expr <- substitute(expr)
  [21:15:34.623]                 local <- as.logical(local)
  [21:15:34.623]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.623]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.623]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.623]                   label = label, ...)
  [21:15:34.623]                 if (!future$lazy) 
  [21:15:34.623]                   future <- run(future)
  [21:15:34.623]                 invisible(future)
  [21:15:34.623]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.623]         }
  [21:15:34.623]         base::options(...future.oldOptions)
  [21:15:34.623]     })
  [21:15:34.623]     Sys.time
  [21:15:34.623]     if (base::is.na(TRUE)) {
  [21:15:34.623]     }
  [21:15:34.623]     else {
  [21:15:34.623]         base::sink(type = "output", split = FALSE)
  [21:15:34.623]         if (TRUE) {
  [21:15:34.623]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.623]         }
  [21:15:34.623]         else {
  [21:15:34.623]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.623]         }
  [21:15:34.623]         base::close(...future.stdout)
  [21:15:34.623]         ...future.stdout <- NULL
  [21:15:34.623]     }
  [21:15:34.623]     ...future.result$conditions <- ...future.conditions
  [21:15:34.623]     ...future.result
  [21:15:34.623] }
  [21:15:34.628] plan(): Setting new future strategy stack:
  [21:15:34.628] List of future strategies:
  [21:15:34.628] 1. sequential:
  [21:15:34.628]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.628]    - tweaked: FALSE
  [21:15:34.628]    - call: NULL
  [21:15:34.629] plan(): nbrOfWorkers() = 1
  [21:15:34.630] plan(): Setting new future strategy stack:
  [21:15:34.630] List of future strategies:
  [21:15:34.630] 1. sequential:
  [21:15:34.630]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.630]    - tweaked: FALSE
  [21:15:34.630]    - call: plan(strategy)
  [21:15:34.631] plan(): nbrOfWorkers() = 1
  [21:15:34.632] SequentialFuture started (and completed)
  [21:15:34.633] getGlobalsAndPackages() ...
  [21:15:34.633] Searching for globals...
  [21:15:34.635] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.636] Searching for globals ... DONE
  [21:15:34.636] Resolving globals: FALSE
  [21:15:34.637] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.637] - globals: [1] 'x'
  [21:15:34.638] 
  [21:15:34.638] getGlobalsAndPackages() ... DONE
  [21:15:34.640] Packages needed by the future expression (n = 0): <none>
  [21:15:34.640] Packages needed by future strategies (n = 0): <none>
  [21:15:34.645] {
  [21:15:34.645]     {
  [21:15:34.645]         ...future.startTime <- base::Sys.time()
  [21:15:34.645]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.645]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.645]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.645]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.645]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.645]         {
  [21:15:34.645]             {
  [21:15:34.645]                 base::local({
  [21:15:34.645]                   has_future <- base::requireNamespace("future", 
  [21:15:34.645]                     quietly = TRUE)
  [21:15:34.645]                   version <- if (has_future) 
  [21:15:34.645]                     utils::packageVersion("future")
  [21:15:34.645]                   else NULL
  [21:15:34.645]                   if (!has_future || version < "1.8.0") {
  [21:15:34.645]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.645]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.645]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.645]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.645]                         "release", "version")], collapse = " "), 
  [21:15:34.645]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.645]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.645]                       info)
  [21:15:34.645]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.645]                     if (!has_future) {
  [21:15:34.645]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.645]                         info)
  [21:15:34.645]                     }
  [21:15:34.645]                     else {
  [21:15:34.645]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.645]                         info, version)
  [21:15:34.645]                     }
  [21:15:34.645]                     base::stop(msg)
  [21:15:34.645]                   }
  [21:15:34.645]                 })
  [21:15:34.645]             }
  [21:15:34.645]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.645]         }
  [21:15:34.645]     }
  [21:15:34.645]     if (base::is.na(TRUE)) {
  [21:15:34.645]     }
  [21:15:34.645]     else {
  [21:15:34.645]         if (TRUE) {
  [21:15:34.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.645]                 open = "w")
  [21:15:34.645]         }
  [21:15:34.645]         else {
  [21:15:34.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.645]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.645]         }
  [21:15:34.645]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.645]             base::sink(type = "output", split = FALSE)
  [21:15:34.645]             base::close(...future.stdout)
  [21:15:34.645]         }, add = TRUE)
  [21:15:34.645]     }
  [21:15:34.645]     ...future.frame <- base::sys.nframe()
  [21:15:34.645]     ...future.conditions <- base::list()
  [21:15:34.645]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.645]     ...future.result <- base::tryCatch({
  [21:15:34.645]         base::withCallingHandlers({
  [21:15:34.645]             ...future.value <- base::withVisible(base::local({
  [21:15:34.645]                 sample(x, size = 1L)
  [21:15:34.645]             }))
  [21:15:34.645]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.645]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.645]                 version = "1.8")
  [21:15:34.645]         }, condition = base::local({
  [21:15:34.645]             c <- base::c
  [21:15:34.645]             inherits <- base::inherits
  [21:15:34.645]             invokeRestart <- base::invokeRestart
  [21:15:34.645]             length <- base::length
  [21:15:34.645]             list <- base::list
  [21:15:34.645]             seq.int <- base::seq.int
  [21:15:34.645]             signalCondition <- base::signalCondition
  [21:15:34.645]             sys.calls <- base::sys.calls
  [21:15:34.645]             Sys.time <- base::Sys.time
  [21:15:34.645]             `[[` <- base::`[[`
  [21:15:34.645]             `+` <- base::`+`
  [21:15:34.645]             `<<-` <- base::`<<-`
  [21:15:34.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.645]                   3L)]
  [21:15:34.645]             }
  [21:15:34.645]             function(cond) {
  [21:15:34.645]                 if (inherits(cond, "error")) {
  [21:15:34.645]                   sessionInformation <- function() {
  [21:15:34.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.645]                       search = base::search(), system = base::Sys.info())
  [21:15:34.645]                   }
  [21:15:34.645]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.645]                     cond$call), session = sessionInformation(), 
  [21:15:34.645]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.645]                   signalCondition(cond)
  [21:15:34.645]                 }
  [21:15:34.645]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.645]                 ))) {
  [21:15:34.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.645]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.645]                   if (!signal) {
  [21:15:34.645]                     muffleCondition <- function (cond) 
  [21:15:34.645]                     {
  [21:15:34.645]                       inherits <- base::inherits
  [21:15:34.645]                       invokeRestart <- base::invokeRestart
  [21:15:34.645]                       muffled <- FALSE
  [21:15:34.645]                       if (inherits(cond, "message")) {
  [21:15:34.645]                         invokeRestart("muffleMessage")
  [21:15:34.645]                         muffled <- TRUE
  [21:15:34.645]                       }
  [21:15:34.645]                       else if (inherits(cond, "warning")) {
  [21:15:34.645]                         invokeRestart("muffleWarning")
  [21:15:34.645]                         muffled <- TRUE
  [21:15:34.645]                       }
  [21:15:34.645]                       else if (inherits(cond, "condition")) {
  [21:15:34.645]                         computeRestarts <- base::computeRestarts
  [21:15:34.645]                         grepl <- base::grepl
  [21:15:34.645]                         is.null <- base::is.null
  [21:15:34.645]                         restarts <- computeRestarts(cond)
  [21:15:34.645]                         for (restart in restarts) {
  [21:15:34.645]                           name <- restart$name
  [21:15:34.645]                           if (is.null(name)) 
  [21:15:34.645]                             next
  [21:15:34.645]                           if (!grepl("^muffle", name)) 
  [21:15:34.645]                             next
  [21:15:34.645]                           invokeRestart(restart)
  [21:15:34.645]                           muffled <- TRUE
  [21:15:34.645]                           break
  [21:15:34.645]                         }
  [21:15:34.645]                       }
  [21:15:34.645]                       invisible(muffled)
  [21:15:34.645]                     }
  [21:15:34.645]                     muffleCondition(cond)
  [21:15:34.645]                   }
  [21:15:34.645]                 }
  [21:15:34.645]             }
  [21:15:34.645]         }))
  [21:15:34.645]     }, error = function(ex) {
  [21:15:34.645]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.645]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.645]     }, finally = {
  [21:15:34.645]         {
  [21:15:34.645]             NULL
  [21:15:34.645]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.645]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.645]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.645]                 label = NULL, ...) 
  [21:15:34.645]             {
  [21:15:34.645]                 if (substitute) 
  [21:15:34.645]                   expr <- substitute(expr)
  [21:15:34.645]                 local <- as.logical(local)
  [21:15:34.645]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.645]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.645]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.645]                   label = label, ...)
  [21:15:34.645]                 if (!future$lazy) 
  [21:15:34.645]                   future <- run(future)
  [21:15:34.645]                 invisible(future)
  [21:15:34.645]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.645]         }
  [21:15:34.645]         base::options(...future.oldOptions)
  [21:15:34.645]     })
  [21:15:34.645]     Sys.time
  [21:15:34.645]     if (base::is.na(TRUE)) {
  [21:15:34.645]     }
  [21:15:34.645]     else {
  [21:15:34.645]         base::sink(type = "output", split = FALSE)
  [21:15:34.645]         if (TRUE) {
  [21:15:34.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.645]         }
  [21:15:34.645]         else {
  [21:15:34.645]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.645]         }
  [21:15:34.645]         base::close(...future.stdout)
  [21:15:34.645]         ...future.stdout <- NULL
  [21:15:34.645]     }
  [21:15:34.645]     ...future.result$conditions <- ...future.conditions
  [21:15:34.645]     ...future.result
  [21:15:34.645] }
  [21:15:34.650] plan(): Setting new future strategy stack:
  [21:15:34.650] List of future strategies:
  [21:15:34.650] 1. sequential:
  [21:15:34.650]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.650]    - tweaked: FALSE
  [21:15:34.650]    - call: NULL
  [21:15:34.651] plan(): nbrOfWorkers() = 1
  [21:15:34.652] plan(): Setting new future strategy stack:
  [21:15:34.652] List of future strategies:
  [21:15:34.652] 1. sequential:
  [21:15:34.652]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.652]    - tweaked: FALSE
  [21:15:34.652]    - call: plan(strategy)
  [21:15:34.653] plan(): nbrOfWorkers() = 1
  [21:15:34.654] SequentialFuture started (and completed)
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 2
  
  [21:15:34.657] getGlobalsAndPackages() ...
  [21:15:34.657] Searching for globals...
  [21:15:34.659] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.659] Searching for globals ... DONE
  [21:15:34.660] Resolving globals: FALSE
  [21:15:34.661] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.661] - globals: [1] 'x'
  [21:15:34.661] 
  [21:15:34.662] getGlobalsAndPackages() ... DONE
  [21:15:34.663] Packages needed by the future expression (n = 0): <none>
  [21:15:34.664] Packages needed by future strategies (n = 0): <none>
  [21:15:34.668] {
  [21:15:34.668]     {
  [21:15:34.668]         ...future.startTime <- base::Sys.time()
  [21:15:34.668]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.668]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.668]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.668]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.668]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.668]         {
  [21:15:34.668]             {
  [21:15:34.668]                 base::local({
  [21:15:34.668]                   has_future <- base::requireNamespace("future", 
  [21:15:34.668]                     quietly = TRUE)
  [21:15:34.668]                   version <- if (has_future) 
  [21:15:34.668]                     utils::packageVersion("future")
  [21:15:34.668]                   else NULL
  [21:15:34.668]                   if (!has_future || version < "1.8.0") {
  [21:15:34.668]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.668]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.668]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.668]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.668]                         "release", "version")], collapse = " "), 
  [21:15:34.668]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.668]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.668]                       info)
  [21:15:34.668]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.668]                     if (!has_future) {
  [21:15:34.668]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.668]                         info)
  [21:15:34.668]                     }
  [21:15:34.668]                     else {
  [21:15:34.668]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.668]                         info, version)
  [21:15:34.668]                     }
  [21:15:34.668]                     base::stop(msg)
  [21:15:34.668]                   }
  [21:15:34.668]                 })
  [21:15:34.668]             }
  [21:15:34.668]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.668]         }
  [21:15:34.668]     }
  [21:15:34.668]     if (base::is.na(TRUE)) {
  [21:15:34.668]     }
  [21:15:34.668]     else {
  [21:15:34.668]         if (TRUE) {
  [21:15:34.668]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.668]                 open = "w")
  [21:15:34.668]         }
  [21:15:34.668]         else {
  [21:15:34.668]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.668]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.668]         }
  [21:15:34.668]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.668]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.668]             base::sink(type = "output", split = FALSE)
  [21:15:34.668]             base::close(...future.stdout)
  [21:15:34.668]         }, add = TRUE)
  [21:15:34.668]     }
  [21:15:34.668]     ...future.frame <- base::sys.nframe()
  [21:15:34.668]     ...future.conditions <- base::list()
  [21:15:34.668]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.668]     ...future.result <- base::tryCatch({
  [21:15:34.668]         base::withCallingHandlers({
  [21:15:34.668]             ...future.value <- base::withVisible(base::local({
  [21:15:34.668]                 sample(x, size = 1L)
  [21:15:34.668]             }))
  [21:15:34.668]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.668]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.668]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.668]                 version = "1.8")
  [21:15:34.668]         }, condition = base::local({
  [21:15:34.668]             c <- base::c
  [21:15:34.668]             inherits <- base::inherits
  [21:15:34.668]             invokeRestart <- base::invokeRestart
  [21:15:34.668]             length <- base::length
  [21:15:34.668]             list <- base::list
  [21:15:34.668]             seq.int <- base::seq.int
  [21:15:34.668]             signalCondition <- base::signalCondition
  [21:15:34.668]             sys.calls <- base::sys.calls
  [21:15:34.668]             Sys.time <- base::Sys.time
  [21:15:34.668]             `[[` <- base::`[[`
  [21:15:34.668]             `+` <- base::`+`
  [21:15:34.668]             `<<-` <- base::`<<-`
  [21:15:34.668]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.668]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.668]                   3L)]
  [21:15:34.668]             }
  [21:15:34.668]             function(cond) {
  [21:15:34.668]                 if (inherits(cond, "error")) {
  [21:15:34.668]                   sessionInformation <- function() {
  [21:15:34.668]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.668]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.668]                       search = base::search(), system = base::Sys.info())
  [21:15:34.668]                   }
  [21:15:34.668]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.668]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.668]                     cond$call), session = sessionInformation(), 
  [21:15:34.668]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.668]                   signalCondition(cond)
  [21:15:34.668]                 }
  [21:15:34.668]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.668]                 ))) {
  [21:15:34.668]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.668]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.668]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.668]                   if (!signal) {
  [21:15:34.668]                     muffleCondition <- function (cond) 
  [21:15:34.668]                     {
  [21:15:34.668]                       inherits <- base::inherits
  [21:15:34.668]                       invokeRestart <- base::invokeRestart
  [21:15:34.668]                       muffled <- FALSE
  [21:15:34.668]                       if (inherits(cond, "message")) {
  [21:15:34.668]                         invokeRestart("muffleMessage")
  [21:15:34.668]                         muffled <- TRUE
  [21:15:34.668]                       }
  [21:15:34.668]                       else if (inherits(cond, "warning")) {
  [21:15:34.668]                         invokeRestart("muffleWarning")
  [21:15:34.668]                         muffled <- TRUE
  [21:15:34.668]                       }
  [21:15:34.668]                       else if (inherits(cond, "condition")) {
  [21:15:34.668]                         computeRestarts <- base::computeRestarts
  [21:15:34.668]                         grepl <- base::grepl
  [21:15:34.668]                         is.null <- base::is.null
  [21:15:34.668]                         restarts <- computeRestarts(cond)
  [21:15:34.668]                         for (restart in restarts) {
  [21:15:34.668]                           name <- restart$name
  [21:15:34.668]                           if (is.null(name)) 
  [21:15:34.668]                             next
  [21:15:34.668]                           if (!grepl("^muffle", name)) 
  [21:15:34.668]                             next
  [21:15:34.668]                           invokeRestart(restart)
  [21:15:34.668]                           muffled <- TRUE
  [21:15:34.668]                           break
  [21:15:34.668]                         }
  [21:15:34.668]                       }
  [21:15:34.668]                       invisible(muffled)
  [21:15:34.668]                     }
  [21:15:34.668]                     muffleCondition(cond)
  [21:15:34.668]                   }
  [21:15:34.668]                 }
  [21:15:34.668]             }
  [21:15:34.668]         }))
  [21:15:34.668]     }, error = function(ex) {
  [21:15:34.668]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.668]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.668]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.668]     }, finally = {
  [21:15:34.668]         {
  [21:15:34.668]             NULL
  [21:15:34.668]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.668]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.668]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.668]                 label = NULL, ...) 
  [21:15:34.668]             {
  [21:15:34.668]                 if (substitute) 
  [21:15:34.668]                   expr <- substitute(expr)
  [21:15:34.668]                 local <- as.logical(local)
  [21:15:34.668]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.668]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.668]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.668]                   label = label, ...)
  [21:15:34.668]                 if (!future$lazy) 
  [21:15:34.668]                   future <- run(future)
  [21:15:34.668]                 invisible(future)
  [21:15:34.668]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.668]         }
  [21:15:34.668]         base::options(...future.oldOptions)
  [21:15:34.668]     })
  [21:15:34.668]     Sys.time
  [21:15:34.668]     if (base::is.na(TRUE)) {
  [21:15:34.668]     }
  [21:15:34.668]     else {
  [21:15:34.668]         base::sink(type = "output", split = FALSE)
  [21:15:34.668]         if (TRUE) {
  [21:15:34.668]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.668]         }
  [21:15:34.668]         else {
  [21:15:34.668]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.668]         }
  [21:15:34.668]         base::close(...future.stdout)
  [21:15:34.668]         ...future.stdout <- NULL
  [21:15:34.668]     }
  [21:15:34.668]     ...future.result$conditions <- ...future.conditions
  [21:15:34.668]     ...future.result
  [21:15:34.668] }
  [21:15:34.672] plan(): Setting new future strategy stack:
  [21:15:34.673] List of future strategies:
  [21:15:34.673] 1. sequential:
  [21:15:34.673]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.673]    - tweaked: FALSE
  [21:15:34.673]    - call: NULL
  [21:15:34.674] plan(): nbrOfWorkers() = 1
  [21:15:34.675] plan(): Setting new future strategy stack:
  [21:15:34.675] List of future strategies:
  [21:15:34.675] 1. sequential:
  [21:15:34.675]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.675]    - tweaked: FALSE
  [21:15:34.675]    - call: plan(strategy)
  [21:15:34.676] plan(): nbrOfWorkers() = 1
  [21:15:34.677] SequentialFuture started (and completed)
  [21:15:34.678] getGlobalsAndPackages() ...
  [21:15:34.678] Searching for globals...
  [21:15:34.680] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.683] Searching for globals ... DONE
  [21:15:34.684] Resolving globals: FALSE
  [21:15:34.685] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.685] - globals: [1] 'x'
  [21:15:34.685] 
  [21:15:34.686] getGlobalsAndPackages() ... DONE
  [21:15:34.687] Packages needed by the future expression (n = 0): <none>
  [21:15:34.688] Packages needed by future strategies (n = 0): <none>
  [21:15:34.692] {
  [21:15:34.692]     {
  [21:15:34.692]         ...future.startTime <- base::Sys.time()
  [21:15:34.692]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.692]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.692]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.692]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.692]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.692]         {
  [21:15:34.692]             {
  [21:15:34.692]                 base::local({
  [21:15:34.692]                   has_future <- base::requireNamespace("future", 
  [21:15:34.692]                     quietly = TRUE)
  [21:15:34.692]                   version <- if (has_future) 
  [21:15:34.692]                     utils::packageVersion("future")
  [21:15:34.692]                   else NULL
  [21:15:34.692]                   if (!has_future || version < "1.8.0") {
  [21:15:34.692]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.692]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.692]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.692]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.692]                         "release", "version")], collapse = " "), 
  [21:15:34.692]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.692]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.692]                       info)
  [21:15:34.692]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.692]                     if (!has_future) {
  [21:15:34.692]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.692]                         info)
  [21:15:34.692]                     }
  [21:15:34.692]                     else {
  [21:15:34.692]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.692]                         info, version)
  [21:15:34.692]                     }
  [21:15:34.692]                     base::stop(msg)
  [21:15:34.692]                   }
  [21:15:34.692]                 })
  [21:15:34.692]             }
  [21:15:34.692]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.692]         }
  [21:15:34.692]     }
  [21:15:34.692]     if (base::is.na(TRUE)) {
  [21:15:34.692]     }
  [21:15:34.692]     else {
  [21:15:34.692]         if (TRUE) {
  [21:15:34.692]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.692]                 open = "w")
  [21:15:34.692]         }
  [21:15:34.692]         else {
  [21:15:34.692]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.692]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.692]         }
  [21:15:34.692]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.692]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.692]             base::sink(type = "output", split = FALSE)
  [21:15:34.692]             base::close(...future.stdout)
  [21:15:34.692]         }, add = TRUE)
  [21:15:34.692]     }
  [21:15:34.692]     ...future.frame <- base::sys.nframe()
  [21:15:34.692]     ...future.conditions <- base::list()
  [21:15:34.692]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.692]     ...future.result <- base::tryCatch({
  [21:15:34.692]         base::withCallingHandlers({
  [21:15:34.692]             ...future.value <- base::withVisible(base::local({
  [21:15:34.692]                 sample(x, size = 1L)
  [21:15:34.692]             }))
  [21:15:34.692]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.692]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.692]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.692]                 version = "1.8")
  [21:15:34.692]         }, condition = base::local({
  [21:15:34.692]             c <- base::c
  [21:15:34.692]             inherits <- base::inherits
  [21:15:34.692]             invokeRestart <- base::invokeRestart
  [21:15:34.692]             length <- base::length
  [21:15:34.692]             list <- base::list
  [21:15:34.692]             seq.int <- base::seq.int
  [21:15:34.692]             signalCondition <- base::signalCondition
  [21:15:34.692]             sys.calls <- base::sys.calls
  [21:15:34.692]             Sys.time <- base::Sys.time
  [21:15:34.692]             `[[` <- base::`[[`
  [21:15:34.692]             `+` <- base::`+`
  [21:15:34.692]             `<<-` <- base::`<<-`
  [21:15:34.692]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.692]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.692]                   3L)]
  [21:15:34.692]             }
  [21:15:34.692]             function(cond) {
  [21:15:34.692]                 if (inherits(cond, "error")) {
  [21:15:34.692]                   sessionInformation <- function() {
  [21:15:34.692]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.692]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.692]                       search = base::search(), system = base::Sys.info())
  [21:15:34.692]                   }
  [21:15:34.692]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.692]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.692]                     cond$call), session = sessionInformation(), 
  [21:15:34.692]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.692]                   signalCondition(cond)
  [21:15:34.692]                 }
  [21:15:34.692]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.692]                 ))) {
  [21:15:34.692]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.692]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.692]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.692]                   if (!signal) {
  [21:15:34.692]                     muffleCondition <- function (cond) 
  [21:15:34.692]                     {
  [21:15:34.692]                       inherits <- base::inherits
  [21:15:34.692]                       invokeRestart <- base::invokeRestart
  [21:15:34.692]                       muffled <- FALSE
  [21:15:34.692]                       if (inherits(cond, "message")) {
  [21:15:34.692]                         invokeRestart("muffleMessage")
  [21:15:34.692]                         muffled <- TRUE
  [21:15:34.692]                       }
  [21:15:34.692]                       else if (inherits(cond, "warning")) {
  [21:15:34.692]                         invokeRestart("muffleWarning")
  [21:15:34.692]                         muffled <- TRUE
  [21:15:34.692]                       }
  [21:15:34.692]                       else if (inherits(cond, "condition")) {
  [21:15:34.692]                         computeRestarts <- base::computeRestarts
  [21:15:34.692]                         grepl <- base::grepl
  [21:15:34.692]                         is.null <- base::is.null
  [21:15:34.692]                         restarts <- computeRestarts(cond)
  [21:15:34.692]                         for (restart in restarts) {
  [21:15:34.692]                           name <- restart$name
  [21:15:34.692]                           if (is.null(name)) 
  [21:15:34.692]                             next
  [21:15:34.692]                           if (!grepl("^muffle", name)) 
  [21:15:34.692]                             next
  [21:15:34.692]                           invokeRestart(restart)
  [21:15:34.692]                           muffled <- TRUE
  [21:15:34.692]                           break
  [21:15:34.692]                         }
  [21:15:34.692]                       }
  [21:15:34.692]                       invisible(muffled)
  [21:15:34.692]                     }
  [21:15:34.692]                     muffleCondition(cond)
  [21:15:34.692]                   }
  [21:15:34.692]                 }
  [21:15:34.692]             }
  [21:15:34.692]         }))
  [21:15:34.692]     }, error = function(ex) {
  [21:15:34.692]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.692]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.692]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.692]     }, finally = {
  [21:15:34.692]         {
  [21:15:34.692]             NULL
  [21:15:34.692]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.692]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.692]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.692]                 label = NULL, ...) 
  [21:15:34.692]             {
  [21:15:34.692]                 if (substitute) 
  [21:15:34.692]                   expr <- substitute(expr)
  [21:15:34.692]                 local <- as.logical(local)
  [21:15:34.692]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.692]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.692]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.692]                   label = label, ...)
  [21:15:34.692]                 if (!future$lazy) 
  [21:15:34.692]                   future <- run(future)
  [21:15:34.692]                 invisible(future)
  [21:15:34.692]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.692]         }
  [21:15:34.692]         base::options(...future.oldOptions)
  [21:15:34.692]     })
  [21:15:34.692]     Sys.time
  [21:15:34.692]     if (base::is.na(TRUE)) {
  [21:15:34.692]     }
  [21:15:34.692]     else {
  [21:15:34.692]         base::sink(type = "output", split = FALSE)
  [21:15:34.692]         if (TRUE) {
  [21:15:34.692]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.692]         }
  [21:15:34.692]         else {
  [21:15:34.692]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.692]         }
  [21:15:34.692]         base::close(...future.stdout)
  [21:15:34.692]         ...future.stdout <- NULL
  [21:15:34.692]     }
  [21:15:34.692]     ...future.result$conditions <- ...future.conditions
  [21:15:34.692]     ...future.result
  [21:15:34.692] }
  [21:15:34.697] plan(): Setting new future strategy stack:
  [21:15:34.697] List of future strategies:
  [21:15:34.697] 1. sequential:
  [21:15:34.697]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.697]    - tweaked: FALSE
  [21:15:34.697]    - call: NULL
  [21:15:34.698] plan(): nbrOfWorkers() = 1
  [21:15:34.699] plan(): Setting new future strategy stack:
  [21:15:34.700] List of future strategies:
  [21:15:34.700] 1. sequential:
  [21:15:34.700]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.700]    - tweaked: FALSE
  [21:15:34.700]    - call: plan(strategy)
  [21:15:34.701] plan(): nbrOfWorkers() = 1
  [21:15:34.701] SequentialFuture started (and completed)
  [21:15:34.702] getGlobalsAndPackages() ...
  [21:15:34.703] Searching for globals...
  [21:15:34.705] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.705] Searching for globals ... DONE
  [21:15:34.705] Resolving globals: FALSE
  [21:15:34.706] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.707] - globals: [1] 'x'
  [21:15:34.707] 
  [21:15:34.708] getGlobalsAndPackages() ... DONE
  [21:15:34.709] Packages needed by the future expression (n = 0): <none>
  [21:15:34.710] Packages needed by future strategies (n = 0): <none>
  [21:15:34.714] {
  [21:15:34.714]     {
  [21:15:34.714]         ...future.startTime <- base::Sys.time()
  [21:15:34.714]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.714]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.714]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.714]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.714]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.714]         {
  [21:15:34.714]             {
  [21:15:34.714]                 base::local({
  [21:15:34.714]                   has_future <- base::requireNamespace("future", 
  [21:15:34.714]                     quietly = TRUE)
  [21:15:34.714]                   version <- if (has_future) 
  [21:15:34.714]                     utils::packageVersion("future")
  [21:15:34.714]                   else NULL
  [21:15:34.714]                   if (!has_future || version < "1.8.0") {
  [21:15:34.714]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.714]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.714]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.714]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.714]                         "release", "version")], collapse = " "), 
  [21:15:34.714]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.714]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.714]                       info)
  [21:15:34.714]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.714]                     if (!has_future) {
  [21:15:34.714]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.714]                         info)
  [21:15:34.714]                     }
  [21:15:34.714]                     else {
  [21:15:34.714]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.714]                         info, version)
  [21:15:34.714]                     }
  [21:15:34.714]                     base::stop(msg)
  [21:15:34.714]                   }
  [21:15:34.714]                 })
  [21:15:34.714]             }
  [21:15:34.714]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.714]         }
  [21:15:34.714]     }
  [21:15:34.714]     if (base::is.na(TRUE)) {
  [21:15:34.714]     }
  [21:15:34.714]     else {
  [21:15:34.714]         if (TRUE) {
  [21:15:34.714]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.714]                 open = "w")
  [21:15:34.714]         }
  [21:15:34.714]         else {
  [21:15:34.714]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.714]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.714]         }
  [21:15:34.714]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.714]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.714]             base::sink(type = "output", split = FALSE)
  [21:15:34.714]             base::close(...future.stdout)
  [21:15:34.714]         }, add = TRUE)
  [21:15:34.714]     }
  [21:15:34.714]     ...future.frame <- base::sys.nframe()
  [21:15:34.714]     ...future.conditions <- base::list()
  [21:15:34.714]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.714]     ...future.result <- base::tryCatch({
  [21:15:34.714]         base::withCallingHandlers({
  [21:15:34.714]             ...future.value <- base::withVisible(base::local({
  [21:15:34.714]                 sample(x, size = 1L)
  [21:15:34.714]             }))
  [21:15:34.714]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.714]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.714]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.714]                 version = "1.8")
  [21:15:34.714]         }, condition = base::local({
  [21:15:34.714]             c <- base::c
  [21:15:34.714]             inherits <- base::inherits
  [21:15:34.714]             invokeRestart <- base::invokeRestart
  [21:15:34.714]             length <- base::length
  [21:15:34.714]             list <- base::list
  [21:15:34.714]             seq.int <- base::seq.int
  [21:15:34.714]             signalCondition <- base::signalCondition
  [21:15:34.714]             sys.calls <- base::sys.calls
  [21:15:34.714]             Sys.time <- base::Sys.time
  [21:15:34.714]             `[[` <- base::`[[`
  [21:15:34.714]             `+` <- base::`+`
  [21:15:34.714]             `<<-` <- base::`<<-`
  [21:15:34.714]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.714]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.714]                   3L)]
  [21:15:34.714]             }
  [21:15:34.714]             function(cond) {
  [21:15:34.714]                 if (inherits(cond, "error")) {
  [21:15:34.714]                   sessionInformation <- function() {
  [21:15:34.714]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.714]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.714]                       search = base::search(), system = base::Sys.info())
  [21:15:34.714]                   }
  [21:15:34.714]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.714]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.714]                     cond$call), session = sessionInformation(), 
  [21:15:34.714]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.714]                   signalCondition(cond)
  [21:15:34.714]                 }
  [21:15:34.714]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.714]                 ))) {
  [21:15:34.714]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.714]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.714]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.714]                   if (!signal) {
  [21:15:34.714]                     muffleCondition <- function (cond) 
  [21:15:34.714]                     {
  [21:15:34.714]                       inherits <- base::inherits
  [21:15:34.714]                       invokeRestart <- base::invokeRestart
  [21:15:34.714]                       muffled <- FALSE
  [21:15:34.714]                       if (inherits(cond, "message")) {
  [21:15:34.714]                         invokeRestart("muffleMessage")
  [21:15:34.714]                         muffled <- TRUE
  [21:15:34.714]                       }
  [21:15:34.714]                       else if (inherits(cond, "warning")) {
  [21:15:34.714]                         invokeRestart("muffleWarning")
  [21:15:34.714]                         muffled <- TRUE
  [21:15:34.714]                       }
  [21:15:34.714]                       else if (inherits(cond, "condition")) {
  [21:15:34.714]                         computeRestarts <- base::computeRestarts
  [21:15:34.714]                         grepl <- base::grepl
  [21:15:34.714]                         is.null <- base::is.null
  [21:15:34.714]                         restarts <- computeRestarts(cond)
  [21:15:34.714]                         for (restart in restarts) {
  [21:15:34.714]                           name <- restart$name
  [21:15:34.714]                           if (is.null(name)) 
  [21:15:34.714]                             next
  [21:15:34.714]                           if (!grepl("^muffle", name)) 
  [21:15:34.714]                             next
  [21:15:34.714]                           invokeRestart(restart)
  [21:15:34.714]                           muffled <- TRUE
  [21:15:34.714]                           break
  [21:15:34.714]                         }
  [21:15:34.714]                       }
  [21:15:34.714]                       invisible(muffled)
  [21:15:34.714]                     }
  [21:15:34.714]                     muffleCondition(cond)
  [21:15:34.714]                   }
  [21:15:34.714]                 }
  [21:15:34.714]             }
  [21:15:34.714]         }))
  [21:15:34.714]     }, error = function(ex) {
  [21:15:34.714]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.714]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.714]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.714]     }, finally = {
  [21:15:34.714]         {
  [21:15:34.714]             NULL
  [21:15:34.714]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.714]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.714]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.714]                 label = NULL, ...) 
  [21:15:34.714]             {
  [21:15:34.714]                 if (substitute) 
  [21:15:34.714]                   expr <- substitute(expr)
  [21:15:34.714]                 local <- as.logical(local)
  [21:15:34.714]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.714]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.714]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.714]                   label = label, ...)
  [21:15:34.714]                 if (!future$lazy) 
  [21:15:34.714]                   future <- run(future)
  [21:15:34.714]                 invisible(future)
  [21:15:34.714]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.714]         }
  [21:15:34.714]         base::options(...future.oldOptions)
  [21:15:34.714]     })
  [21:15:34.714]     Sys.time
  [21:15:34.714]     if (base::is.na(TRUE)) {
  [21:15:34.714]     }
  [21:15:34.714]     else {
  [21:15:34.714]         base::sink(type = "output", split = FALSE)
  [21:15:34.714]         if (TRUE) {
  [21:15:34.714]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.714]         }
  [21:15:34.714]         else {
  [21:15:34.714]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.714]         }
  [21:15:34.714]         base::close(...future.stdout)
  [21:15:34.714]         ...future.stdout <- NULL
  [21:15:34.714]     }
  [21:15:34.714]     ...future.result$conditions <- ...future.conditions
  [21:15:34.714]     ...future.result
  [21:15:34.714] }
  [21:15:34.718] plan(): Setting new future strategy stack:
  [21:15:34.718] List of future strategies:
  [21:15:34.718] 1. sequential:
  [21:15:34.718]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.718]    - tweaked: FALSE
  [21:15:34.718]    - call: NULL
  [21:15:34.719] plan(): nbrOfWorkers() = 1
  [21:15:34.720] plan(): Setting new future strategy stack:
  [21:15:34.721] List of future strategies:
  [21:15:34.721] 1. sequential:
  [21:15:34.721]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.721]    - tweaked: FALSE
  [21:15:34.721]    - call: plan(strategy)
  [21:15:34.722] plan(): nbrOfWorkers() = 1
  [21:15:34.722] SequentialFuture started (and completed)
  [21:15:34.723] getGlobalsAndPackages() ...
  [21:15:34.724] Searching for globals...
  [21:15:34.726] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.726] Searching for globals ... DONE
  [21:15:34.726] Resolving globals: FALSE
  [21:15:34.727] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.727] - globals: [1] 'x'
  [21:15:34.728] 
  [21:15:34.728] getGlobalsAndPackages() ... DONE
  [21:15:34.730] Packages needed by the future expression (n = 0): <none>
  [21:15:34.730] Packages needed by future strategies (n = 0): <none>
  [21:15:34.734] {
  [21:15:34.734]     {
  [21:15:34.734]         ...future.startTime <- base::Sys.time()
  [21:15:34.734]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.734]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.734]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.734]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.734]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.734]         {
  [21:15:34.734]             {
  [21:15:34.734]                 base::local({
  [21:15:34.734]                   has_future <- base::requireNamespace("future", 
  [21:15:34.734]                     quietly = TRUE)
  [21:15:34.734]                   version <- if (has_future) 
  [21:15:34.734]                     utils::packageVersion("future")
  [21:15:34.734]                   else NULL
  [21:15:34.734]                   if (!has_future || version < "1.8.0") {
  [21:15:34.734]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.734]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.734]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.734]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.734]                         "release", "version")], collapse = " "), 
  [21:15:34.734]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.734]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.734]                       info)
  [21:15:34.734]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.734]                     if (!has_future) {
  [21:15:34.734]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.734]                         info)
  [21:15:34.734]                     }
  [21:15:34.734]                     else {
  [21:15:34.734]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.734]                         info, version)
  [21:15:34.734]                     }
  [21:15:34.734]                     base::stop(msg)
  [21:15:34.734]                   }
  [21:15:34.734]                 })
  [21:15:34.734]             }
  [21:15:34.734]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.734]         }
  [21:15:34.734]     }
  [21:15:34.734]     if (base::is.na(TRUE)) {
  [21:15:34.734]     }
  [21:15:34.734]     else {
  [21:15:34.734]         if (TRUE) {
  [21:15:34.734]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.734]                 open = "w")
  [21:15:34.734]         }
  [21:15:34.734]         else {
  [21:15:34.734]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.734]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.734]         }
  [21:15:34.734]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.734]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.734]             base::sink(type = "output", split = FALSE)
  [21:15:34.734]             base::close(...future.stdout)
  [21:15:34.734]         }, add = TRUE)
  [21:15:34.734]     }
  [21:15:34.734]     ...future.frame <- base::sys.nframe()
  [21:15:34.734]     ...future.conditions <- base::list()
  [21:15:34.734]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.734]     ...future.result <- base::tryCatch({
  [21:15:34.734]         base::withCallingHandlers({
  [21:15:34.734]             ...future.value <- base::withVisible(base::local({
  [21:15:34.734]                 sample(x, size = 1L)
  [21:15:34.734]             }))
  [21:15:34.734]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.734]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.734]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.734]                 version = "1.8")
  [21:15:34.734]         }, condition = base::local({
  [21:15:34.734]             c <- base::c
  [21:15:34.734]             inherits <- base::inherits
  [21:15:34.734]             invokeRestart <- base::invokeRestart
  [21:15:34.734]             length <- base::length
  [21:15:34.734]             list <- base::list
  [21:15:34.734]             seq.int <- base::seq.int
  [21:15:34.734]             signalCondition <- base::signalCondition
  [21:15:34.734]             sys.calls <- base::sys.calls
  [21:15:34.734]             Sys.time <- base::Sys.time
  [21:15:34.734]             `[[` <- base::`[[`
  [21:15:34.734]             `+` <- base::`+`
  [21:15:34.734]             `<<-` <- base::`<<-`
  [21:15:34.734]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.734]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.734]                   3L)]
  [21:15:34.734]             }
  [21:15:34.734]             function(cond) {
  [21:15:34.734]                 if (inherits(cond, "error")) {
  [21:15:34.734]                   sessionInformation <- function() {
  [21:15:34.734]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.734]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.734]                       search = base::search(), system = base::Sys.info())
  [21:15:34.734]                   }
  [21:15:34.734]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.734]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.734]                     cond$call), session = sessionInformation(), 
  [21:15:34.734]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.734]                   signalCondition(cond)
  [21:15:34.734]                 }
  [21:15:34.734]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.734]                 ))) {
  [21:15:34.734]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.734]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.734]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.734]                   if (!signal) {
  [21:15:34.734]                     muffleCondition <- function (cond) 
  [21:15:34.734]                     {
  [21:15:34.734]                       inherits <- base::inherits
  [21:15:34.734]                       invokeRestart <- base::invokeRestart
  [21:15:34.734]                       muffled <- FALSE
  [21:15:34.734]                       if (inherits(cond, "message")) {
  [21:15:34.734]                         invokeRestart("muffleMessage")
  [21:15:34.734]                         muffled <- TRUE
  [21:15:34.734]                       }
  [21:15:34.734]                       else if (inherits(cond, "warning")) {
  [21:15:34.734]                         invokeRestart("muffleWarning")
  [21:15:34.734]                         muffled <- TRUE
  [21:15:34.734]                       }
  [21:15:34.734]                       else if (inherits(cond, "condition")) {
  [21:15:34.734]                         computeRestarts <- base::computeRestarts
  [21:15:34.734]                         grepl <- base::grepl
  [21:15:34.734]                         is.null <- base::is.null
  [21:15:34.734]                         restarts <- computeRestarts(cond)
  [21:15:34.734]                         for (restart in restarts) {
  [21:15:34.734]                           name <- restart$name
  [21:15:34.734]                           if (is.null(name)) 
  [21:15:34.734]                             next
  [21:15:34.734]                           if (!grepl("^muffle", name)) 
  [21:15:34.734]                             next
  [21:15:34.734]                           invokeRestart(restart)
  [21:15:34.734]                           muffled <- TRUE
  [21:15:34.734]                           break
  [21:15:34.734]                         }
  [21:15:34.734]                       }
  [21:15:34.734]                       invisible(muffled)
  [21:15:34.734]                     }
  [21:15:34.734]                     muffleCondition(cond)
  [21:15:34.734]                   }
  [21:15:34.734]                 }
  [21:15:34.734]             }
  [21:15:34.734]         }))
  [21:15:34.734]     }, error = function(ex) {
  [21:15:34.734]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.734]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.734]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.734]     }, finally = {
  [21:15:34.734]         {
  [21:15:34.734]             NULL
  [21:15:34.734]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.734]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.734]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.734]                 label = NULL, ...) 
  [21:15:34.734]             {
  [21:15:34.734]                 if (substitute) 
  [21:15:34.734]                   expr <- substitute(expr)
  [21:15:34.734]                 local <- as.logical(local)
  [21:15:34.734]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.734]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.734]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.734]                   label = label, ...)
  [21:15:34.734]                 if (!future$lazy) 
  [21:15:34.734]                   future <- run(future)
  [21:15:34.734]                 invisible(future)
  [21:15:34.734]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.734]         }
  [21:15:34.734]         base::options(...future.oldOptions)
  [21:15:34.734]     })
  [21:15:34.734]     Sys.time
  [21:15:34.734]     if (base::is.na(TRUE)) {
  [21:15:34.734]     }
  [21:15:34.734]     else {
  [21:15:34.734]         base::sink(type = "output", split = FALSE)
  [21:15:34.734]         if (TRUE) {
  [21:15:34.734]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.734]         }
  [21:15:34.734]         else {
  [21:15:34.734]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.734]         }
  [21:15:34.734]         base::close(...future.stdout)
  [21:15:34.734]         ...future.stdout <- NULL
  [21:15:34.734]     }
  [21:15:34.734]     ...future.result$conditions <- ...future.conditions
  [21:15:34.734]     ...future.result
  [21:15:34.734] }
  [21:15:34.739] plan(): Setting new future strategy stack:
  [21:15:34.739] List of future strategies:
  [21:15:34.739] 1. sequential:
  [21:15:34.739]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.739]    - tweaked: FALSE
  [21:15:34.739]    - call: NULL
  [21:15:34.740] plan(): nbrOfWorkers() = 1
  [21:15:34.741] plan(): Setting new future strategy stack:
  [21:15:34.741] List of future strategies:
  [21:15:34.741] 1. sequential:
  [21:15:34.741]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.741]    - tweaked: FALSE
  [21:15:34.741]    - call: plan(strategy)
  [21:15:34.742] plan(): nbrOfWorkers() = 1
  [21:15:34.743] SequentialFuture started (and completed)
  [[1]]
  [1] 0
  
  [[2]]
  [1] 2
  
  [[3]]
  [1] 2
  
  [[4]]
  [1] 0
  
  [21:15:34.745] getGlobalsAndPackages() ...
  [21:15:34.746] Searching for globals...
  [21:15:34.748] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.748] Searching for globals ... DONE
  [21:15:34.748] Resolving globals: FALSE
  [21:15:34.749] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.750] - globals: [1] 'x'
  [21:15:34.750] 
  [21:15:34.750] getGlobalsAndPackages() ... DONE
  [21:15:34.752] Packages needed by the future expression (n = 0): <none>
  [21:15:34.753] Packages needed by future strategies (n = 0): <none>
  [21:15:34.760] {
  [21:15:34.760]     {
  [21:15:34.760]         ...future.startTime <- base::Sys.time()
  [21:15:34.760]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.760]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.760]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.760]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.760]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.760]         {
  [21:15:34.760]             {
  [21:15:34.760]                 base::local({
  [21:15:34.760]                   has_future <- base::requireNamespace("future", 
  [21:15:34.760]                     quietly = TRUE)
  [21:15:34.760]                   version <- if (has_future) 
  [21:15:34.760]                     utils::packageVersion("future")
  [21:15:34.760]                   else NULL
  [21:15:34.760]                   if (!has_future || version < "1.8.0") {
  [21:15:34.760]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.760]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.760]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.760]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.760]                         "release", "version")], collapse = " "), 
  [21:15:34.760]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.760]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.760]                       info)
  [21:15:34.760]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.760]                     if (!has_future) {
  [21:15:34.760]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.760]                         info)
  [21:15:34.760]                     }
  [21:15:34.760]                     else {
  [21:15:34.760]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.760]                         info, version)
  [21:15:34.760]                     }
  [21:15:34.760]                     base::stop(msg)
  [21:15:34.760]                   }
  [21:15:34.760]                 })
  [21:15:34.760]             }
  [21:15:34.760]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.760]         }
  [21:15:34.760]     }
  [21:15:34.760]     if (base::is.na(TRUE)) {
  [21:15:34.760]     }
  [21:15:34.760]     else {
  [21:15:34.760]         if (TRUE) {
  [21:15:34.760]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.760]                 open = "w")
  [21:15:34.760]         }
  [21:15:34.760]         else {
  [21:15:34.760]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.760]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.760]         }
  [21:15:34.760]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.760]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.760]             base::sink(type = "output", split = FALSE)
  [21:15:34.760]             base::close(...future.stdout)
  [21:15:34.760]         }, add = TRUE)
  [21:15:34.760]     }
  [21:15:34.760]     ...future.frame <- base::sys.nframe()
  [21:15:34.760]     ...future.conditions <- base::list()
  [21:15:34.760]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.760]     ...future.result <- base::tryCatch({
  [21:15:34.760]         base::withCallingHandlers({
  [21:15:34.760]             ...future.value <- base::withVisible(base::local({
  [21:15:34.760]                 sample(x, size = 1L)
  [21:15:34.760]             }))
  [21:15:34.760]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.760]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.760]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.760]                 version = "1.8")
  [21:15:34.760]         }, condition = base::local({
  [21:15:34.760]             c <- base::c
  [21:15:34.760]             inherits <- base::inherits
  [21:15:34.760]             invokeRestart <- base::invokeRestart
  [21:15:34.760]             length <- base::length
  [21:15:34.760]             list <- base::list
  [21:15:34.760]             seq.int <- base::seq.int
  [21:15:34.760]             signalCondition <- base::signalCondition
  [21:15:34.760]             sys.calls <- base::sys.calls
  [21:15:34.760]             Sys.time <- base::Sys.time
  [21:15:34.760]             `[[` <- base::`[[`
  [21:15:34.760]             `+` <- base::`+`
  [21:15:34.760]             `<<-` <- base::`<<-`
  [21:15:34.760]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.760]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.760]                   3L)]
  [21:15:34.760]             }
  [21:15:34.760]             function(cond) {
  [21:15:34.760]                 if (inherits(cond, "error")) {
  [21:15:34.760]                   sessionInformation <- function() {
  [21:15:34.760]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.760]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.760]                       search = base::search(), system = base::Sys.info())
  [21:15:34.760]                   }
  [21:15:34.760]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.760]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.760]                     cond$call), session = sessionInformation(), 
  [21:15:34.760]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.760]                   signalCondition(cond)
  [21:15:34.760]                 }
  [21:15:34.760]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.760]                 ))) {
  [21:15:34.760]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.760]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.760]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.760]                   if (!signal) {
  [21:15:34.760]                     muffleCondition <- function (cond) 
  [21:15:34.760]                     {
  [21:15:34.760]                       inherits <- base::inherits
  [21:15:34.760]                       invokeRestart <- base::invokeRestart
  [21:15:34.760]                       muffled <- FALSE
  [21:15:34.760]                       if (inherits(cond, "message")) {
  [21:15:34.760]                         invokeRestart("muffleMessage")
  [21:15:34.760]                         muffled <- TRUE
  [21:15:34.760]                       }
  [21:15:34.760]                       else if (inherits(cond, "warning")) {
  [21:15:34.760]                         invokeRestart("muffleWarning")
  [21:15:34.760]                         muffled <- TRUE
  [21:15:34.760]                       }
  [21:15:34.760]                       else if (inherits(cond, "condition")) {
  [21:15:34.760]                         computeRestarts <- base::computeRestarts
  [21:15:34.760]                         grepl <- base::grepl
  [21:15:34.760]                         is.null <- base::is.null
  [21:15:34.760]                         restarts <- computeRestarts(cond)
  [21:15:34.760]                         for (restart in restarts) {
  [21:15:34.760]                           name <- restart$name
  [21:15:34.760]                           if (is.null(name)) 
  [21:15:34.760]                             next
  [21:15:34.760]                           if (!grepl("^muffle", name)) 
  [21:15:34.760]                             next
  [21:15:34.760]                           invokeRestart(restart)
  [21:15:34.760]                           muffled <- TRUE
  [21:15:34.760]                           break
  [21:15:34.760]                         }
  [21:15:34.760]                       }
  [21:15:34.760]                       invisible(muffled)
  [21:15:34.760]                     }
  [21:15:34.760]                     muffleCondition(cond)
  [21:15:34.760]                   }
  [21:15:34.760]                 }
  [21:15:34.760]             }
  [21:15:34.760]         }))
  [21:15:34.760]     }, error = function(ex) {
  [21:15:34.760]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.760]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.760]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.760]     }, finally = {
  [21:15:34.760]         {
  [21:15:34.760]             NULL
  [21:15:34.760]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.760]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.760]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.760]                 label = NULL, ...) 
  [21:15:34.760]             {
  [21:15:34.760]                 if (substitute) 
  [21:15:34.760]                   expr <- substitute(expr)
  [21:15:34.760]                 local <- as.logical(local)
  [21:15:34.760]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.760]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.760]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.760]                   label = label, ...)
  [21:15:34.760]                 if (!future$lazy) 
  [21:15:34.760]                   future <- run(future)
  [21:15:34.760]                 invisible(future)
  [21:15:34.760]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.760]         }
  [21:15:34.760]         base::options(...future.oldOptions)
  [21:15:34.760]     })
  [21:15:34.760]     Sys.time
  [21:15:34.760]     if (base::is.na(TRUE)) {
  [21:15:34.760]     }
  [21:15:34.760]     else {
  [21:15:34.760]         base::sink(type = "output", split = FALSE)
  [21:15:34.760]         if (TRUE) {
  [21:15:34.760]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.760]         }
  [21:15:34.760]         else {
  [21:15:34.760]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.760]         }
  [21:15:34.760]         base::close(...future.stdout)
  [21:15:34.760]         ...future.stdout <- NULL
  [21:15:34.760]     }
  [21:15:34.760]     ...future.result$conditions <- ...future.conditions
  [21:15:34.760]     ...future.result
  [21:15:34.760] }
  [21:15:34.765] plan(): Setting new future strategy stack:
  [21:15:34.765] List of future strategies:
  [21:15:34.765] 1. sequential:
  [21:15:34.765]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.765]    - tweaked: FALSE
  [21:15:34.765]    - call: NULL
  [21:15:34.766] plan(): nbrOfWorkers() = 1
  [21:15:34.767] plan(): Setting new future strategy stack:
  [21:15:34.767] List of future strategies:
  [21:15:34.767] 1. sequential:
  [21:15:34.767]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.767]    - tweaked: FALSE
  [21:15:34.767]    - call: plan(strategy)
  [21:15:34.768] plan(): nbrOfWorkers() = 1
  [21:15:34.769] SequentialFuture started (and completed)
  [21:15:34.770] getGlobalsAndPackages() ...
  [21:15:34.770] Searching for globals...
  [21:15:34.772] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.773] Searching for globals ... DONE
  [21:15:34.773] Resolving globals: FALSE
  [21:15:34.774] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.774] - globals: [1] 'x'
  [21:15:34.775] 
  [21:15:34.775] getGlobalsAndPackages() ... DONE
  [21:15:34.777] Packages needed by the future expression (n = 0): <none>
  [21:15:34.777] Packages needed by future strategies (n = 0): <none>
  [21:15:34.782] {
  [21:15:34.782]     {
  [21:15:34.782]         ...future.startTime <- base::Sys.time()
  [21:15:34.782]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.782]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.782]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.782]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.782]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.782]         {
  [21:15:34.782]             {
  [21:15:34.782]                 base::local({
  [21:15:34.782]                   has_future <- base::requireNamespace("future", 
  [21:15:34.782]                     quietly = TRUE)
  [21:15:34.782]                   version <- if (has_future) 
  [21:15:34.782]                     utils::packageVersion("future")
  [21:15:34.782]                   else NULL
  [21:15:34.782]                   if (!has_future || version < "1.8.0") {
  [21:15:34.782]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.782]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.782]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.782]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.782]                         "release", "version")], collapse = " "), 
  [21:15:34.782]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.782]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.782]                       info)
  [21:15:34.782]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.782]                     if (!has_future) {
  [21:15:34.782]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.782]                         info)
  [21:15:34.782]                     }
  [21:15:34.782]                     else {
  [21:15:34.782]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.782]                         info, version)
  [21:15:34.782]                     }
  [21:15:34.782]                     base::stop(msg)
  [21:15:34.782]                   }
  [21:15:34.782]                 })
  [21:15:34.782]             }
  [21:15:34.782]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.782]         }
  [21:15:34.782]     }
  [21:15:34.782]     if (base::is.na(TRUE)) {
  [21:15:34.782]     }
  [21:15:34.782]     else {
  [21:15:34.782]         if (TRUE) {
  [21:15:34.782]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.782]                 open = "w")
  [21:15:34.782]         }
  [21:15:34.782]         else {
  [21:15:34.782]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.782]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.782]         }
  [21:15:34.782]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.782]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.782]             base::sink(type = "output", split = FALSE)
  [21:15:34.782]             base::close(...future.stdout)
  [21:15:34.782]         }, add = TRUE)
  [21:15:34.782]     }
  [21:15:34.782]     ...future.frame <- base::sys.nframe()
  [21:15:34.782]     ...future.conditions <- base::list()
  [21:15:34.782]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.782]     ...future.result <- base::tryCatch({
  [21:15:34.782]         base::withCallingHandlers({
  [21:15:34.782]             ...future.value <- base::withVisible(base::local({
  [21:15:34.782]                 sample(x, size = 1L)
  [21:15:34.782]             }))
  [21:15:34.782]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.782]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.782]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.782]                 version = "1.8")
  [21:15:34.782]         }, condition = base::local({
  [21:15:34.782]             c <- base::c
  [21:15:34.782]             inherits <- base::inherits
  [21:15:34.782]             invokeRestart <- base::invokeRestart
  [21:15:34.782]             length <- base::length
  [21:15:34.782]             list <- base::list
  [21:15:34.782]             seq.int <- base::seq.int
  [21:15:34.782]             signalCondition <- base::signalCondition
  [21:15:34.782]             sys.calls <- base::sys.calls
  [21:15:34.782]             Sys.time <- base::Sys.time
  [21:15:34.782]             `[[` <- base::`[[`
  [21:15:34.782]             `+` <- base::`+`
  [21:15:34.782]             `<<-` <- base::`<<-`
  [21:15:34.782]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.782]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.782]                   3L)]
  [21:15:34.782]             }
  [21:15:34.782]             function(cond) {
  [21:15:34.782]                 if (inherits(cond, "error")) {
  [21:15:34.782]                   sessionInformation <- function() {
  [21:15:34.782]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.782]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.782]                       search = base::search(), system = base::Sys.info())
  [21:15:34.782]                   }
  [21:15:34.782]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.782]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.782]                     cond$call), session = sessionInformation(), 
  [21:15:34.782]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.782]                   signalCondition(cond)
  [21:15:34.782]                 }
  [21:15:34.782]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.782]                 ))) {
  [21:15:34.782]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.782]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.782]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.782]                   if (!signal) {
  [21:15:34.782]                     muffleCondition <- function (cond) 
  [21:15:34.782]                     {
  [21:15:34.782]                       inherits <- base::inherits
  [21:15:34.782]                       invokeRestart <- base::invokeRestart
  [21:15:34.782]                       muffled <- FALSE
  [21:15:34.782]                       if (inherits(cond, "message")) {
  [21:15:34.782]                         invokeRestart("muffleMessage")
  [21:15:34.782]                         muffled <- TRUE
  [21:15:34.782]                       }
  [21:15:34.782]                       else if (inherits(cond, "warning")) {
  [21:15:34.782]                         invokeRestart("muffleWarning")
  [21:15:34.782]                         muffled <- TRUE
  [21:15:34.782]                       }
  [21:15:34.782]                       else if (inherits(cond, "condition")) {
  [21:15:34.782]                         computeRestarts <- base::computeRestarts
  [21:15:34.782]                         grepl <- base::grepl
  [21:15:34.782]                         is.null <- base::is.null
  [21:15:34.782]                         restarts <- computeRestarts(cond)
  [21:15:34.782]                         for (restart in restarts) {
  [21:15:34.782]                           name <- restart$name
  [21:15:34.782]                           if (is.null(name)) 
  [21:15:34.782]                             next
  [21:15:34.782]                           if (!grepl("^muffle", name)) 
  [21:15:34.782]                             next
  [21:15:34.782]                           invokeRestart(restart)
  [21:15:34.782]                           muffled <- TRUE
  [21:15:34.782]                           break
  [21:15:34.782]                         }
  [21:15:34.782]                       }
  [21:15:34.782]                       invisible(muffled)
  [21:15:34.782]                     }
  [21:15:34.782]                     muffleCondition(cond)
  [21:15:34.782]                   }
  [21:15:34.782]                 }
  [21:15:34.782]             }
  [21:15:34.782]         }))
  [21:15:34.782]     }, error = function(ex) {
  [21:15:34.782]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.782]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.782]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.782]     }, finally = {
  [21:15:34.782]         {
  [21:15:34.782]             NULL
  [21:15:34.782]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.782]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.782]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.782]                 label = NULL, ...) 
  [21:15:34.782]             {
  [21:15:34.782]                 if (substitute) 
  [21:15:34.782]                   expr <- substitute(expr)
  [21:15:34.782]                 local <- as.logical(local)
  [21:15:34.782]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.782]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.782]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.782]                   label = label, ...)
  [21:15:34.782]                 if (!future$lazy) 
  [21:15:34.782]                   future <- run(future)
  [21:15:34.782]                 invisible(future)
  [21:15:34.782]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.782]         }
  [21:15:34.782]         base::options(...future.oldOptions)
  [21:15:34.782]     })
  [21:15:34.782]     Sys.time
  [21:15:34.782]     if (base::is.na(TRUE)) {
  [21:15:34.782]     }
  [21:15:34.782]     else {
  [21:15:34.782]         base::sink(type = "output", split = FALSE)
  [21:15:34.782]         if (TRUE) {
  [21:15:34.782]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.782]         }
  [21:15:34.782]         else {
  [21:15:34.782]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.782]         }
  [21:15:34.782]         base::close(...future.stdout)
  [21:15:34.782]         ...future.stdout <- NULL
  [21:15:34.782]     }
  [21:15:34.782]     ...future.result$conditions <- ...future.conditions
  [21:15:34.782]     ...future.result
  [21:15:34.782] }
  [21:15:34.787] plan(): Setting new future strategy stack:
  [21:15:34.787] List of future strategies:
  [21:15:34.787] 1. sequential:
  [21:15:34.787]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.787]    - tweaked: FALSE
  [21:15:34.787]    - call: NULL
  [21:15:34.788] plan(): nbrOfWorkers() = 1
  [21:15:34.789] plan(): Setting new future strategy stack:
  [21:15:34.790] List of future strategies:
  [21:15:34.790] 1. sequential:
  [21:15:34.790]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.790]    - tweaked: FALSE
  [21:15:34.790]    - call: plan(strategy)
  [21:15:34.791] plan(): nbrOfWorkers() = 1
  [21:15:34.791] SequentialFuture started (and completed)
  [21:15:34.792] getGlobalsAndPackages() ...
  [21:15:34.793] Searching for globals...
  [21:15:34.795] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.795] Searching for globals ... DONE
  [21:15:34.796] Resolving globals: FALSE
  [21:15:34.796] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.797] - globals: [1] 'x'
  [21:15:34.797] 
  [21:15:34.797] getGlobalsAndPackages() ... DONE
  [21:15:34.799] Packages needed by the future expression (n = 0): <none>
  [21:15:34.800] Packages needed by future strategies (n = 0): <none>
  [21:15:34.805] {
  [21:15:34.805]     {
  [21:15:34.805]         ...future.startTime <- base::Sys.time()
  [21:15:34.805]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.805]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.805]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.805]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.805]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.805]         {
  [21:15:34.805]             {
  [21:15:34.805]                 base::local({
  [21:15:34.805]                   has_future <- base::requireNamespace("future", 
  [21:15:34.805]                     quietly = TRUE)
  [21:15:34.805]                   version <- if (has_future) 
  [21:15:34.805]                     utils::packageVersion("future")
  [21:15:34.805]                   else NULL
  [21:15:34.805]                   if (!has_future || version < "1.8.0") {
  [21:15:34.805]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.805]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.805]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.805]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.805]                         "release", "version")], collapse = " "), 
  [21:15:34.805]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.805]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.805]                       info)
  [21:15:34.805]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.805]                     if (!has_future) {
  [21:15:34.805]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.805]                         info)
  [21:15:34.805]                     }
  [21:15:34.805]                     else {
  [21:15:34.805]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.805]                         info, version)
  [21:15:34.805]                     }
  [21:15:34.805]                     base::stop(msg)
  [21:15:34.805]                   }
  [21:15:34.805]                 })
  [21:15:34.805]             }
  [21:15:34.805]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.805]         }
  [21:15:34.805]     }
  [21:15:34.805]     if (base::is.na(TRUE)) {
  [21:15:34.805]     }
  [21:15:34.805]     else {
  [21:15:34.805]         if (TRUE) {
  [21:15:34.805]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.805]                 open = "w")
  [21:15:34.805]         }
  [21:15:34.805]         else {
  [21:15:34.805]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.805]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.805]         }
  [21:15:34.805]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.805]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.805]             base::sink(type = "output", split = FALSE)
  [21:15:34.805]             base::close(...future.stdout)
  [21:15:34.805]         }, add = TRUE)
  [21:15:34.805]     }
  [21:15:34.805]     ...future.frame <- base::sys.nframe()
  [21:15:34.805]     ...future.conditions <- base::list()
  [21:15:34.805]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.805]     ...future.result <- base::tryCatch({
  [21:15:34.805]         base::withCallingHandlers({
  [21:15:34.805]             ...future.value <- base::withVisible(base::local({
  [21:15:34.805]                 sample(x, size = 1L)
  [21:15:34.805]             }))
  [21:15:34.805]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.805]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.805]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.805]                 version = "1.8")
  [21:15:34.805]         }, condition = base::local({
  [21:15:34.805]             c <- base::c
  [21:15:34.805]             inherits <- base::inherits
  [21:15:34.805]             invokeRestart <- base::invokeRestart
  [21:15:34.805]             length <- base::length
  [21:15:34.805]             list <- base::list
  [21:15:34.805]             seq.int <- base::seq.int
  [21:15:34.805]             signalCondition <- base::signalCondition
  [21:15:34.805]             sys.calls <- base::sys.calls
  [21:15:34.805]             Sys.time <- base::Sys.time
  [21:15:34.805]             `[[` <- base::`[[`
  [21:15:34.805]             `+` <- base::`+`
  [21:15:34.805]             `<<-` <- base::`<<-`
  [21:15:34.805]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.805]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.805]                   3L)]
  [21:15:34.805]             }
  [21:15:34.805]             function(cond) {
  [21:15:34.805]                 if (inherits(cond, "error")) {
  [21:15:34.805]                   sessionInformation <- function() {
  [21:15:34.805]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.805]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.805]                       search = base::search(), system = base::Sys.info())
  [21:15:34.805]                   }
  [21:15:34.805]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.805]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.805]                     cond$call), session = sessionInformation(), 
  [21:15:34.805]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.805]                   signalCondition(cond)
  [21:15:34.805]                 }
  [21:15:34.805]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.805]                 ))) {
  [21:15:34.805]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.805]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.805]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.805]                   if (!signal) {
  [21:15:34.805]                     muffleCondition <- function (cond) 
  [21:15:34.805]                     {
  [21:15:34.805]                       inherits <- base::inherits
  [21:15:34.805]                       invokeRestart <- base::invokeRestart
  [21:15:34.805]                       muffled <- FALSE
  [21:15:34.805]                       if (inherits(cond, "message")) {
  [21:15:34.805]                         invokeRestart("muffleMessage")
  [21:15:34.805]                         muffled <- TRUE
  [21:15:34.805]                       }
  [21:15:34.805]                       else if (inherits(cond, "warning")) {
  [21:15:34.805]                         invokeRestart("muffleWarning")
  [21:15:34.805]                         muffled <- TRUE
  [21:15:34.805]                       }
  [21:15:34.805]                       else if (inherits(cond, "condition")) {
  [21:15:34.805]                         computeRestarts <- base::computeRestarts
  [21:15:34.805]                         grepl <- base::grepl
  [21:15:34.805]                         is.null <- base::is.null
  [21:15:34.805]                         restarts <- computeRestarts(cond)
  [21:15:34.805]                         for (restart in restarts) {
  [21:15:34.805]                           name <- restart$name
  [21:15:34.805]                           if (is.null(name)) 
  [21:15:34.805]                             next
  [21:15:34.805]                           if (!grepl("^muffle", name)) 
  [21:15:34.805]                             next
  [21:15:34.805]                           invokeRestart(restart)
  [21:15:34.805]                           muffled <- TRUE
  [21:15:34.805]                           break
  [21:15:34.805]                         }
  [21:15:34.805]                       }
  [21:15:34.805]                       invisible(muffled)
  [21:15:34.805]                     }
  [21:15:34.805]                     muffleCondition(cond)
  [21:15:34.805]                   }
  [21:15:34.805]                 }
  [21:15:34.805]             }
  [21:15:34.805]         }))
  [21:15:34.805]     }, error = function(ex) {
  [21:15:34.805]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.805]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.805]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.805]     }, finally = {
  [21:15:34.805]         {
  [21:15:34.805]             NULL
  [21:15:34.805]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.805]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.805]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.805]                 label = NULL, ...) 
  [21:15:34.805]             {
  [21:15:34.805]                 if (substitute) 
  [21:15:34.805]                   expr <- substitute(expr)
  [21:15:34.805]                 local <- as.logical(local)
  [21:15:34.805]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.805]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.805]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.805]                   label = label, ...)
  [21:15:34.805]                 if (!future$lazy) 
  [21:15:34.805]                   future <- run(future)
  [21:15:34.805]                 invisible(future)
  [21:15:34.805]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.805]         }
  [21:15:34.805]         base::options(...future.oldOptions)
  [21:15:34.805]     })
  [21:15:34.805]     Sys.time
  [21:15:34.805]     if (base::is.na(TRUE)) {
  [21:15:34.805]     }
  [21:15:34.805]     else {
  [21:15:34.805]         base::sink(type = "output", split = FALSE)
  [21:15:34.805]         if (TRUE) {
  [21:15:34.805]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.805]         }
  [21:15:34.805]         else {
  [21:15:34.805]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.805]         }
  [21:15:34.805]         base::close(...future.stdout)
  [21:15:34.805]         ...future.stdout <- NULL
  [21:15:34.805]     }
  [21:15:34.805]     ...future.result$conditions <- ...future.conditions
  [21:15:34.805]     ...future.result
  [21:15:34.805] }
  [21:15:34.809] plan(): Setting new future strategy stack:
  [21:15:34.810] List of future strategies:
  [21:15:34.810] 1. sequential:
  [21:15:34.810]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.810]    - tweaked: FALSE
  [21:15:34.810]    - call: NULL
  [21:15:34.811] plan(): nbrOfWorkers() = 1
  [21:15:34.812] plan(): Setting new future strategy stack:
  [21:15:34.812] List of future strategies:
  [21:15:34.812] 1. sequential:
  [21:15:34.812]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.812]    - tweaked: FALSE
  [21:15:34.812]    - call: plan(strategy)
  [21:15:34.813] plan(): nbrOfWorkers() = 1
  [21:15:34.814] SequentialFuture started (and completed)
  [21:15:34.815] getGlobalsAndPackages() ...
  [21:15:34.815] Searching for globals...
  [21:15:34.817] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.818] Searching for globals ... DONE
  [21:15:34.818] Resolving globals: FALSE
  [21:15:34.819] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.819] - globals: [1] 'x'
  [21:15:34.820] 
  [21:15:34.820] getGlobalsAndPackages() ... DONE
  [21:15:34.822] Packages needed by the future expression (n = 0): <none>
  [21:15:34.822] Packages needed by future strategies (n = 0): <none>
  [21:15:34.826] {
  [21:15:34.826]     {
  [21:15:34.826]         ...future.startTime <- base::Sys.time()
  [21:15:34.826]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.826]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.826]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.826]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.826]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.826]         {
  [21:15:34.826]             {
  [21:15:34.826]                 base::local({
  [21:15:34.826]                   has_future <- base::requireNamespace("future", 
  [21:15:34.826]                     quietly = TRUE)
  [21:15:34.826]                   version <- if (has_future) 
  [21:15:34.826]                     utils::packageVersion("future")
  [21:15:34.826]                   else NULL
  [21:15:34.826]                   if (!has_future || version < "1.8.0") {
  [21:15:34.826]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.826]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.826]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.826]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.826]                         "release", "version")], collapse = " "), 
  [21:15:34.826]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.826]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.826]                       info)
  [21:15:34.826]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.826]                     if (!has_future) {
  [21:15:34.826]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.826]                         info)
  [21:15:34.826]                     }
  [21:15:34.826]                     else {
  [21:15:34.826]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.826]                         info, version)
  [21:15:34.826]                     }
  [21:15:34.826]                     base::stop(msg)
  [21:15:34.826]                   }
  [21:15:34.826]                 })
  [21:15:34.826]             }
  [21:15:34.826]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.826]         }
  [21:15:34.826]     }
  [21:15:34.826]     if (base::is.na(TRUE)) {
  [21:15:34.826]     }
  [21:15:34.826]     else {
  [21:15:34.826]         if (TRUE) {
  [21:15:34.826]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.826]                 open = "w")
  [21:15:34.826]         }
  [21:15:34.826]         else {
  [21:15:34.826]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.826]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.826]         }
  [21:15:34.826]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.826]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.826]             base::sink(type = "output", split = FALSE)
  [21:15:34.826]             base::close(...future.stdout)
  [21:15:34.826]         }, add = TRUE)
  [21:15:34.826]     }
  [21:15:34.826]     ...future.frame <- base::sys.nframe()
  [21:15:34.826]     ...future.conditions <- base::list()
  [21:15:34.826]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.826]     ...future.result <- base::tryCatch({
  [21:15:34.826]         base::withCallingHandlers({
  [21:15:34.826]             ...future.value <- base::withVisible(base::local({
  [21:15:34.826]                 sample(x, size = 1L)
  [21:15:34.826]             }))
  [21:15:34.826]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.826]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.826]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.826]                 version = "1.8")
  [21:15:34.826]         }, condition = base::local({
  [21:15:34.826]             c <- base::c
  [21:15:34.826]             inherits <- base::inherits
  [21:15:34.826]             invokeRestart <- base::invokeRestart
  [21:15:34.826]             length <- base::length
  [21:15:34.826]             list <- base::list
  [21:15:34.826]             seq.int <- base::seq.int
  [21:15:34.826]             signalCondition <- base::signalCondition
  [21:15:34.826]             sys.calls <- base::sys.calls
  [21:15:34.826]             Sys.time <- base::Sys.time
  [21:15:34.826]             `[[` <- base::`[[`
  [21:15:34.826]             `+` <- base::`+`
  [21:15:34.826]             `<<-` <- base::`<<-`
  [21:15:34.826]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.826]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.826]                   3L)]
  [21:15:34.826]             }
  [21:15:34.826]             function(cond) {
  [21:15:34.826]                 if (inherits(cond, "error")) {
  [21:15:34.826]                   sessionInformation <- function() {
  [21:15:34.826]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.826]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.826]                       search = base::search(), system = base::Sys.info())
  [21:15:34.826]                   }
  [21:15:34.826]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.826]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.826]                     cond$call), session = sessionInformation(), 
  [21:15:34.826]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.826]                   signalCondition(cond)
  [21:15:34.826]                 }
  [21:15:34.826]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.826]                 ))) {
  [21:15:34.826]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.826]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.826]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.826]                   if (!signal) {
  [21:15:34.826]                     muffleCondition <- function (cond) 
  [21:15:34.826]                     {
  [21:15:34.826]                       inherits <- base::inherits
  [21:15:34.826]                       invokeRestart <- base::invokeRestart
  [21:15:34.826]                       muffled <- FALSE
  [21:15:34.826]                       if (inherits(cond, "message")) {
  [21:15:34.826]                         invokeRestart("muffleMessage")
  [21:15:34.826]                         muffled <- TRUE
  [21:15:34.826]                       }
  [21:15:34.826]                       else if (inherits(cond, "warning")) {
  [21:15:34.826]                         invokeRestart("muffleWarning")
  [21:15:34.826]                         muffled <- TRUE
  [21:15:34.826]                       }
  [21:15:34.826]                       else if (inherits(cond, "condition")) {
  [21:15:34.826]                         computeRestarts <- base::computeRestarts
  [21:15:34.826]                         grepl <- base::grepl
  [21:15:34.826]                         is.null <- base::is.null
  [21:15:34.826]                         restarts <- computeRestarts(cond)
  [21:15:34.826]                         for (restart in restarts) {
  [21:15:34.826]                           name <- restart$name
  [21:15:34.826]                           if (is.null(name)) 
  [21:15:34.826]                             next
  [21:15:34.826]                           if (!grepl("^muffle", name)) 
  [21:15:34.826]                             next
  [21:15:34.826]                           invokeRestart(restart)
  [21:15:34.826]                           muffled <- TRUE
  [21:15:34.826]                           break
  [21:15:34.826]                         }
  [21:15:34.826]                       }
  [21:15:34.826]                       invisible(muffled)
  [21:15:34.826]                     }
  [21:15:34.826]                     muffleCondition(cond)
  [21:15:34.826]                   }
  [21:15:34.826]                 }
  [21:15:34.826]             }
  [21:15:34.826]         }))
  [21:15:34.826]     }, error = function(ex) {
  [21:15:34.826]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.826]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.826]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.826]     }, finally = {
  [21:15:34.826]         {
  [21:15:34.826]             NULL
  [21:15:34.826]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.826]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.826]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.826]                 label = NULL, ...) 
  [21:15:34.826]             {
  [21:15:34.826]                 if (substitute) 
  [21:15:34.826]                   expr <- substitute(expr)
  [21:15:34.826]                 local <- as.logical(local)
  [21:15:34.826]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.826]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.826]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.826]                   label = label, ...)
  [21:15:34.826]                 if (!future$lazy) 
  [21:15:34.826]                   future <- run(future)
  [21:15:34.826]                 invisible(future)
  [21:15:34.826]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.826]         }
  [21:15:34.826]         base::options(...future.oldOptions)
  [21:15:34.826]     })
  [21:15:34.826]     Sys.time
  [21:15:34.826]     if (base::is.na(TRUE)) {
  [21:15:34.826]     }
  [21:15:34.826]     else {
  [21:15:34.826]         base::sink(type = "output", split = FALSE)
  [21:15:34.826]         if (TRUE) {
  [21:15:34.826]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.826]         }
  [21:15:34.826]         else {
  [21:15:34.826]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.826]         }
  [21:15:34.826]         base::close(...future.stdout)
  [21:15:34.826]         ...future.stdout <- NULL
  [21:15:34.826]     }
  [21:15:34.826]     ...future.result$conditions <- ...future.conditions
  [21:15:34.826]     ...future.result
  [21:15:34.826] }
  [21:15:34.833] plan(): Setting new future strategy stack:
  [21:15:34.834] List of future strategies:
  [21:15:34.834] 1. sequential:
  [21:15:34.834]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.834]    - tweaked: FALSE
  [21:15:34.834]    - call: NULL
  [21:15:34.835] plan(): nbrOfWorkers() = 1
  [21:15:34.836] plan(): Setting new future strategy stack:
  [21:15:34.836] List of future strategies:
  [21:15:34.836] 1. sequential:
  [21:15:34.836]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.836]    - tweaked: FALSE
  [21:15:34.836]    - call: plan(strategy)
  [21:15:34.837] plan(): nbrOfWorkers() = 1
  [21:15:34.838] SequentialFuture started (and completed)
  [21:15:34.839] Future state: 'finished'
  [21:15:34.839] signalConditions() ...
  [21:15:34.839]  - include = 'condition'
  [21:15:34.840]  - exclude = 'immediateCondition'
  [21:15:34.840]  - resignal = TRUE
  [21:15:34.840]  - Number of conditions: 1
  [21:15:34.841]  - Condition #1: 'simpleWarning', 'warning', 'condition'
  [21:15:34.841] signalConditions() ... done
  <simpleWarning: UNRELIABLE VALUE: Future ('fsample_1-798024') unexpectedly generated random numbers without specifying argument '[future.]seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify argument argument '[future.]seed', e.g. 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, set option 'future.rng.onMisuse' to "ignore".>
  [21:15:34.842] getGlobalsAndPackages() ...
  [21:15:34.843] Searching for globals...
  [21:15:34.845] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.845] Searching for globals ... DONE
  [21:15:34.845] Resolving globals: FALSE
  [21:15:34.846] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.847] - globals: [1] 'x'
  [21:15:34.847] 
  [21:15:34.847] getGlobalsAndPackages() ... DONE
  [21:15:34.849] Packages needed by the future expression (n = 0): <none>
  [21:15:34.849] Packages needed by future strategies (n = 0): <none>
  [21:15:34.854] {
  [21:15:34.854]     {
  [21:15:34.854]         ...future.startTime <- base::Sys.time()
  [21:15:34.854]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.854]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.854]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.854]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.854]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.854]         {
  [21:15:34.854]             {
  [21:15:34.854]                 base::local({
  [21:15:34.854]                   has_future <- base::requireNamespace("future", 
  [21:15:34.854]                     quietly = TRUE)
  [21:15:34.854]                   version <- if (has_future) 
  [21:15:34.854]                     utils::packageVersion("future")
  [21:15:34.854]                   else NULL
  [21:15:34.854]                   if (!has_future || version < "1.8.0") {
  [21:15:34.854]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.854]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.854]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.854]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.854]                         "release", "version")], collapse = " "), 
  [21:15:34.854]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.854]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.854]                       info)
  [21:15:34.854]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.854]                     if (!has_future) {
  [21:15:34.854]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.854]                         info)
  [21:15:34.854]                     }
  [21:15:34.854]                     else {
  [21:15:34.854]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.854]                         info, version)
  [21:15:34.854]                     }
  [21:15:34.854]                     base::stop(msg)
  [21:15:34.854]                   }
  [21:15:34.854]                 })
  [21:15:34.854]             }
  [21:15:34.854]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.854]         }
  [21:15:34.854]     }
  [21:15:34.854]     if (base::is.na(TRUE)) {
  [21:15:34.854]     }
  [21:15:34.854]     else {
  [21:15:34.854]         if (TRUE) {
  [21:15:34.854]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.854]                 open = "w")
  [21:15:34.854]         }
  [21:15:34.854]         else {
  [21:15:34.854]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.854]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.854]         }
  [21:15:34.854]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.854]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.854]             base::sink(type = "output", split = FALSE)
  [21:15:34.854]             base::close(...future.stdout)
  [21:15:34.854]         }, add = TRUE)
  [21:15:34.854]     }
  [21:15:34.854]     ...future.frame <- base::sys.nframe()
  [21:15:34.854]     ...future.conditions <- base::list()
  [21:15:34.854]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.854]     ...future.result <- base::tryCatch({
  [21:15:34.854]         base::withCallingHandlers({
  [21:15:34.854]             ...future.value <- base::withVisible(base::local({
  [21:15:34.854]                 sample(x, size = 1L)
  [21:15:34.854]             }))
  [21:15:34.854]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.854]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.854]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.854]                 version = "1.8")
  [21:15:34.854]         }, condition = base::local({
  [21:15:34.854]             c <- base::c
  [21:15:34.854]             inherits <- base::inherits
  [21:15:34.854]             invokeRestart <- base::invokeRestart
  [21:15:34.854]             length <- base::length
  [21:15:34.854]             list <- base::list
  [21:15:34.854]             seq.int <- base::seq.int
  [21:15:34.854]             signalCondition <- base::signalCondition
  [21:15:34.854]             sys.calls <- base::sys.calls
  [21:15:34.854]             Sys.time <- base::Sys.time
  [21:15:34.854]             `[[` <- base::`[[`
  [21:15:34.854]             `+` <- base::`+`
  [21:15:34.854]             `<<-` <- base::`<<-`
  [21:15:34.854]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.854]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.854]                   3L)]
  [21:15:34.854]             }
  [21:15:34.854]             function(cond) {
  [21:15:34.854]                 if (inherits(cond, "error")) {
  [21:15:34.854]                   sessionInformation <- function() {
  [21:15:34.854]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.854]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.854]                       search = base::search(), system = base::Sys.info())
  [21:15:34.854]                   }
  [21:15:34.854]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.854]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.854]                     cond$call), session = sessionInformation(), 
  [21:15:34.854]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.854]                   signalCondition(cond)
  [21:15:34.854]                 }
  [21:15:34.854]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.854]                 ))) {
  [21:15:34.854]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.854]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.854]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.854]                   if (!signal) {
  [21:15:34.854]                     muffleCondition <- function (cond) 
  [21:15:34.854]                     {
  [21:15:34.854]                       inherits <- base::inherits
  [21:15:34.854]                       invokeRestart <- base::invokeRestart
  [21:15:34.854]                       muffled <- FALSE
  [21:15:34.854]                       if (inherits(cond, "message")) {
  [21:15:34.854]                         invokeRestart("muffleMessage")
  [21:15:34.854]                         muffled <- TRUE
  [21:15:34.854]                       }
  [21:15:34.854]                       else if (inherits(cond, "warning")) {
  [21:15:34.854]                         invokeRestart("muffleWarning")
  [21:15:34.854]                         muffled <- TRUE
  [21:15:34.854]                       }
  [21:15:34.854]                       else if (inherits(cond, "condition")) {
  [21:15:34.854]                         computeRestarts <- base::computeRestarts
  [21:15:34.854]                         grepl <- base::grepl
  [21:15:34.854]                         is.null <- base::is.null
  [21:15:34.854]                         restarts <- computeRestarts(cond)
  [21:15:34.854]                         for (restart in restarts) {
  [21:15:34.854]                           name <- restart$name
  [21:15:34.854]                           if (is.null(name)) 
  [21:15:34.854]                             next
  [21:15:34.854]                           if (!grepl("^muffle", name)) 
  [21:15:34.854]                             next
  [21:15:34.854]                           invokeRestart(restart)
  [21:15:34.854]                           muffled <- TRUE
  [21:15:34.854]                           break
  [21:15:34.854]                         }
  [21:15:34.854]                       }
  [21:15:34.854]                       invisible(muffled)
  [21:15:34.854]                     }
  [21:15:34.854]                     muffleCondition(cond)
  [21:15:34.854]                   }
  [21:15:34.854]                 }
  [21:15:34.854]             }
  [21:15:34.854]         }))
  [21:15:34.854]     }, error = function(ex) {
  [21:15:34.854]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.854]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.854]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.854]     }, finally = {
  [21:15:34.854]         {
  [21:15:34.854]             NULL
  [21:15:34.854]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.854]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.854]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.854]                 label = NULL, ...) 
  [21:15:34.854]             {
  [21:15:34.854]                 if (substitute) 
  [21:15:34.854]                   expr <- substitute(expr)
  [21:15:34.854]                 local <- as.logical(local)
  [21:15:34.854]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.854]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.854]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.854]                   label = label, ...)
  [21:15:34.854]                 if (!future$lazy) 
  [21:15:34.854]                   future <- run(future)
  [21:15:34.854]                 invisible(future)
  [21:15:34.854]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.854]         }
  [21:15:34.854]         base::options(...future.oldOptions)
  [21:15:34.854]     })
  [21:15:34.854]     Sys.time
  [21:15:34.854]     if (base::is.na(TRUE)) {
  [21:15:34.854]     }
  [21:15:34.854]     else {
  [21:15:34.854]         base::sink(type = "output", split = FALSE)
  [21:15:34.854]         if (TRUE) {
  [21:15:34.854]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.854]         }
  [21:15:34.854]         else {
  [21:15:34.854]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.854]         }
  [21:15:34.854]         base::close(...future.stdout)
  [21:15:34.854]         ...future.stdout <- NULL
  [21:15:34.854]     }
  [21:15:34.854]     ...future.result$conditions <- ...future.conditions
  [21:15:34.854]     ...future.result
  [21:15:34.854] }
  [21:15:34.859] plan(): Setting new future strategy stack:
  [21:15:34.859] List of future strategies:
  [21:15:34.859] 1. sequential:
  [21:15:34.859]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.859]    - tweaked: FALSE
  [21:15:34.859]    - call: NULL
  [21:15:34.860] plan(): nbrOfWorkers() = 1
  [21:15:34.861] plan(): Setting new future strategy stack:
  [21:15:34.862] List of future strategies:
  [21:15:34.862] 1. sequential:
  [21:15:34.862]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.862]    - tweaked: FALSE
  [21:15:34.862]    - call: plan(strategy)
  [21:15:34.863] plan(): nbrOfWorkers() = 1
  [21:15:34.863] SequentialFuture started (and completed)
  [21:15:34.864] getGlobalsAndPackages() ...
  [21:15:34.865] Searching for globals...
  [21:15:34.867] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.867] Searching for globals ... DONE
  [21:15:34.868] Resolving globals: FALSE
  [21:15:34.869] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.869] - globals: [1] 'x'
  [21:15:34.869] 
  [21:15:34.870] getGlobalsAndPackages() ... DONE
  [21:15:34.871] Packages needed by the future expression (n = 0): <none>
  [21:15:34.872] Packages needed by future strategies (n = 0): <none>
  [21:15:34.876] {
  [21:15:34.876]     {
  [21:15:34.876]         ...future.startTime <- base::Sys.time()
  [21:15:34.876]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.876]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.876]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.876]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.876]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.876]         {
  [21:15:34.876]             {
  [21:15:34.876]                 base::local({
  [21:15:34.876]                   has_future <- base::requireNamespace("future", 
  [21:15:34.876]                     quietly = TRUE)
  [21:15:34.876]                   version <- if (has_future) 
  [21:15:34.876]                     utils::packageVersion("future")
  [21:15:34.876]                   else NULL
  [21:15:34.876]                   if (!has_future || version < "1.8.0") {
  [21:15:34.876]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.876]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.876]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.876]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.876]                         "release", "version")], collapse = " "), 
  [21:15:34.876]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.876]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.876]                       info)
  [21:15:34.876]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.876]                     if (!has_future) {
  [21:15:34.876]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.876]                         info)
  [21:15:34.876]                     }
  [21:15:34.876]                     else {
  [21:15:34.876]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.876]                         info, version)
  [21:15:34.876]                     }
  [21:15:34.876]                     base::stop(msg)
  [21:15:34.876]                   }
  [21:15:34.876]                 })
  [21:15:34.876]             }
  [21:15:34.876]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.876]         }
  [21:15:34.876]     }
  [21:15:34.876]     if (base::is.na(TRUE)) {
  [21:15:34.876]     }
  [21:15:34.876]     else {
  [21:15:34.876]         if (TRUE) {
  [21:15:34.876]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.876]                 open = "w")
  [21:15:34.876]         }
  [21:15:34.876]         else {
  [21:15:34.876]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.876]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.876]         }
  [21:15:34.876]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.876]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.876]             base::sink(type = "output", split = FALSE)
  [21:15:34.876]             base::close(...future.stdout)
  [21:15:34.876]         }, add = TRUE)
  [21:15:34.876]     }
  [21:15:34.876]     ...future.frame <- base::sys.nframe()
  [21:15:34.876]     ...future.conditions <- base::list()
  [21:15:34.876]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.876]     ...future.result <- base::tryCatch({
  [21:15:34.876]         base::withCallingHandlers({
  [21:15:34.876]             ...future.value <- base::withVisible(base::local({
  [21:15:34.876]                 sample(x, size = 1L)
  [21:15:34.876]             }))
  [21:15:34.876]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.876]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.876]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.876]                 version = "1.8")
  [21:15:34.876]         }, condition = base::local({
  [21:15:34.876]             c <- base::c
  [21:15:34.876]             inherits <- base::inherits
  [21:15:34.876]             invokeRestart <- base::invokeRestart
  [21:15:34.876]             length <- base::length
  [21:15:34.876]             list <- base::list
  [21:15:34.876]             seq.int <- base::seq.int
  [21:15:34.876]             signalCondition <- base::signalCondition
  [21:15:34.876]             sys.calls <- base::sys.calls
  [21:15:34.876]             Sys.time <- base::Sys.time
  [21:15:34.876]             `[[` <- base::`[[`
  [21:15:34.876]             `+` <- base::`+`
  [21:15:34.876]             `<<-` <- base::`<<-`
  [21:15:34.876]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.876]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.876]                   3L)]
  [21:15:34.876]             }
  [21:15:34.876]             function(cond) {
  [21:15:34.876]                 if (inherits(cond, "error")) {
  [21:15:34.876]                   sessionInformation <- function() {
  [21:15:34.876]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.876]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.876]                       search = base::search(), system = base::Sys.info())
  [21:15:34.876]                   }
  [21:15:34.876]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.876]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.876]                     cond$call), session = sessionInformation(), 
  [21:15:34.876]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.876]                   signalCondition(cond)
  [21:15:34.876]                 }
  [21:15:34.876]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.876]                 ))) {
  [21:15:34.876]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.876]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.876]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.876]                   if (!signal) {
  [21:15:34.876]                     muffleCondition <- function (cond) 
  [21:15:34.876]                     {
  [21:15:34.876]                       inherits <- base::inherits
  [21:15:34.876]                       invokeRestart <- base::invokeRestart
  [21:15:34.876]                       muffled <- FALSE
  [21:15:34.876]                       if (inherits(cond, "message")) {
  [21:15:34.876]                         invokeRestart("muffleMessage")
  [21:15:34.876]                         muffled <- TRUE
  [21:15:34.876]                       }
  [21:15:34.876]                       else if (inherits(cond, "warning")) {
  [21:15:34.876]                         invokeRestart("muffleWarning")
  [21:15:34.876]                         muffled <- TRUE
  [21:15:34.876]                       }
  [21:15:34.876]                       else if (inherits(cond, "condition")) {
  [21:15:34.876]                         computeRestarts <- base::computeRestarts
  [21:15:34.876]                         grepl <- base::grepl
  [21:15:34.876]                         is.null <- base::is.null
  [21:15:34.876]                         restarts <- computeRestarts(cond)
  [21:15:34.876]                         for (restart in restarts) {
  [21:15:34.876]                           name <- restart$name
  [21:15:34.876]                           if (is.null(name)) 
  [21:15:34.876]                             next
  [21:15:34.876]                           if (!grepl("^muffle", name)) 
  [21:15:34.876]                             next
  [21:15:34.876]                           invokeRestart(restart)
  [21:15:34.876]                           muffled <- TRUE
  [21:15:34.876]                           break
  [21:15:34.876]                         }
  [21:15:34.876]                       }
  [21:15:34.876]                       invisible(muffled)
  [21:15:34.876]                     }
  [21:15:34.876]                     muffleCondition(cond)
  [21:15:34.876]                   }
  [21:15:34.876]                 }
  [21:15:34.876]             }
  [21:15:34.876]         }))
  [21:15:34.876]     }, error = function(ex) {
  [21:15:34.876]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.876]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.876]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.876]     }, finally = {
  [21:15:34.876]         {
  [21:15:34.876]             NULL
  [21:15:34.876]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.876]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.876]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.876]                 label = NULL, ...) 
  [21:15:34.876]             {
  [21:15:34.876]                 if (substitute) 
  [21:15:34.876]                   expr <- substitute(expr)
  [21:15:34.876]                 local <- as.logical(local)
  [21:15:34.876]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.876]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.876]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.876]                   label = label, ...)
  [21:15:34.876]                 if (!future$lazy) 
  [21:15:34.876]                   future <- run(future)
  [21:15:34.876]                 invisible(future)
  [21:15:34.876]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.876]         }
  [21:15:34.876]         base::options(...future.oldOptions)
  [21:15:34.876]     })
  [21:15:34.876]     Sys.time
  [21:15:34.876]     if (base::is.na(TRUE)) {
  [21:15:34.876]     }
  [21:15:34.876]     else {
  [21:15:34.876]         base::sink(type = "output", split = FALSE)
  [21:15:34.876]         if (TRUE) {
  [21:15:34.876]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.876]         }
  [21:15:34.876]         else {
  [21:15:34.876]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.876]         }
  [21:15:34.876]         base::close(...future.stdout)
  [21:15:34.876]         ...future.stdout <- NULL
  [21:15:34.876]     }
  [21:15:34.876]     ...future.result$conditions <- ...future.conditions
  [21:15:34.876]     ...future.result
  [21:15:34.876] }
  [21:15:34.880] plan(): Setting new future strategy stack:
  [21:15:34.881] List of future strategies:
  [21:15:34.881] 1. sequential:
  [21:15:34.881]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.881]    - tweaked: FALSE
  [21:15:34.881]    - call: NULL
  [21:15:34.882] plan(): nbrOfWorkers() = 1
  [21:15:34.883] plan(): Setting new future strategy stack:
  [21:15:34.883] List of future strategies:
  [21:15:34.883] 1. sequential:
  [21:15:34.883]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.883]    - tweaked: FALSE
  [21:15:34.883]    - call: plan(strategy)
  [21:15:34.884] plan(): nbrOfWorkers() = 1
  [21:15:34.885] SequentialFuture started (and completed)
  [21:15:34.886] getGlobalsAndPackages() ...
  [21:15:34.886] Searching for globals...
  [21:15:34.888] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.888] Searching for globals ... DONE
  [21:15:34.889] Resolving globals: FALSE
  [21:15:34.889] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.890] - globals: [1] 'x'
  [21:15:34.890] 
  [21:15:34.890] getGlobalsAndPackages() ... DONE
  [21:15:34.892] Packages needed by the future expression (n = 0): <none>
  [21:15:34.892] Packages needed by future strategies (n = 0): <none>
  [21:15:34.896] {
  [21:15:34.896]     {
  [21:15:34.896]         ...future.startTime <- base::Sys.time()
  [21:15:34.896]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.896]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.896]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.896]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.896]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.896]         {
  [21:15:34.896]             {
  [21:15:34.896]                 base::local({
  [21:15:34.896]                   has_future <- base::requireNamespace("future", 
  [21:15:34.896]                     quietly = TRUE)
  [21:15:34.896]                   version <- if (has_future) 
  [21:15:34.896]                     utils::packageVersion("future")
  [21:15:34.896]                   else NULL
  [21:15:34.896]                   if (!has_future || version < "1.8.0") {
  [21:15:34.896]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.896]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.896]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.896]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.896]                         "release", "version")], collapse = " "), 
  [21:15:34.896]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.896]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.896]                       info)
  [21:15:34.896]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.896]                     if (!has_future) {
  [21:15:34.896]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.896]                         info)
  [21:15:34.896]                     }
  [21:15:34.896]                     else {
  [21:15:34.896]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.896]                         info, version)
  [21:15:34.896]                     }
  [21:15:34.896]                     base::stop(msg)
  [21:15:34.896]                   }
  [21:15:34.896]                 })
  [21:15:34.896]             }
  [21:15:34.896]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.896]         }
  [21:15:34.896]     }
  [21:15:34.896]     if (base::is.na(TRUE)) {
  [21:15:34.896]     }
  [21:15:34.896]     else {
  [21:15:34.896]         if (TRUE) {
  [21:15:34.896]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.896]                 open = "w")
  [21:15:34.896]         }
  [21:15:34.896]         else {
  [21:15:34.896]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.896]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.896]         }
  [21:15:34.896]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.896]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.896]             base::sink(type = "output", split = FALSE)
  [21:15:34.896]             base::close(...future.stdout)
  [21:15:34.896]         }, add = TRUE)
  [21:15:34.896]     }
  [21:15:34.896]     ...future.frame <- base::sys.nframe()
  [21:15:34.896]     ...future.conditions <- base::list()
  [21:15:34.896]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.896]     ...future.result <- base::tryCatch({
  [21:15:34.896]         base::withCallingHandlers({
  [21:15:34.896]             ...future.value <- base::withVisible(base::local({
  [21:15:34.896]                 sample(x, size = 1L)
  [21:15:34.896]             }))
  [21:15:34.896]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.896]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.896]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.896]                 version = "1.8")
  [21:15:34.896]         }, condition = base::local({
  [21:15:34.896]             c <- base::c
  [21:15:34.896]             inherits <- base::inherits
  [21:15:34.896]             invokeRestart <- base::invokeRestart
  [21:15:34.896]             length <- base::length
  [21:15:34.896]             list <- base::list
  [21:15:34.896]             seq.int <- base::seq.int
  [21:15:34.896]             signalCondition <- base::signalCondition
  [21:15:34.896]             sys.calls <- base::sys.calls
  [21:15:34.896]             Sys.time <- base::Sys.time
  [21:15:34.896]             `[[` <- base::`[[`
  [21:15:34.896]             `+` <- base::`+`
  [21:15:34.896]             `<<-` <- base::`<<-`
  [21:15:34.896]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.896]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.896]                   3L)]
  [21:15:34.896]             }
  [21:15:34.896]             function(cond) {
  [21:15:34.896]                 if (inherits(cond, "error")) {
  [21:15:34.896]                   sessionInformation <- function() {
  [21:15:34.896]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.896]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.896]                       search = base::search(), system = base::Sys.info())
  [21:15:34.896]                   }
  [21:15:34.896]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.896]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.896]                     cond$call), session = sessionInformation(), 
  [21:15:34.896]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.896]                   signalCondition(cond)
  [21:15:34.896]                 }
  [21:15:34.896]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.896]                 ))) {
  [21:15:34.896]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.896]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.896]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.896]                   if (!signal) {
  [21:15:34.896]                     muffleCondition <- function (cond) 
  [21:15:34.896]                     {
  [21:15:34.896]                       inherits <- base::inherits
  [21:15:34.896]                       invokeRestart <- base::invokeRestart
  [21:15:34.896]                       muffled <- FALSE
  [21:15:34.896]                       if (inherits(cond, "message")) {
  [21:15:34.896]                         invokeRestart("muffleMessage")
  [21:15:34.896]                         muffled <- TRUE
  [21:15:34.896]                       }
  [21:15:34.896]                       else if (inherits(cond, "warning")) {
  [21:15:34.896]                         invokeRestart("muffleWarning")
  [21:15:34.896]                         muffled <- TRUE
  [21:15:34.896]                       }
  [21:15:34.896]                       else if (inherits(cond, "condition")) {
  [21:15:34.896]                         computeRestarts <- base::computeRestarts
  [21:15:34.896]                         grepl <- base::grepl
  [21:15:34.896]                         is.null <- base::is.null
  [21:15:34.896]                         restarts <- computeRestarts(cond)
  [21:15:34.896]                         for (restart in restarts) {
  [21:15:34.896]                           name <- restart$name
  [21:15:34.896]                           if (is.null(name)) 
  [21:15:34.896]                             next
  [21:15:34.896]                           if (!grepl("^muffle", name)) 
  [21:15:34.896]                             next
  [21:15:34.896]                           invokeRestart(restart)
  [21:15:34.896]                           muffled <- TRUE
  [21:15:34.896]                           break
  [21:15:34.896]                         }
  [21:15:34.896]                       }
  [21:15:34.896]                       invisible(muffled)
  [21:15:34.896]                     }
  [21:15:34.896]                     muffleCondition(cond)
  [21:15:34.896]                   }
  [21:15:34.896]                 }
  [21:15:34.896]             }
  [21:15:34.896]         }))
  [21:15:34.896]     }, error = function(ex) {
  [21:15:34.896]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.896]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.896]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.896]     }, finally = {
  [21:15:34.896]         {
  [21:15:34.896]             NULL
  [21:15:34.896]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.896]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.896]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.896]                 label = NULL, ...) 
  [21:15:34.896]             {
  [21:15:34.896]                 if (substitute) 
  [21:15:34.896]                   expr <- substitute(expr)
  [21:15:34.896]                 local <- as.logical(local)
  [21:15:34.896]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.896]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.896]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.896]                   label = label, ...)
  [21:15:34.896]                 if (!future$lazy) 
  [21:15:34.896]                   future <- run(future)
  [21:15:34.896]                 invisible(future)
  [21:15:34.896]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.896]         }
  [21:15:34.896]         base::options(...future.oldOptions)
  [21:15:34.896]     })
  [21:15:34.896]     Sys.time
  [21:15:34.896]     if (base::is.na(TRUE)) {
  [21:15:34.896]     }
  [21:15:34.896]     else {
  [21:15:34.896]         base::sink(type = "output", split = FALSE)
  [21:15:34.896]         if (TRUE) {
  [21:15:34.896]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.896]         }
  [21:15:34.896]         else {
  [21:15:34.896]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.896]         }
  [21:15:34.896]         base::close(...future.stdout)
  [21:15:34.896]         ...future.stdout <- NULL
  [21:15:34.896]     }
  [21:15:34.896]     ...future.result$conditions <- ...future.conditions
  [21:15:34.896]     ...future.result
  [21:15:34.896] }
  [21:15:34.901] plan(): Setting new future strategy stack:
  [21:15:34.901] List of future strategies:
  [21:15:34.901] 1. sequential:
  [21:15:34.901]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.901]    - tweaked: FALSE
  [21:15:34.901]    - call: NULL
  [21:15:34.902] plan(): nbrOfWorkers() = 1
  [21:15:34.906] plan(): Setting new future strategy stack:
  [21:15:34.907] List of future strategies:
  [21:15:34.907] 1. sequential:
  [21:15:34.907]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.907]    - tweaked: FALSE
  [21:15:34.907]    - call: plan(strategy)
  [21:15:34.908] plan(): nbrOfWorkers() = 1
  [21:15:34.908] SequentialFuture started (and completed)
  [21:15:34.910] getGlobalsAndPackages() ...
  [21:15:34.910] Searching for globals...
  [21:15:34.912] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.913] Searching for globals ... DONE
  [21:15:34.913] Resolving globals: FALSE
  [21:15:34.914] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.914] - globals: [1] 'x'
  [21:15:34.915] 
  [21:15:34.915] getGlobalsAndPackages() ... DONE
  [21:15:34.917] Packages needed by the future expression (n = 0): <none>
  [21:15:34.917] Packages needed by future strategies (n = 0): <none>
  [21:15:34.921] {
  [21:15:34.921]     {
  [21:15:34.921]         ...future.startTime <- base::Sys.time()
  [21:15:34.921]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.921]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.921]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.921]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.921]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.921]         {
  [21:15:34.921]             {
  [21:15:34.921]                 base::local({
  [21:15:34.921]                   has_future <- base::requireNamespace("future", 
  [21:15:34.921]                     quietly = TRUE)
  [21:15:34.921]                   version <- if (has_future) 
  [21:15:34.921]                     utils::packageVersion("future")
  [21:15:34.921]                   else NULL
  [21:15:34.921]                   if (!has_future || version < "1.8.0") {
  [21:15:34.921]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.921]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.921]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.921]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.921]                         "release", "version")], collapse = " "), 
  [21:15:34.921]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.921]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.921]                       info)
  [21:15:34.921]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.921]                     if (!has_future) {
  [21:15:34.921]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.921]                         info)
  [21:15:34.921]                     }
  [21:15:34.921]                     else {
  [21:15:34.921]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.921]                         info, version)
  [21:15:34.921]                     }
  [21:15:34.921]                     base::stop(msg)
  [21:15:34.921]                   }
  [21:15:34.921]                 })
  [21:15:34.921]             }
  [21:15:34.921]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.921]         }
  [21:15:34.921]     }
  [21:15:34.921]     if (base::is.na(TRUE)) {
  [21:15:34.921]     }
  [21:15:34.921]     else {
  [21:15:34.921]         if (TRUE) {
  [21:15:34.921]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.921]                 open = "w")
  [21:15:34.921]         }
  [21:15:34.921]         else {
  [21:15:34.921]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.921]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.921]         }
  [21:15:34.921]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.921]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.921]             base::sink(type = "output", split = FALSE)
  [21:15:34.921]             base::close(...future.stdout)
  [21:15:34.921]         }, add = TRUE)
  [21:15:34.921]     }
  [21:15:34.921]     ...future.frame <- base::sys.nframe()
  [21:15:34.921]     ...future.conditions <- base::list()
  [21:15:34.921]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.921]     ...future.result <- base::tryCatch({
  [21:15:34.921]         base::withCallingHandlers({
  [21:15:34.921]             ...future.value <- base::withVisible(base::local({
  [21:15:34.921]                 sample(x, size = 1L)
  [21:15:34.921]             }))
  [21:15:34.921]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.921]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.921]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.921]                 version = "1.8")
  [21:15:34.921]         }, condition = base::local({
  [21:15:34.921]             c <- base::c
  [21:15:34.921]             inherits <- base::inherits
  [21:15:34.921]             invokeRestart <- base::invokeRestart
  [21:15:34.921]             length <- base::length
  [21:15:34.921]             list <- base::list
  [21:15:34.921]             seq.int <- base::seq.int
  [21:15:34.921]             signalCondition <- base::signalCondition
  [21:15:34.921]             sys.calls <- base::sys.calls
  [21:15:34.921]             Sys.time <- base::Sys.time
  [21:15:34.921]             `[[` <- base::`[[`
  [21:15:34.921]             `+` <- base::`+`
  [21:15:34.921]             `<<-` <- base::`<<-`
  [21:15:34.921]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.921]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.921]                   3L)]
  [21:15:34.921]             }
  [21:15:34.921]             function(cond) {
  [21:15:34.921]                 if (inherits(cond, "error")) {
  [21:15:34.921]                   sessionInformation <- function() {
  [21:15:34.921]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.921]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.921]                       search = base::search(), system = base::Sys.info())
  [21:15:34.921]                   }
  [21:15:34.921]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.921]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.921]                     cond$call), session = sessionInformation(), 
  [21:15:34.921]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.921]                   signalCondition(cond)
  [21:15:34.921]                 }
  [21:15:34.921]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.921]                 ))) {
  [21:15:34.921]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.921]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.921]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.921]                   if (!signal) {
  [21:15:34.921]                     muffleCondition <- function (cond) 
  [21:15:34.921]                     {
  [21:15:34.921]                       inherits <- base::inherits
  [21:15:34.921]                       invokeRestart <- base::invokeRestart
  [21:15:34.921]                       muffled <- FALSE
  [21:15:34.921]                       if (inherits(cond, "message")) {
  [21:15:34.921]                         invokeRestart("muffleMessage")
  [21:15:34.921]                         muffled <- TRUE
  [21:15:34.921]                       }
  [21:15:34.921]                       else if (inherits(cond, "warning")) {
  [21:15:34.921]                         invokeRestart("muffleWarning")
  [21:15:34.921]                         muffled <- TRUE
  [21:15:34.921]                       }
  [21:15:34.921]                       else if (inherits(cond, "condition")) {
  [21:15:34.921]                         computeRestarts <- base::computeRestarts
  [21:15:34.921]                         grepl <- base::grepl
  [21:15:34.921]                         is.null <- base::is.null
  [21:15:34.921]                         restarts <- computeRestarts(cond)
  [21:15:34.921]                         for (restart in restarts) {
  [21:15:34.921]                           name <- restart$name
  [21:15:34.921]                           if (is.null(name)) 
  [21:15:34.921]                             next
  [21:15:34.921]                           if (!grepl("^muffle", name)) 
  [21:15:34.921]                             next
  [21:15:34.921]                           invokeRestart(restart)
  [21:15:34.921]                           muffled <- TRUE
  [21:15:34.921]                           break
  [21:15:34.921]                         }
  [21:15:34.921]                       }
  [21:15:34.921]                       invisible(muffled)
  [21:15:34.921]                     }
  [21:15:34.921]                     muffleCondition(cond)
  [21:15:34.921]                   }
  [21:15:34.921]                 }
  [21:15:34.921]             }
  [21:15:34.921]         }))
  [21:15:34.921]     }, error = function(ex) {
  [21:15:34.921]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.921]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.921]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.921]     }, finally = {
  [21:15:34.921]         {
  [21:15:34.921]             NULL
  [21:15:34.921]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.921]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.921]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.921]                 label = NULL, ...) 
  [21:15:34.921]             {
  [21:15:34.921]                 if (substitute) 
  [21:15:34.921]                   expr <- substitute(expr)
  [21:15:34.921]                 local <- as.logical(local)
  [21:15:34.921]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.921]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.921]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.921]                   label = label, ...)
  [21:15:34.921]                 if (!future$lazy) 
  [21:15:34.921]                   future <- run(future)
  [21:15:34.921]                 invisible(future)
  [21:15:34.921]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.921]         }
  [21:15:34.921]         base::options(...future.oldOptions)
  [21:15:34.921]     })
  [21:15:34.921]     Sys.time
  [21:15:34.921]     if (base::is.na(TRUE)) {
  [21:15:34.921]     }
  [21:15:34.921]     else {
  [21:15:34.921]         base::sink(type = "output", split = FALSE)
  [21:15:34.921]         if (TRUE) {
  [21:15:34.921]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.921]         }
  [21:15:34.921]         else {
  [21:15:34.921]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.921]         }
  [21:15:34.921]         base::close(...future.stdout)
  [21:15:34.921]         ...future.stdout <- NULL
  [21:15:34.921]     }
  [21:15:34.921]     ...future.result$conditions <- ...future.conditions
  [21:15:34.921]     ...future.result
  [21:15:34.921] }
  [21:15:34.926] plan(): Setting new future strategy stack:
  [21:15:34.926] List of future strategies:
  [21:15:34.926] 1. sequential:
  [21:15:34.926]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.926]    - tweaked: FALSE
  [21:15:34.926]    - call: NULL
  [21:15:34.927] plan(): nbrOfWorkers() = 1
  [21:15:34.928] plan(): Setting new future strategy stack:
  [21:15:34.929] List of future strategies:
  [21:15:34.929] 1. sequential:
  [21:15:34.929]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.929]    - tweaked: FALSE
  [21:15:34.929]    - call: plan(strategy)
  [21:15:34.930] plan(): nbrOfWorkers() = 1
  [21:15:34.930] SequentialFuture started (and completed)
  [[1]]
  [1] 2
  
  [[2]]
  [1] 3
  
  [[3]]
  [1] 1
  
  [[4]]
  [1] 0
  
  [21:15:34.932] getGlobalsAndPackages() ...
  [21:15:34.933] Searching for globals...
  [21:15:34.935] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.935] Searching for globals ... DONE
  [21:15:34.936] Resolving globals: FALSE
  [21:15:34.937] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.937] - globals: [1] 'x'
  [21:15:34.938] 
  [21:15:34.938] getGlobalsAndPackages() ... DONE
  [21:15:34.940] Packages needed by the future expression (n = 0): <none>
  [21:15:34.940] Packages needed by future strategies (n = 0): <none>
  [21:15:34.944] {
  [21:15:34.944]     {
  [21:15:34.944]         ...future.startTime <- base::Sys.time()
  [21:15:34.944]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.944]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.944]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.944]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.944]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.944]         {
  [21:15:34.944]             {
  [21:15:34.944]                 base::local({
  [21:15:34.944]                   has_future <- base::requireNamespace("future", 
  [21:15:34.944]                     quietly = TRUE)
  [21:15:34.944]                   version <- if (has_future) 
  [21:15:34.944]                     utils::packageVersion("future")
  [21:15:34.944]                   else NULL
  [21:15:34.944]                   if (!has_future || version < "1.8.0") {
  [21:15:34.944]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.944]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.944]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.944]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.944]                         "release", "version")], collapse = " "), 
  [21:15:34.944]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.944]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.944]                       info)
  [21:15:34.944]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.944]                     if (!has_future) {
  [21:15:34.944]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.944]                         info)
  [21:15:34.944]                     }
  [21:15:34.944]                     else {
  [21:15:34.944]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.944]                         info, version)
  [21:15:34.944]                     }
  [21:15:34.944]                     base::stop(msg)
  [21:15:34.944]                   }
  [21:15:34.944]                 })
  [21:15:34.944]             }
  [21:15:34.944]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.944]         }
  [21:15:34.944]     }
  [21:15:34.944]     if (base::is.na(TRUE)) {
  [21:15:34.944]     }
  [21:15:34.944]     else {
  [21:15:34.944]         if (TRUE) {
  [21:15:34.944]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.944]                 open = "w")
  [21:15:34.944]         }
  [21:15:34.944]         else {
  [21:15:34.944]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.944]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.944]         }
  [21:15:34.944]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.944]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.944]             base::sink(type = "output", split = FALSE)
  [21:15:34.944]             base::close(...future.stdout)
  [21:15:34.944]         }, add = TRUE)
  [21:15:34.944]     }
  [21:15:34.944]     ...future.frame <- base::sys.nframe()
  [21:15:34.944]     ...future.conditions <- base::list()
  [21:15:34.944]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.944]     ...future.result <- base::tryCatch({
  [21:15:34.944]         base::withCallingHandlers({
  [21:15:34.944]             ...future.value <- base::withVisible(base::local({
  [21:15:34.944]                 sample(x, size = 1L)
  [21:15:34.944]             }))
  [21:15:34.944]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.944]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.944]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.944]                 version = "1.8")
  [21:15:34.944]         }, condition = base::local({
  [21:15:34.944]             c <- base::c
  [21:15:34.944]             inherits <- base::inherits
  [21:15:34.944]             invokeRestart <- base::invokeRestart
  [21:15:34.944]             length <- base::length
  [21:15:34.944]             list <- base::list
  [21:15:34.944]             seq.int <- base::seq.int
  [21:15:34.944]             signalCondition <- base::signalCondition
  [21:15:34.944]             sys.calls <- base::sys.calls
  [21:15:34.944]             Sys.time <- base::Sys.time
  [21:15:34.944]             `[[` <- base::`[[`
  [21:15:34.944]             `+` <- base::`+`
  [21:15:34.944]             `<<-` <- base::`<<-`
  [21:15:34.944]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.944]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.944]                   3L)]
  [21:15:34.944]             }
  [21:15:34.944]             function(cond) {
  [21:15:34.944]                 if (inherits(cond, "error")) {
  [21:15:34.944]                   sessionInformation <- function() {
  [21:15:34.944]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.944]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.944]                       search = base::search(), system = base::Sys.info())
  [21:15:34.944]                   }
  [21:15:34.944]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.944]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.944]                     cond$call), session = sessionInformation(), 
  [21:15:34.944]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.944]                   signalCondition(cond)
  [21:15:34.944]                 }
  [21:15:34.944]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.944]                 ))) {
  [21:15:34.944]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.944]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.944]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.944]                   if (!signal) {
  [21:15:34.944]                     muffleCondition <- function (cond) 
  [21:15:34.944]                     {
  [21:15:34.944]                       inherits <- base::inherits
  [21:15:34.944]                       invokeRestart <- base::invokeRestart
  [21:15:34.944]                       muffled <- FALSE
  [21:15:34.944]                       if (inherits(cond, "message")) {
  [21:15:34.944]                         invokeRestart("muffleMessage")
  [21:15:34.944]                         muffled <- TRUE
  [21:15:34.944]                       }
  [21:15:34.944]                       else if (inherits(cond, "warning")) {
  [21:15:34.944]                         invokeRestart("muffleWarning")
  [21:15:34.944]                         muffled <- TRUE
  [21:15:34.944]                       }
  [21:15:34.944]                       else if (inherits(cond, "condition")) {
  [21:15:34.944]                         computeRestarts <- base::computeRestarts
  [21:15:34.944]                         grepl <- base::grepl
  [21:15:34.944]                         is.null <- base::is.null
  [21:15:34.944]                         restarts <- computeRestarts(cond)
  [21:15:34.944]                         for (restart in restarts) {
  [21:15:34.944]                           name <- restart$name
  [21:15:34.944]                           if (is.null(name)) 
  [21:15:34.944]                             next
  [21:15:34.944]                           if (!grepl("^muffle", name)) 
  [21:15:34.944]                             next
  [21:15:34.944]                           invokeRestart(restart)
  [21:15:34.944]                           muffled <- TRUE
  [21:15:34.944]                           break
  [21:15:34.944]                         }
  [21:15:34.944]                       }
  [21:15:34.944]                       invisible(muffled)
  [21:15:34.944]                     }
  [21:15:34.944]                     muffleCondition(cond)
  [21:15:34.944]                   }
  [21:15:34.944]                 }
  [21:15:34.944]             }
  [21:15:34.944]         }))
  [21:15:34.944]     }, error = function(ex) {
  [21:15:34.944]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.944]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.944]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.944]     }, finally = {
  [21:15:34.944]         {
  [21:15:34.944]             NULL
  [21:15:34.944]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.944]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.944]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.944]                 label = NULL, ...) 
  [21:15:34.944]             {
  [21:15:34.944]                 if (substitute) 
  [21:15:34.944]                   expr <- substitute(expr)
  [21:15:34.944]                 local <- as.logical(local)
  [21:15:34.944]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.944]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.944]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.944]                   label = label, ...)
  [21:15:34.944]                 if (!future$lazy) 
  [21:15:34.944]                   future <- run(future)
  [21:15:34.944]                 invisible(future)
  [21:15:34.944]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.944]         }
  [21:15:34.944]         base::options(...future.oldOptions)
  [21:15:34.944]     })
  [21:15:34.944]     Sys.time
  [21:15:34.944]     if (base::is.na(TRUE)) {
  [21:15:34.944]     }
  [21:15:34.944]     else {
  [21:15:34.944]         base::sink(type = "output", split = FALSE)
  [21:15:34.944]         if (TRUE) {
  [21:15:34.944]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.944]         }
  [21:15:34.944]         else {
  [21:15:34.944]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.944]         }
  [21:15:34.944]         base::close(...future.stdout)
  [21:15:34.944]         ...future.stdout <- NULL
  [21:15:34.944]     }
  [21:15:34.944]     ...future.result$conditions <- ...future.conditions
  [21:15:34.944]     ...future.result
  [21:15:34.944] }
  [21:15:34.948] plan(): Setting new future strategy stack:
  [21:15:34.949] List of future strategies:
  [21:15:34.949] 1. sequential:
  [21:15:34.949]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.949]    - tweaked: FALSE
  [21:15:34.949]    - call: NULL
  [21:15:34.950] plan(): nbrOfWorkers() = 1
  [21:15:34.951] plan(): Setting new future strategy stack:
  [21:15:34.951] List of future strategies:
  [21:15:34.951] 1. sequential:
  [21:15:34.951]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.951]    - tweaked: FALSE
  [21:15:34.951]    - call: plan(strategy)
  [21:15:34.952] plan(): nbrOfWorkers() = 1
  [21:15:34.953] SequentialFuture started (and completed)
  [21:15:34.954] getGlobalsAndPackages() ...
  [21:15:34.954] Searching for globals...
  [21:15:34.956] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.957] Searching for globals ... DONE
  [21:15:34.957] Resolving globals: FALSE
  [21:15:34.958] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.958] - globals: [1] 'x'
  [21:15:34.959] 
  [21:15:34.959] getGlobalsAndPackages() ... DONE
  [21:15:34.961] Packages needed by the future expression (n = 0): <none>
  [21:15:34.961] Packages needed by future strategies (n = 0): <none>
  [21:15:34.965] {
  [21:15:34.965]     {
  [21:15:34.965]         ...future.startTime <- base::Sys.time()
  [21:15:34.965]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.965]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.965]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.965]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.965]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.965]         {
  [21:15:34.965]             {
  [21:15:34.965]                 base::local({
  [21:15:34.965]                   has_future <- base::requireNamespace("future", 
  [21:15:34.965]                     quietly = TRUE)
  [21:15:34.965]                   version <- if (has_future) 
  [21:15:34.965]                     utils::packageVersion("future")
  [21:15:34.965]                   else NULL
  [21:15:34.965]                   if (!has_future || version < "1.8.0") {
  [21:15:34.965]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.965]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.965]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.965]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.965]                         "release", "version")], collapse = " "), 
  [21:15:34.965]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.965]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.965]                       info)
  [21:15:34.965]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.965]                     if (!has_future) {
  [21:15:34.965]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.965]                         info)
  [21:15:34.965]                     }
  [21:15:34.965]                     else {
  [21:15:34.965]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.965]                         info, version)
  [21:15:34.965]                     }
  [21:15:34.965]                     base::stop(msg)
  [21:15:34.965]                   }
  [21:15:34.965]                 })
  [21:15:34.965]             }
  [21:15:34.965]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.965]         }
  [21:15:34.965]     }
  [21:15:34.965]     if (base::is.na(TRUE)) {
  [21:15:34.965]     }
  [21:15:34.965]     else {
  [21:15:34.965]         if (TRUE) {
  [21:15:34.965]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.965]                 open = "w")
  [21:15:34.965]         }
  [21:15:34.965]         else {
  [21:15:34.965]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.965]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.965]         }
  [21:15:34.965]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.965]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.965]             base::sink(type = "output", split = FALSE)
  [21:15:34.965]             base::close(...future.stdout)
  [21:15:34.965]         }, add = TRUE)
  [21:15:34.965]     }
  [21:15:34.965]     ...future.frame <- base::sys.nframe()
  [21:15:34.965]     ...future.conditions <- base::list()
  [21:15:34.965]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.965]     ...future.result <- base::tryCatch({
  [21:15:34.965]         base::withCallingHandlers({
  [21:15:34.965]             ...future.value <- base::withVisible(base::local({
  [21:15:34.965]                 sample(x, size = 1L)
  [21:15:34.965]             }))
  [21:15:34.965]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.965]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.965]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.965]                 version = "1.8")
  [21:15:34.965]         }, condition = base::local({
  [21:15:34.965]             c <- base::c
  [21:15:34.965]             inherits <- base::inherits
  [21:15:34.965]             invokeRestart <- base::invokeRestart
  [21:15:34.965]             length <- base::length
  [21:15:34.965]             list <- base::list
  [21:15:34.965]             seq.int <- base::seq.int
  [21:15:34.965]             signalCondition <- base::signalCondition
  [21:15:34.965]             sys.calls <- base::sys.calls
  [21:15:34.965]             Sys.time <- base::Sys.time
  [21:15:34.965]             `[[` <- base::`[[`
  [21:15:34.965]             `+` <- base::`+`
  [21:15:34.965]             `<<-` <- base::`<<-`
  [21:15:34.965]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.965]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.965]                   3L)]
  [21:15:34.965]             }
  [21:15:34.965]             function(cond) {
  [21:15:34.965]                 if (inherits(cond, "error")) {
  [21:15:34.965]                   sessionInformation <- function() {
  [21:15:34.965]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.965]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.965]                       search = base::search(), system = base::Sys.info())
  [21:15:34.965]                   }
  [21:15:34.965]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.965]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.965]                     cond$call), session = sessionInformation(), 
  [21:15:34.965]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.965]                   signalCondition(cond)
  [21:15:34.965]                 }
  [21:15:34.965]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.965]                 ))) {
  [21:15:34.965]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.965]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.965]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.965]                   if (!signal) {
  [21:15:34.965]                     muffleCondition <- function (cond) 
  [21:15:34.965]                     {
  [21:15:34.965]                       inherits <- base::inherits
  [21:15:34.965]                       invokeRestart <- base::invokeRestart
  [21:15:34.965]                       muffled <- FALSE
  [21:15:34.965]                       if (inherits(cond, "message")) {
  [21:15:34.965]                         invokeRestart("muffleMessage")
  [21:15:34.965]                         muffled <- TRUE
  [21:15:34.965]                       }
  [21:15:34.965]                       else if (inherits(cond, "warning")) {
  [21:15:34.965]                         invokeRestart("muffleWarning")
  [21:15:34.965]                         muffled <- TRUE
  [21:15:34.965]                       }
  [21:15:34.965]                       else if (inherits(cond, "condition")) {
  [21:15:34.965]                         computeRestarts <- base::computeRestarts
  [21:15:34.965]                         grepl <- base::grepl
  [21:15:34.965]                         is.null <- base::is.null
  [21:15:34.965]                         restarts <- computeRestarts(cond)
  [21:15:34.965]                         for (restart in restarts) {
  [21:15:34.965]                           name <- restart$name
  [21:15:34.965]                           if (is.null(name)) 
  [21:15:34.965]                             next
  [21:15:34.965]                           if (!grepl("^muffle", name)) 
  [21:15:34.965]                             next
  [21:15:34.965]                           invokeRestart(restart)
  [21:15:34.965]                           muffled <- TRUE
  [21:15:34.965]                           break
  [21:15:34.965]                         }
  [21:15:34.965]                       }
  [21:15:34.965]                       invisible(muffled)
  [21:15:34.965]                     }
  [21:15:34.965]                     muffleCondition(cond)
  [21:15:34.965]                   }
  [21:15:34.965]                 }
  [21:15:34.965]             }
  [21:15:34.965]         }))
  [21:15:34.965]     }, error = function(ex) {
  [21:15:34.965]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.965]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.965]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.965]     }, finally = {
  [21:15:34.965]         {
  [21:15:34.965]             NULL
  [21:15:34.965]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.965]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.965]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.965]                 label = NULL, ...) 
  [21:15:34.965]             {
  [21:15:34.965]                 if (substitute) 
  [21:15:34.965]                   expr <- substitute(expr)
  [21:15:34.965]                 local <- as.logical(local)
  [21:15:34.965]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.965]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.965]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.965]                   label = label, ...)
  [21:15:34.965]                 if (!future$lazy) 
  [21:15:34.965]                   future <- run(future)
  [21:15:34.965]                 invisible(future)
  [21:15:34.965]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.965]         }
  [21:15:34.965]         base::options(...future.oldOptions)
  [21:15:34.965]     })
  [21:15:34.965]     Sys.time
  [21:15:34.965]     if (base::is.na(TRUE)) {
  [21:15:34.965]     }
  [21:15:34.965]     else {
  [21:15:34.965]         base::sink(type = "output", split = FALSE)
  [21:15:34.965]         if (TRUE) {
  [21:15:34.965]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.965]         }
  [21:15:34.965]         else {
  [21:15:34.965]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.965]         }
  [21:15:34.965]         base::close(...future.stdout)
  [21:15:34.965]         ...future.stdout <- NULL
  [21:15:34.965]     }
  [21:15:34.965]     ...future.result$conditions <- ...future.conditions
  [21:15:34.965]     ...future.result
  [21:15:34.965] }
  [21:15:34.970] plan(): Setting new future strategy stack:
  [21:15:34.970] List of future strategies:
  [21:15:34.970] 1. sequential:
  [21:15:34.970]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.970]    - tweaked: FALSE
  [21:15:34.970]    - call: NULL
  [21:15:34.971] plan(): nbrOfWorkers() = 1
  [21:15:34.973] plan(): Setting new future strategy stack:
  [21:15:34.973] List of future strategies:
  [21:15:34.973] 1. sequential:
  [21:15:34.973]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.973]    - tweaked: FALSE
  [21:15:34.973]    - call: plan(strategy)
  [21:15:34.974] plan(): nbrOfWorkers() = 1
  [21:15:34.974] SequentialFuture started (and completed)
  [21:15:34.976] getGlobalsAndPackages() ...
  [21:15:34.976] Searching for globals...
  [21:15:34.981] - globals found: [3] '{', 'sample', 'x'
  [21:15:34.982] Searching for globals ... DONE
  [21:15:34.983] Resolving globals: FALSE
  [21:15:34.984] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:34.984] - globals: [1] 'x'
  [21:15:34.985] 
  [21:15:34.985] getGlobalsAndPackages() ... DONE
  [21:15:34.987] Packages needed by the future expression (n = 0): <none>
  [21:15:34.987] Packages needed by future strategies (n = 0): <none>
  [21:15:34.991] {
  [21:15:34.991]     {
  [21:15:34.991]         ...future.startTime <- base::Sys.time()
  [21:15:34.991]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:34.991]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:34.991]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:34.991]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:34.991]             future.resolve.recursive = NULL, width = 80L)
  [21:15:34.991]         {
  [21:15:34.991]             {
  [21:15:34.991]                 base::local({
  [21:15:34.991]                   has_future <- base::requireNamespace("future", 
  [21:15:34.991]                     quietly = TRUE)
  [21:15:34.991]                   version <- if (has_future) 
  [21:15:34.991]                     utils::packageVersion("future")
  [21:15:34.991]                   else NULL
  [21:15:34.991]                   if (!has_future || version < "1.8.0") {
  [21:15:34.991]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:34.991]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:34.991]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:34.991]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:34.991]                         "release", "version")], collapse = " "), 
  [21:15:34.991]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:34.991]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:34.991]                       info)
  [21:15:34.991]                     info <- base::paste(info, collapse = "; ")
  [21:15:34.991]                     if (!has_future) {
  [21:15:34.991]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:34.991]                         info)
  [21:15:34.991]                     }
  [21:15:34.991]                     else {
  [21:15:34.991]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:34.991]                         info, version)
  [21:15:34.991]                     }
  [21:15:34.991]                     base::stop(msg)
  [21:15:34.991]                   }
  [21:15:34.991]                 })
  [21:15:34.991]             }
  [21:15:34.991]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:34.991]         }
  [21:15:34.991]     }
  [21:15:34.991]     if (base::is.na(TRUE)) {
  [21:15:34.991]     }
  [21:15:34.991]     else {
  [21:15:34.991]         if (TRUE) {
  [21:15:34.991]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:34.991]                 open = "w")
  [21:15:34.991]         }
  [21:15:34.991]         else {
  [21:15:34.991]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:34.991]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:34.991]         }
  [21:15:34.991]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:34.991]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:34.991]             base::sink(type = "output", split = FALSE)
  [21:15:34.991]             base::close(...future.stdout)
  [21:15:34.991]         }, add = TRUE)
  [21:15:34.991]     }
  [21:15:34.991]     ...future.frame <- base::sys.nframe()
  [21:15:34.991]     ...future.conditions <- base::list()
  [21:15:34.991]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:34.991]     ...future.result <- base::tryCatch({
  [21:15:34.991]         base::withCallingHandlers({
  [21:15:34.991]             ...future.value <- base::withVisible(base::local({
  [21:15:34.991]                 sample(x, size = 1L)
  [21:15:34.991]             }))
  [21:15:34.991]             future::FutureResult(value = ...future.value$value, 
  [21:15:34.991]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.991]                   ...future.rng), started = ...future.startTime, 
  [21:15:34.991]                 version = "1.8")
  [21:15:34.991]         }, condition = base::local({
  [21:15:34.991]             c <- base::c
  [21:15:34.991]             inherits <- base::inherits
  [21:15:34.991]             invokeRestart <- base::invokeRestart
  [21:15:34.991]             length <- base::length
  [21:15:34.991]             list <- base::list
  [21:15:34.991]             seq.int <- base::seq.int
  [21:15:34.991]             signalCondition <- base::signalCondition
  [21:15:34.991]             sys.calls <- base::sys.calls
  [21:15:34.991]             Sys.time <- base::Sys.time
  [21:15:34.991]             `[[` <- base::`[[`
  [21:15:34.991]             `+` <- base::`+`
  [21:15:34.991]             `<<-` <- base::`<<-`
  [21:15:34.991]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:34.991]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:34.991]                   3L)]
  [21:15:34.991]             }
  [21:15:34.991]             function(cond) {
  [21:15:34.991]                 if (inherits(cond, "error")) {
  [21:15:34.991]                   sessionInformation <- function() {
  [21:15:34.991]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:34.991]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:34.991]                       search = base::search(), system = base::Sys.info())
  [21:15:34.991]                   }
  [21:15:34.991]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.991]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:34.991]                     cond$call), session = sessionInformation(), 
  [21:15:34.991]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:34.991]                   signalCondition(cond)
  [21:15:34.991]                 }
  [21:15:34.991]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:34.991]                 ))) {
  [21:15:34.991]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:34.991]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:34.991]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:34.991]                   if (!signal) {
  [21:15:34.991]                     muffleCondition <- function (cond) 
  [21:15:34.991]                     {
  [21:15:34.991]                       inherits <- base::inherits
  [21:15:34.991]                       invokeRestart <- base::invokeRestart
  [21:15:34.991]                       muffled <- FALSE
  [21:15:34.991]                       if (inherits(cond, "message")) {
  [21:15:34.991]                         invokeRestart("muffleMessage")
  [21:15:34.991]                         muffled <- TRUE
  [21:15:34.991]                       }
  [21:15:34.991]                       else if (inherits(cond, "warning")) {
  [21:15:34.991]                         invokeRestart("muffleWarning")
  [21:15:34.991]                         muffled <- TRUE
  [21:15:34.991]                       }
  [21:15:34.991]                       else if (inherits(cond, "condition")) {
  [21:15:34.991]                         computeRestarts <- base::computeRestarts
  [21:15:34.991]                         grepl <- base::grepl
  [21:15:34.991]                         is.null <- base::is.null
  [21:15:34.991]                         restarts <- computeRestarts(cond)
  [21:15:34.991]                         for (restart in restarts) {
  [21:15:34.991]                           name <- restart$name
  [21:15:34.991]                           if (is.null(name)) 
  [21:15:34.991]                             next
  [21:15:34.991]                           if (!grepl("^muffle", name)) 
  [21:15:34.991]                             next
  [21:15:34.991]                           invokeRestart(restart)
  [21:15:34.991]                           muffled <- TRUE
  [21:15:34.991]                           break
  [21:15:34.991]                         }
  [21:15:34.991]                       }
  [21:15:34.991]                       invisible(muffled)
  [21:15:34.991]                     }
  [21:15:34.991]                     muffleCondition(cond)
  [21:15:34.991]                   }
  [21:15:34.991]                 }
  [21:15:34.991]             }
  [21:15:34.991]         }))
  [21:15:34.991]     }, error = function(ex) {
  [21:15:34.991]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:34.991]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:34.991]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:34.991]     }, finally = {
  [21:15:34.991]         {
  [21:15:34.991]             NULL
  [21:15:34.991]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:34.991]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:34.991]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:34.991]                 label = NULL, ...) 
  [21:15:34.991]             {
  [21:15:34.991]                 if (substitute) 
  [21:15:34.991]                   expr <- substitute(expr)
  [21:15:34.991]                 local <- as.logical(local)
  [21:15:34.991]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:34.991]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:34.991]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:34.991]                   label = label, ...)
  [21:15:34.991]                 if (!future$lazy) 
  [21:15:34.991]                   future <- run(future)
  [21:15:34.991]                 invisible(future)
  [21:15:34.991]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:34.991]         }
  [21:15:34.991]         base::options(...future.oldOptions)
  [21:15:34.991]     })
  [21:15:34.991]     Sys.time
  [21:15:34.991]     if (base::is.na(TRUE)) {
  [21:15:34.991]     }
  [21:15:34.991]     else {
  [21:15:34.991]         base::sink(type = "output", split = FALSE)
  [21:15:34.991]         if (TRUE) {
  [21:15:34.991]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:34.991]         }
  [21:15:34.991]         else {
  [21:15:34.991]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:34.991]         }
  [21:15:34.991]         base::close(...future.stdout)
  [21:15:34.991]         ...future.stdout <- NULL
  [21:15:34.991]     }
  [21:15:34.991]     ...future.result$conditions <- ...future.conditions
  [21:15:34.991]     ...future.result
  [21:15:34.991] }
  [21:15:34.995] plan(): Setting new future strategy stack:
  [21:15:34.996] List of future strategies:
  [21:15:34.996] 1. sequential:
  [21:15:34.996]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.996]    - tweaked: FALSE
  [21:15:34.996]    - call: NULL
  [21:15:34.996] plan(): nbrOfWorkers() = 1
  [21:15:34.997] plan(): Setting new future strategy stack:
  [21:15:34.998] List of future strategies:
  [21:15:34.998] 1. sequential:
  [21:15:34.998]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:34.998]    - tweaked: FALSE
  [21:15:34.998]    - call: plan(strategy)
  [21:15:34.999] plan(): nbrOfWorkers() = 1
  [21:15:34.999] SequentialFuture started (and completed)
  [21:15:35.000] getGlobalsAndPackages() ...
  [21:15:35.001] Searching for globals...
  [21:15:35.003] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.003] Searching for globals ... DONE
  [21:15:35.003] Resolving globals: FALSE
  [21:15:35.004] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.004] - globals: [1] 'x'
  [21:15:35.005] 
  [21:15:35.005] getGlobalsAndPackages() ... DONE
  [21:15:35.007] Packages needed by the future expression (n = 0): <none>
  [21:15:35.007] Packages needed by future strategies (n = 0): <none>
  [21:15:35.011] {
  [21:15:35.011]     {
  [21:15:35.011]         ...future.startTime <- base::Sys.time()
  [21:15:35.011]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.011]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.011]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.011]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.011]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.011]         {
  [21:15:35.011]             {
  [21:15:35.011]                 base::local({
  [21:15:35.011]                   has_future <- base::requireNamespace("future", 
  [21:15:35.011]                     quietly = TRUE)
  [21:15:35.011]                   version <- if (has_future) 
  [21:15:35.011]                     utils::packageVersion("future")
  [21:15:35.011]                   else NULL
  [21:15:35.011]                   if (!has_future || version < "1.8.0") {
  [21:15:35.011]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.011]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.011]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.011]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.011]                         "release", "version")], collapse = " "), 
  [21:15:35.011]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:35.011]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.011]                       info)
  [21:15:35.011]                     info <- base::paste(info, collapse = "; ")
  [21:15:35.011]                     if (!has_future) {
  [21:15:35.011]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.011]                         info)
  [21:15:35.011]                     }
  [21:15:35.011]                     else {
  [21:15:35.011]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.011]                         info, version)
  [21:15:35.011]                     }
  [21:15:35.011]                     base::stop(msg)
  [21:15:35.011]                   }
  [21:15:35.011]                 })
  [21:15:35.011]             }
  [21:15:35.011]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.011]         }
  [21:15:35.011]     }
  [21:15:35.011]     if (base::is.na(TRUE)) {
  [21:15:35.011]     }
  [21:15:35.011]     else {
  [21:15:35.011]         if (TRUE) {
  [21:15:35.011]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.011]                 open = "w")
  [21:15:35.011]         }
  [21:15:35.011]         else {
  [21:15:35.011]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.011]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.011]         }
  [21:15:35.011]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.011]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.011]             base::sink(type = "output", split = FALSE)
  [21:15:35.011]             base::close(...future.stdout)
  [21:15:35.011]         }, add = TRUE)
  [21:15:35.011]     }
  [21:15:35.011]     ...future.frame <- base::sys.nframe()
  [21:15:35.011]     ...future.conditions <- base::list()
  [21:15:35.011]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.011]     ...future.result <- base::tryCatch({
  [21:15:35.011]         base::withCallingHandlers({
  [21:15:35.011]             ...future.value <- base::withVisible(base::local({
  [21:15:35.011]                 sample(x, size = 1L)
  [21:15:35.011]             }))
  [21:15:35.011]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.011]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.011]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.011]                 version = "1.8")
  [21:15:35.011]         }, condition = base::local({
  [21:15:35.011]             c <- base::c
  [21:15:35.011]             inherits <- base::inherits
  [21:15:35.011]             invokeRestart <- base::invokeRestart
  [21:15:35.011]             length <- base::length
  [21:15:35.011]             list <- base::list
  [21:15:35.011]             seq.int <- base::seq.int
  [21:15:35.011]             signalCondition <- base::signalCondition
  [21:15:35.011]             sys.calls <- base::sys.calls
  [21:15:35.011]             Sys.time <- base::Sys.time
  [21:15:35.011]             `[[` <- base::`[[`
  [21:15:35.011]             `+` <- base::`+`
  [21:15:35.011]             `<<-` <- base::`<<-`
  [21:15:35.011]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.011]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.011]                   3L)]
  [21:15:35.011]             }
  [21:15:35.011]             function(cond) {
  [21:15:35.011]                 if (inherits(cond, "error")) {
  [21:15:35.011]                   sessionInformation <- function() {
  [21:15:35.011]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.011]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.011]                       search = base::search(), system = base::Sys.info())
  [21:15:35.011]                   }
  [21:15:35.011]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.011]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.011]                     cond$call), session = sessionInformation(), 
  [21:15:35.011]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.011]                   signalCondition(cond)
  [21:15:35.011]                 }
  [21:15:35.011]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:35.011]                 ))) {
  [21:15:35.011]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:35.011]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.011]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.011]                   if (!signal) {
  [21:15:35.011]                     muffleCondition <- function (cond) 
  [21:15:35.011]                     {
  [21:15:35.011]                       inherits <- base::inherits
  [21:15:35.011]                       invokeRestart <- base::invokeRestart
  [21:15:35.011]                       muffled <- FALSE
  [21:15:35.011]                       if (inherits(cond, "message")) {
  [21:15:35.011]                         invokeRestart("muffleMessage")
  [21:15:35.011]                         muffled <- TRUE
  [21:15:35.011]                       }
  [21:15:35.011]                       else if (inherits(cond, "warning")) {
  [21:15:35.011]                         invokeRestart("muffleWarning")
  [21:15:35.011]                         muffled <- TRUE
  [21:15:35.011]                       }
  [21:15:35.011]                       else if (inherits(cond, "condition")) {
  [21:15:35.011]                         computeRestarts <- base::computeRestarts
  [21:15:35.011]                         grepl <- base::grepl
  [21:15:35.011]                         is.null <- base::is.null
  [21:15:35.011]                         restarts <- computeRestarts(cond)
  [21:15:35.011]                         for (restart in restarts) {
  [21:15:35.011]                           name <- restart$name
  [21:15:35.011]                           if (is.null(name)) 
  [21:15:35.011]                             next
  [21:15:35.011]                           if (!grepl("^muffle", name)) 
  [21:15:35.011]                             next
  [21:15:35.011]                           invokeRestart(restart)
  [21:15:35.011]                           muffled <- TRUE
  [21:15:35.011]                           break
  [21:15:35.011]                         }
  [21:15:35.011]                       }
  [21:15:35.011]                       invisible(muffled)
  [21:15:35.011]                     }
  [21:15:35.011]                     muffleCondition(cond)
  [21:15:35.011]                   }
  [21:15:35.011]                 }
  [21:15:35.011]             }
  [21:15:35.011]         }))
  [21:15:35.011]     }, error = function(ex) {
  [21:15:35.011]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.011]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.011]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.011]     }, finally = {
  [21:15:35.011]         {
  [21:15:35.011]             NULL
  [21:15:35.011]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.011]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.011]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:35.011]                 label = NULL, ...) 
  [21:15:35.011]             {
  [21:15:35.011]                 if (substitute) 
  [21:15:35.011]                   expr <- substitute(expr)
  [21:15:35.011]                 local <- as.logical(local)
  [21:15:35.011]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:35.011]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.011]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:35.011]                   label = label, ...)
  [21:15:35.011]                 if (!future$lazy) 
  [21:15:35.011]                   future <- run(future)
  [21:15:35.011]                 invisible(future)
  [21:15:35.011]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.011]         }
  [21:15:35.011]         base::options(...future.oldOptions)
  [21:15:35.011]     })
  [21:15:35.011]     Sys.time
  [21:15:35.011]     if (base::is.na(TRUE)) {
  [21:15:35.011]     }
  [21:15:35.011]     else {
  [21:15:35.011]         base::sink(type = "output", split = FALSE)
  [21:15:35.011]         if (TRUE) {
  [21:15:35.011]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.011]         }
  [21:15:35.011]         else {
  [21:15:35.011]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.011]         }
  [21:15:35.011]         base::close(...future.stdout)
  [21:15:35.011]         ...future.stdout <- NULL
  [21:15:35.011]     }
  [21:15:35.011]     ...future.result$conditions <- ...future.conditions
  [21:15:35.011]     ...future.result
  [21:15:35.011] }
  [21:15:35.015] plan(): Setting new future strategy stack:
  [21:15:35.016] List of future strategies:
  [21:15:35.016] 1. sequential:
  [21:15:35.016]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.016]    - tweaked: FALSE
  [21:15:35.016]    - call: NULL
  [21:15:35.016] plan(): nbrOfWorkers() = 1
  [21:15:35.018] plan(): Setting new future strategy stack:
  [21:15:35.018] List of future strategies:
  [21:15:35.018] 1. sequential:
  [21:15:35.018]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.018]    - tweaked: FALSE
  [21:15:35.018]    - call: plan(strategy)
  [21:15:35.019] plan(): nbrOfWorkers() = 1
  [21:15:35.019] SequentialFuture started (and completed)
  [21:15:35.020] Future state: 'finished'
  [21:15:35.021] signalConditions() ...
  [21:15:35.021]  - include = 'condition'
  [21:15:35.021]  - exclude = 'immediateCondition'
  [21:15:35.022]  - resignal = TRUE
  [21:15:35.022]  - Number of conditions: 1
  [21:15:35.022]  - Condition #1: 'simpleError', 'error', 'condition'
  [21:15:35.023] signalConditions() ... done
  <simpleError: UNRELIABLE VALUE: Future ('fsample_1-547708') unexpectedly generated random numbers without specifying argument '[future.]seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify argument argument '[future.]seed', e.g. 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, set option 'future.rng.onMisuse' to "ignore".>
  [21:15:35.024] getGlobalsAndPackages() ...
  [21:15:35.024] Searching for globals...
  [21:15:35.026] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.027] Searching for globals ... DONE
  [21:15:35.027] Resolving globals: FALSE
  [21:15:35.028] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.028] - globals: [1] 'x'
  [21:15:35.029] 
  [21:15:35.029] getGlobalsAndPackages() ... DONE
  [21:15:35.031] Packages needed by the future expression (n = 0): <none>
  [21:15:35.031] Packages needed by future strategies (n = 0): <none>
  [21:15:35.035] {
  [21:15:35.035]     {
  [21:15:35.035]         ...future.startTime <- base::Sys.time()
  [21:15:35.035]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.035]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.035]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.035]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.035]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.035]         {
  [21:15:35.035]             {
  [21:15:35.035]                 base::local({
  [21:15:35.035]                   has_future <- base::requireNamespace("future", 
  [21:15:35.035]                     quietly = TRUE)
  [21:15:35.035]                   version <- if (has_future) 
  [21:15:35.035]                     utils::packageVersion("future")
  [21:15:35.035]                   else NULL
  [21:15:35.035]                   if (!has_future || version < "1.8.0") {
  [21:15:35.035]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.035]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.035]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.035]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.035]                         "release", "version")], collapse = " "), 
  [21:15:35.035]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:35.035]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.035]                       info)
  [21:15:35.035]                     info <- base::paste(info, collapse = "; ")
  [21:15:35.035]                     if (!has_future) {
  [21:15:35.035]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.035]                         info)
  [21:15:35.035]                     }
  [21:15:35.035]                     else {
  [21:15:35.035]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.035]                         info, version)
  [21:15:35.035]                     }
  [21:15:35.035]                     base::stop(msg)
  [21:15:35.035]                   }
  [21:15:35.035]                 })
  [21:15:35.035]             }
  [21:15:35.035]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.035]         }
  [21:15:35.035]     }
  [21:15:35.035]     if (base::is.na(TRUE)) {
  [21:15:35.035]     }
  [21:15:35.035]     else {
  [21:15:35.035]         if (TRUE) {
  [21:15:35.035]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.035]                 open = "w")
  [21:15:35.035]         }
  [21:15:35.035]         else {
  [21:15:35.035]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.035]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.035]         }
  [21:15:35.035]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.035]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.035]             base::sink(type = "output", split = FALSE)
  [21:15:35.035]             base::close(...future.stdout)
  [21:15:35.035]         }, add = TRUE)
  [21:15:35.035]     }
  [21:15:35.035]     ...future.frame <- base::sys.nframe()
  [21:15:35.035]     ...future.conditions <- base::list()
  [21:15:35.035]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.035]     ...future.result <- base::tryCatch({
  [21:15:35.035]         base::withCallingHandlers({
  [21:15:35.035]             ...future.value <- base::withVisible(base::local({
  [21:15:35.035]                 sample(x, size = 1L)
  [21:15:35.035]             }))
  [21:15:35.035]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.035]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.035]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.035]                 version = "1.8")
  [21:15:35.035]         }, condition = base::local({
  [21:15:35.035]             c <- base::c
  [21:15:35.035]             inherits <- base::inherits
  [21:15:35.035]             invokeRestart <- base::invokeRestart
  [21:15:35.035]             length <- base::length
  [21:15:35.035]             list <- base::list
  [21:15:35.035]             seq.int <- base::seq.int
  [21:15:35.035]             signalCondition <- base::signalCondition
  [21:15:35.035]             sys.calls <- base::sys.calls
  [21:15:35.035]             Sys.time <- base::Sys.time
  [21:15:35.035]             `[[` <- base::`[[`
  [21:15:35.035]             `+` <- base::`+`
  [21:15:35.035]             `<<-` <- base::`<<-`
  [21:15:35.035]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.035]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.035]                   3L)]
  [21:15:35.035]             }
  [21:15:35.035]             function(cond) {
  [21:15:35.035]                 if (inherits(cond, "error")) {
  [21:15:35.035]                   sessionInformation <- function() {
  [21:15:35.035]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.035]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.035]                       search = base::search(), system = base::Sys.info())
  [21:15:35.035]                   }
  [21:15:35.035]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.035]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.035]                     cond$call), session = sessionInformation(), 
  [21:15:35.035]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.035]                   signalCondition(cond)
  [21:15:35.035]                 }
  [21:15:35.035]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:35.035]                 ))) {
  [21:15:35.035]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:35.035]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.035]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.035]                   if (!signal) {
  [21:15:35.035]                     muffleCondition <- function (cond) 
  [21:15:35.035]                     {
  [21:15:35.035]                       inherits <- base::inherits
  [21:15:35.035]                       invokeRestart <- base::invokeRestart
  [21:15:35.035]                       muffled <- FALSE
  [21:15:35.035]                       if (inherits(cond, "message")) {
  [21:15:35.035]                         invokeRestart("muffleMessage")
  [21:15:35.035]                         muffled <- TRUE
  [21:15:35.035]                       }
  [21:15:35.035]                       else if (inherits(cond, "warning")) {
  [21:15:35.035]                         invokeRestart("muffleWarning")
  [21:15:35.035]                         muffled <- TRUE
  [21:15:35.035]                       }
  [21:15:35.035]                       else if (inherits(cond, "condition")) {
  [21:15:35.035]                         computeRestarts <- base::computeRestarts
  [21:15:35.035]                         grepl <- base::grepl
  [21:15:35.035]                         is.null <- base::is.null
  [21:15:35.035]                         restarts <- computeRestarts(cond)
  [21:15:35.035]                         for (restart in restarts) {
  [21:15:35.035]                           name <- restart$name
  [21:15:35.035]                           if (is.null(name)) 
  [21:15:35.035]                             next
  [21:15:35.035]                           if (!grepl("^muffle", name)) 
  [21:15:35.035]                             next
  [21:15:35.035]                           invokeRestart(restart)
  [21:15:35.035]                           muffled <- TRUE
  [21:15:35.035]                           break
  [21:15:35.035]                         }
  [21:15:35.035]                       }
  [21:15:35.035]                       invisible(muffled)
  [21:15:35.035]                     }
  [21:15:35.035]                     muffleCondition(cond)
  [21:15:35.035]                   }
  [21:15:35.035]                 }
  [21:15:35.035]             }
  [21:15:35.035]         }))
  [21:15:35.035]     }, error = function(ex) {
  [21:15:35.035]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.035]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.035]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.035]     }, finally = {
  [21:15:35.035]         {
  [21:15:35.035]             NULL
  [21:15:35.035]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.035]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.035]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:35.035]                 label = NULL, ...) 
  [21:15:35.035]             {
  [21:15:35.035]                 if (substitute) 
  [21:15:35.035]                   expr <- substitute(expr)
  [21:15:35.035]                 local <- as.logical(local)
  [21:15:35.035]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:35.035]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.035]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:35.035]                   label = label, ...)
  [21:15:35.035]                 if (!future$lazy) 
  [21:15:35.035]                   future <- run(future)
  [21:15:35.035]                 invisible(future)
  [21:15:35.035]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.035]         }
  [21:15:35.035]         base::options(...future.oldOptions)
  [21:15:35.035]     })
  [21:15:35.035]     Sys.time
  [21:15:35.035]     if (base::is.na(TRUE)) {
  [21:15:35.035]     }
  [21:15:35.035]     else {
  [21:15:35.035]         base::sink(type = "output", split = FALSE)
  [21:15:35.035]         if (TRUE) {
  [21:15:35.035]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.035]         }
  [21:15:35.035]         else {
  [21:15:35.035]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.035]         }
  [21:15:35.035]         base::close(...future.stdout)
  [21:15:35.035]         ...future.stdout <- NULL
  [21:15:35.035]     }
  [21:15:35.035]     ...future.result$conditions <- ...future.conditions
  [21:15:35.035]     ...future.result
  [21:15:35.035] }
  [21:15:35.040] plan(): Setting new future strategy stack:
  [21:15:35.040] List of future strategies:
  [21:15:35.040] 1. sequential:
  [21:15:35.040]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.040]    - tweaked: FALSE
  [21:15:35.040]    - call: NULL
  [21:15:35.041] plan(): nbrOfWorkers() = 1
  [21:15:35.042] plan(): Setting new future strategy stack:
  [21:15:35.042] List of future strategies:
  [21:15:35.042] 1. sequential:
  [21:15:35.042]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.042]    - tweaked: FALSE
  [21:15:35.042]    - call: plan(strategy)
  [21:15:35.043] plan(): nbrOfWorkers() = 1
  [21:15:35.044] SequentialFuture started (and completed)
  [21:15:35.045] getGlobalsAndPackages() ...
  [21:15:35.045] Searching for globals...
  [21:15:35.050] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.051] Searching for globals ... DONE
  [21:15:35.051] Resolving globals: FALSE
  [21:15:35.052] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.052] - globals: [1] 'x'
  [21:15:35.053] 
  [21:15:35.053] getGlobalsAndPackages() ... DONE
  [21:15:35.055] Packages needed by the future expression (n = 0): <none>
  [21:15:35.055] Packages needed by future strategies (n = 0): <none>
  [21:15:35.060] {
  [21:15:35.060]     {
  [21:15:35.060]         ...future.startTime <- base::Sys.time()
  [21:15:35.060]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.060]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.060]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.060]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.060]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.060]         {
  [21:15:35.060]             {
  [21:15:35.060]                 base::local({
  [21:15:35.060]                   has_future <- base::requireNamespace("future", 
  [21:15:35.060]                     quietly = TRUE)
  [21:15:35.060]                   version <- if (has_future) 
  [21:15:35.060]                     utils::packageVersion("future")
  [21:15:35.060]                   else NULL
  [21:15:35.060]                   if (!has_future || version < "1.8.0") {
  [21:15:35.060]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.060]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.060]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.060]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.060]                         "release", "version")], collapse = " "), 
  [21:15:35.060]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:35.060]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.060]                       info)
  [21:15:35.060]                     info <- base::paste(info, collapse = "; ")
  [21:15:35.060]                     if (!has_future) {
  [21:15:35.060]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.060]                         info)
  [21:15:35.060]                     }
  [21:15:35.060]                     else {
  [21:15:35.060]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.060]                         info, version)
  [21:15:35.060]                     }
  [21:15:35.060]                     base::stop(msg)
  [21:15:35.060]                   }
  [21:15:35.060]                 })
  [21:15:35.060]             }
  [21:15:35.060]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.060]         }
  [21:15:35.060]     }
  [21:15:35.060]     if (base::is.na(TRUE)) {
  [21:15:35.060]     }
  [21:15:35.060]     else {
  [21:15:35.060]         if (TRUE) {
  [21:15:35.060]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.060]                 open = "w")
  [21:15:35.060]         }
  [21:15:35.060]         else {
  [21:15:35.060]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.060]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.060]         }
  [21:15:35.060]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.060]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.060]             base::sink(type = "output", split = FALSE)
  [21:15:35.060]             base::close(...future.stdout)
  [21:15:35.060]         }, add = TRUE)
  [21:15:35.060]     }
  [21:15:35.060]     ...future.frame <- base::sys.nframe()
  [21:15:35.060]     ...future.conditions <- base::list()
  [21:15:35.060]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.060]     ...future.result <- base::tryCatch({
  [21:15:35.060]         base::withCallingHandlers({
  [21:15:35.060]             ...future.value <- base::withVisible(base::local({
  [21:15:35.060]                 sample(x, size = 1L)
  [21:15:35.060]             }))
  [21:15:35.060]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.060]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.060]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.060]                 version = "1.8")
  [21:15:35.060]         }, condition = base::local({
  [21:15:35.060]             c <- base::c
  [21:15:35.060]             inherits <- base::inherits
  [21:15:35.060]             invokeRestart <- base::invokeRestart
  [21:15:35.060]             length <- base::length
  [21:15:35.060]             list <- base::list
  [21:15:35.060]             seq.int <- base::seq.int
  [21:15:35.060]             signalCondition <- base::signalCondition
  [21:15:35.060]             sys.calls <- base::sys.calls
  [21:15:35.060]             Sys.time <- base::Sys.time
  [21:15:35.060]             `[[` <- base::`[[`
  [21:15:35.060]             `+` <- base::`+`
  [21:15:35.060]             `<<-` <- base::`<<-`
  [21:15:35.060]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.060]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.060]                   3L)]
  [21:15:35.060]             }
  [21:15:35.060]             function(cond) {
  [21:15:35.060]                 if (inherits(cond, "error")) {
  [21:15:35.060]                   sessionInformation <- function() {
  [21:15:35.060]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.060]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.060]                       search = base::search(), system = base::Sys.info())
  [21:15:35.060]                   }
  [21:15:35.060]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.060]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.060]                     cond$call), session = sessionInformation(), 
  [21:15:35.060]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.060]                   signalCondition(cond)
  [21:15:35.060]                 }
  [21:15:35.060]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:35.060]                 ))) {
  [21:15:35.060]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:35.060]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.060]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.060]                   if (!signal) {
  [21:15:35.060]                     muffleCondition <- function (cond) 
  [21:15:35.060]                     {
  [21:15:35.060]                       inherits <- base::inherits
  [21:15:35.060]                       invokeRestart <- base::invokeRestart
  [21:15:35.060]                       muffled <- FALSE
  [21:15:35.060]                       if (inherits(cond, "message")) {
  [21:15:35.060]                         invokeRestart("muffleMessage")
  [21:15:35.060]                         muffled <- TRUE
  [21:15:35.060]                       }
  [21:15:35.060]                       else if (inherits(cond, "warning")) {
  [21:15:35.060]                         invokeRestart("muffleWarning")
  [21:15:35.060]                         muffled <- TRUE
  [21:15:35.060]                       }
  [21:15:35.060]                       else if (inherits(cond, "condition")) {
  [21:15:35.060]                         computeRestarts <- base::computeRestarts
  [21:15:35.060]                         grepl <- base::grepl
  [21:15:35.060]                         is.null <- base::is.null
  [21:15:35.060]                         restarts <- computeRestarts(cond)
  [21:15:35.060]                         for (restart in restarts) {
  [21:15:35.060]                           name <- restart$name
  [21:15:35.060]                           if (is.null(name)) 
  [21:15:35.060]                             next
  [21:15:35.060]                           if (!grepl("^muffle", name)) 
  [21:15:35.060]                             next
  [21:15:35.060]                           invokeRestart(restart)
  [21:15:35.060]                           muffled <- TRUE
  [21:15:35.060]                           break
  [21:15:35.060]                         }
  [21:15:35.060]                       }
  [21:15:35.060]                       invisible(muffled)
  [21:15:35.060]                     }
  [21:15:35.060]                     muffleCondition(cond)
  [21:15:35.060]                   }
  [21:15:35.060]                 }
  [21:15:35.060]             }
  [21:15:35.060]         }))
  [21:15:35.060]     }, error = function(ex) {
  [21:15:35.060]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.060]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.060]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.060]     }, finally = {
  [21:15:35.060]         {
  [21:15:35.060]             NULL
  [21:15:35.060]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.060]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.060]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:35.060]                 label = NULL, ...) 
  [21:15:35.060]             {
  [21:15:35.060]                 if (substitute) 
  [21:15:35.060]                   expr <- substitute(expr)
  [21:15:35.060]                 local <- as.logical(local)
  [21:15:35.060]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:35.060]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.060]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:35.060]                   label = label, ...)
  [21:15:35.060]                 if (!future$lazy) 
  [21:15:35.060]                   future <- run(future)
  [21:15:35.060]                 invisible(future)
  [21:15:35.060]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.060]         }
  [21:15:35.060]         base::options(...future.oldOptions)
  [21:15:35.060]     })
  [21:15:35.060]     Sys.time
  [21:15:35.060]     if (base::is.na(TRUE)) {
  [21:15:35.060]     }
  [21:15:35.060]     else {
  [21:15:35.060]         base::sink(type = "output", split = FALSE)
  [21:15:35.060]         if (TRUE) {
  [21:15:35.060]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.060]         }
  [21:15:35.060]         else {
  [21:15:35.060]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.060]         }
  [21:15:35.060]         base::close(...future.stdout)
  [21:15:35.060]         ...future.stdout <- NULL
  [21:15:35.060]     }
  [21:15:35.060]     ...future.result$conditions <- ...future.conditions
  [21:15:35.060]     ...future.result
  [21:15:35.060] }
  [21:15:35.065] plan(): Setting new future strategy stack:
  [21:15:35.065] List of future strategies:
  [21:15:35.065] 1. sequential:
  [21:15:35.065]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.065]    - tweaked: FALSE
  [21:15:35.065]    - call: NULL
  [21:15:35.066] plan(): nbrOfWorkers() = 1
  [21:15:35.067] plan(): Setting new future strategy stack:
  [21:15:35.067] List of future strategies:
  [21:15:35.067] 1. sequential:
  [21:15:35.067]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.067]    - tweaked: FALSE
  [21:15:35.067]    - call: plan(strategy)
  [21:15:35.068] plan(): nbrOfWorkers() = 1
  [21:15:35.069] SequentialFuture started (and completed)
  [21:15:35.070] getGlobalsAndPackages() ...
  [21:15:35.070] Searching for globals...
  [21:15:35.072] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.073] Searching for globals ... DONE
  [21:15:35.073] Resolving globals: FALSE
  [21:15:35.074] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.074] - globals: [1] 'x'
  [21:15:35.074] 
  [21:15:35.075] getGlobalsAndPackages() ... DONE
  [21:15:35.076] Packages needed by the future expression (n = 0): <none>
  [21:15:35.076] Packages needed by future strategies (n = 0): <none>
  [21:15:35.080] {
  [21:15:35.080]     {
  [21:15:35.080]         ...future.startTime <- base::Sys.time()
  [21:15:35.080]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.080]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.080]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.080]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.080]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.080]         {
  [21:15:35.080]             {
  [21:15:35.080]                 base::local({
  [21:15:35.080]                   has_future <- base::requireNamespace("future", 
  [21:15:35.080]                     quietly = TRUE)
  [21:15:35.080]                   version <- if (has_future) 
  [21:15:35.080]                     utils::packageVersion("future")
  [21:15:35.080]                   else NULL
  [21:15:35.080]                   if (!has_future || version < "1.8.0") {
  [21:15:35.080]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.080]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.080]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.080]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.080]                         "release", "version")], collapse = " "), 
  [21:15:35.080]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:35.080]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.080]                       info)
  [21:15:35.080]                     info <- base::paste(info, collapse = "; ")
  [21:15:35.080]                     if (!has_future) {
  [21:15:35.080]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.080]                         info)
  [21:15:35.080]                     }
  [21:15:35.080]                     else {
  [21:15:35.080]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.080]                         info, version)
  [21:15:35.080]                     }
  [21:15:35.080]                     base::stop(msg)
  [21:15:35.080]                   }
  [21:15:35.080]                 })
  [21:15:35.080]             }
  [21:15:35.080]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.080]         }
  [21:15:35.080]     }
  [21:15:35.080]     if (base::is.na(TRUE)) {
  [21:15:35.080]     }
  [21:15:35.080]     else {
  [21:15:35.080]         if (TRUE) {
  [21:15:35.080]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.080]                 open = "w")
  [21:15:35.080]         }
  [21:15:35.080]         else {
  [21:15:35.080]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.080]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.080]         }
  [21:15:35.080]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.080]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.080]             base::sink(type = "output", split = FALSE)
  [21:15:35.080]             base::close(...future.stdout)
  [21:15:35.080]         }, add = TRUE)
  [21:15:35.080]     }
  [21:15:35.080]     ...future.frame <- base::sys.nframe()
  [21:15:35.080]     ...future.conditions <- base::list()
  [21:15:35.080]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.080]     ...future.result <- base::tryCatch({
  [21:15:35.080]         base::withCallingHandlers({
  [21:15:35.080]             ...future.value <- base::withVisible(base::local({
  [21:15:35.080]                 sample(x, size = 1L)
  [21:15:35.080]             }))
  [21:15:35.080]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.080]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.080]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.080]                 version = "1.8")
  [21:15:35.080]         }, condition = base::local({
  [21:15:35.080]             c <- base::c
  [21:15:35.080]             inherits <- base::inherits
  [21:15:35.080]             invokeRestart <- base::invokeRestart
  [21:15:35.080]             length <- base::length
  [21:15:35.080]             list <- base::list
  [21:15:35.080]             seq.int <- base::seq.int
  [21:15:35.080]             signalCondition <- base::signalCondition
  [21:15:35.080]             sys.calls <- base::sys.calls
  [21:15:35.080]             Sys.time <- base::Sys.time
  [21:15:35.080]             `[[` <- base::`[[`
  [21:15:35.080]             `+` <- base::`+`
  [21:15:35.080]             `<<-` <- base::`<<-`
  [21:15:35.080]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.080]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.080]                   3L)]
  [21:15:35.080]             }
  [21:15:35.080]             function(cond) {
  [21:15:35.080]                 if (inherits(cond, "error")) {
  [21:15:35.080]                   sessionInformation <- function() {
  [21:15:35.080]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.080]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.080]                       search = base::search(), system = base::Sys.info())
  [21:15:35.080]                   }
  [21:15:35.080]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.080]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.080]                     cond$call), session = sessionInformation(), 
  [21:15:35.080]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.080]                   signalCondition(cond)
  [21:15:35.080]                 }
  [21:15:35.080]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:35.080]                 ))) {
  [21:15:35.080]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:35.080]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.080]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.080]                   if (!signal) {
  [21:15:35.080]                     muffleCondition <- function (cond) 
  [21:15:35.080]                     {
  [21:15:35.080]                       inherits <- base::inherits
  [21:15:35.080]                       invokeRestart <- base::invokeRestart
  [21:15:35.080]                       muffled <- FALSE
  [21:15:35.080]                       if (inherits(cond, "message")) {
  [21:15:35.080]                         invokeRestart("muffleMessage")
  [21:15:35.080]                         muffled <- TRUE
  [21:15:35.080]                       }
  [21:15:35.080]                       else if (inherits(cond, "warning")) {
  [21:15:35.080]                         invokeRestart("muffleWarning")
  [21:15:35.080]                         muffled <- TRUE
  [21:15:35.080]                       }
  [21:15:35.080]                       else if (inherits(cond, "condition")) {
  [21:15:35.080]                         computeRestarts <- base::computeRestarts
  [21:15:35.080]                         grepl <- base::grepl
  [21:15:35.080]                         is.null <- base::is.null
  [21:15:35.080]                         restarts <- computeRestarts(cond)
  [21:15:35.080]                         for (restart in restarts) {
  [21:15:35.080]                           name <- restart$name
  [21:15:35.080]                           if (is.null(name)) 
  [21:15:35.080]                             next
  [21:15:35.080]                           if (!grepl("^muffle", name)) 
  [21:15:35.080]                             next
  [21:15:35.080]                           invokeRestart(restart)
  [21:15:35.080]                           muffled <- TRUE
  [21:15:35.080]                           break
  [21:15:35.080]                         }
  [21:15:35.080]                       }
  [21:15:35.080]                       invisible(muffled)
  [21:15:35.080]                     }
  [21:15:35.080]                     muffleCondition(cond)
  [21:15:35.080]                   }
  [21:15:35.080]                 }
  [21:15:35.080]             }
  [21:15:35.080]         }))
  [21:15:35.080]     }, error = function(ex) {
  [21:15:35.080]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.080]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.080]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.080]     }, finally = {
  [21:15:35.080]         {
  [21:15:35.080]             NULL
  [21:15:35.080]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.080]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.080]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:35.080]                 label = NULL, ...) 
  [21:15:35.080]             {
  [21:15:35.080]                 if (substitute) 
  [21:15:35.080]                   expr <- substitute(expr)
  [21:15:35.080]                 local <- as.logical(local)
  [21:15:35.080]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:35.080]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.080]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:35.080]                   label = label, ...)
  [21:15:35.080]                 if (!future$lazy) 
  [21:15:35.080]                   future <- run(future)
  [21:15:35.080]                 invisible(future)
  [21:15:35.080]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.080]         }
  [21:15:35.080]         base::options(...future.oldOptions)
  [21:15:35.080]     })
  [21:15:35.080]     Sys.time
  [21:15:35.080]     if (base::is.na(TRUE)) {
  [21:15:35.080]     }
  [21:15:35.080]     else {
  [21:15:35.080]         base::sink(type = "output", split = FALSE)
  [21:15:35.080]         if (TRUE) {
  [21:15:35.080]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.080]         }
  [21:15:35.080]         else {
  [21:15:35.080]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.080]         }
  [21:15:35.080]         base::close(...future.stdout)
  [21:15:35.080]         ...future.stdout <- NULL
  [21:15:35.080]     }
  [21:15:35.080]     ...future.result$conditions <- ...future.conditions
  [21:15:35.080]     ...future.result
  [21:15:35.080] }
  [21:15:35.085] plan(): Setting new future strategy stack:
  [21:15:35.085] List of future strategies:
  [21:15:35.085] 1. sequential:
  [21:15:35.085]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.085]    - tweaked: FALSE
  [21:15:35.085]    - call: NULL
  [21:15:35.086] plan(): nbrOfWorkers() = 1
  [21:15:35.087] plan(): Setting new future strategy stack:
  [21:15:35.087] List of future strategies:
  [21:15:35.087] 1. sequential:
  [21:15:35.087]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.087]    - tweaked: FALSE
  [21:15:35.087]    - call: plan(strategy)
  [21:15:35.088] plan(): nbrOfWorkers() = 1
  [21:15:35.089] SequentialFuture started (and completed)
  [21:15:35.090] getGlobalsAndPackages() ...
  [21:15:35.090] Searching for globals...
  [21:15:35.092] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.092] Searching for globals ... DONE
  [21:15:35.093] Resolving globals: FALSE
  [21:15:35.094] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.094] - globals: [1] 'x'
  [21:15:35.094] 
  [21:15:35.094] getGlobalsAndPackages() ... DONE
  [21:15:35.096] Packages needed by the future expression (n = 0): <none>
  [21:15:35.096] Packages needed by future strategies (n = 0): <none>
  [21:15:35.100] {
  [21:15:35.100]     {
  [21:15:35.100]         ...future.startTime <- base::Sys.time()
  [21:15:35.100]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.100]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.100]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.100]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.100]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.100]         {
  [21:15:35.100]             {
  [21:15:35.100]                 base::local({
  [21:15:35.100]                   has_future <- base::requireNamespace("future", 
  [21:15:35.100]                     quietly = TRUE)
  [21:15:35.100]                   version <- if (has_future) 
  [21:15:35.100]                     utils::packageVersion("future")
  [21:15:35.100]                   else NULL
  [21:15:35.100]                   if (!has_future || version < "1.8.0") {
  [21:15:35.100]                     info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.100]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.100]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.100]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.100]                         "release", "version")], collapse = " "), 
  [21:15:35.100]                       hostname = base::Sys.info()[["nodename"]])
  [21:15:35.100]                     info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.100]                       info)
  [21:15:35.100]                     info <- base::paste(info, collapse = "; ")
  [21:15:35.100]                     if (!has_future) {
  [21:15:35.100]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.100]                         info)
  [21:15:35.100]                     }
  [21:15:35.100]                     else {
  [21:15:35.100]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.100]                         info, version)
  [21:15:35.100]                     }
  [21:15:35.100]                     base::stop(msg)
  [21:15:35.100]                   }
  [21:15:35.100]                 })
  [21:15:35.100]             }
  [21:15:35.100]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.100]         }
  [21:15:35.100]     }
  [21:15:35.100]     if (base::is.na(TRUE)) {
  [21:15:35.100]     }
  [21:15:35.100]     else {
  [21:15:35.100]         if (TRUE) {
  [21:15:35.100]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.100]                 open = "w")
  [21:15:35.100]         }
  [21:15:35.100]         else {
  [21:15:35.100]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.100]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.100]         }
  [21:15:35.100]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.100]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.100]             base::sink(type = "output", split = FALSE)
  [21:15:35.100]             base::close(...future.stdout)
  [21:15:35.100]         }, add = TRUE)
  [21:15:35.100]     }
  [21:15:35.100]     ...future.frame <- base::sys.nframe()
  [21:15:35.100]     ...future.conditions <- base::list()
  [21:15:35.100]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.100]     ...future.result <- base::tryCatch({
  [21:15:35.100]         base::withCallingHandlers({
  [21:15:35.100]             ...future.value <- base::withVisible(base::local({
  [21:15:35.100]                 sample(x, size = 1L)
  [21:15:35.100]             }))
  [21:15:35.100]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.100]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.100]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.100]                 version = "1.8")
  [21:15:35.100]         }, condition = base::local({
  [21:15:35.100]             c <- base::c
  [21:15:35.100]             inherits <- base::inherits
  [21:15:35.100]             invokeRestart <- base::invokeRestart
  [21:15:35.100]             length <- base::length
  [21:15:35.100]             list <- base::list
  [21:15:35.100]             seq.int <- base::seq.int
  [21:15:35.100]             signalCondition <- base::signalCondition
  [21:15:35.100]             sys.calls <- base::sys.calls
  [21:15:35.100]             Sys.time <- base::Sys.time
  [21:15:35.100]             `[[` <- base::`[[`
  [21:15:35.100]             `+` <- base::`+`
  [21:15:35.100]             `<<-` <- base::`<<-`
  [21:15:35.100]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.100]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.100]                   3L)]
  [21:15:35.100]             }
  [21:15:35.100]             function(cond) {
  [21:15:35.100]                 if (inherits(cond, "error")) {
  [21:15:35.100]                   sessionInformation <- function() {
  [21:15:35.100]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.100]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.100]                       search = base::search(), system = base::Sys.info())
  [21:15:35.100]                   }
  [21:15:35.100]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.100]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.100]                     cond$call), session = sessionInformation(), 
  [21:15:35.100]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.100]                   signalCondition(cond)
  [21:15:35.100]                 }
  [21:15:35.100]                 else if (inherits(cond, c("condition", "immediateCondition"
  [21:15:35.100]                 ))) {
  [21:15:35.100]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [21:15:35.100]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.100]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.100]                   if (!signal) {
  [21:15:35.100]                     muffleCondition <- function (cond) 
  [21:15:35.100]                     {
  [21:15:35.100]                       inherits <- base::inherits
  [21:15:35.100]                       invokeRestart <- base::invokeRestart
  [21:15:35.100]                       muffled <- FALSE
  [21:15:35.100]                       if (inherits(cond, "message")) {
  [21:15:35.100]                         invokeRestart("muffleMessage")
  [21:15:35.100]                         muffled <- TRUE
  [21:15:35.100]                       }
  [21:15:35.100]                       else if (inherits(cond, "warning")) {
  [21:15:35.100]                         invokeRestart("muffleWarning")
  [21:15:35.100]                         muffled <- TRUE
  [21:15:35.100]                       }
  [21:15:35.100]                       else if (inherits(cond, "condition")) {
  [21:15:35.100]                         computeRestarts <- base::computeRestarts
  [21:15:35.100]                         grepl <- base::grepl
  [21:15:35.100]                         is.null <- base::is.null
  [21:15:35.100]                         restarts <- computeRestarts(cond)
  [21:15:35.100]                         for (restart in restarts) {
  [21:15:35.100]                           name <- restart$name
  [21:15:35.100]                           if (is.null(name)) 
  [21:15:35.100]                             next
  [21:15:35.100]                           if (!grepl("^muffle", name)) 
  [21:15:35.100]                             next
  [21:15:35.100]                           invokeRestart(restart)
  [21:15:35.100]                           muffled <- TRUE
  [21:15:35.100]                           break
  [21:15:35.100]                         }
  [21:15:35.100]                       }
  [21:15:35.100]                       invisible(muffled)
  [21:15:35.100]                     }
  [21:15:35.100]                     muffleCondition(cond)
  [21:15:35.100]                   }
  [21:15:35.100]                 }
  [21:15:35.100]             }
  [21:15:35.100]         }))
  [21:15:35.100]     }, error = function(ex) {
  [21:15:35.100]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.100]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.100]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.100]     }, finally = {
  [21:15:35.100]         {
  [21:15:35.100]             NULL
  [21:15:35.100]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.100]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.100]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [21:15:35.100]                 label = NULL, ...) 
  [21:15:35.100]             {
  [21:15:35.100]                 if (substitute) 
  [21:15:35.100]                   expr <- substitute(expr)
  [21:15:35.100]                 local <- as.logical(local)
  [21:15:35.100]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [21:15:35.100]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.100]                   globals = globals, local = local, earlySignal = earlySignal, 
  [21:15:35.100]                   label = label, ...)
  [21:15:35.100]                 if (!future$lazy) 
  [21:15:35.100]                   future <- run(future)
  [21:15:35.100]                 invisible(future)
  [21:15:35.100]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.100]         }
  [21:15:35.100]         base::options(...future.oldOptions)
  [21:15:35.100]     })
  [21:15:35.100]     Sys.time
  [21:15:35.100]     if (base::is.na(TRUE)) {
  [21:15:35.100]     }
  [21:15:35.100]     else {
  [21:15:35.100]         base::sink(type = "output", split = FALSE)
  [21:15:35.100]         if (TRUE) {
  [21:15:35.100]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.100]         }
  [21:15:35.100]         else {
  [21:15:35.100]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.100]         }
  [21:15:35.100]         base::close(...future.stdout)
  [21:15:35.100]         ...future.stdout <- NULL
  [21:15:35.100]     }
  [21:15:35.100]     ...future.result$conditions <- ...future.conditions
  [21:15:35.100]     ...future.result
  [21:15:35.100] }
  [21:15:35.105] plan(): Setting new future strategy stack:
  [21:15:35.105] List of future strategies:
  [21:15:35.105] 1. sequential:
  [21:15:35.105]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.105]    - tweaked: FALSE
  [21:15:35.105]    - call: NULL
  [21:15:35.107] plan(): nbrOfWorkers() = 1
  [21:15:35.108] plan(): Setting new future strategy stack:
  [21:15:35.108] List of future strategies:
  [21:15:35.108] 1. sequential:
  [21:15:35.108]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.108]    - tweaked: FALSE
  [21:15:35.108]    - call: plan(strategy)
  [21:15:35.109] plan(): nbrOfWorkers() = 1
  [21:15:35.110] SequentialFuture started (and completed)
  [[1]]
  [1] 0
  
  [[2]]
  [1] 2
  
  [[3]]
  [1] 2
  
  [[4]]
  [1] 2
  
  sequential ... done
  Testing with 1 cores ... DONE
  Testing with 2 cores ...
  multicore ...
  [21:15:35.125] plan(): Setting new future strategy stack:
  [21:15:35.125] List of future strategies:
  [21:15:35.125] 1. multicore:
  [21:15:35.125]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.125]    - tweaked: FALSE
  [21:15:35.125]    - call: plan(strategy)
  [21:15:35.127] plan(): nbrOfWorkers() = 2
  [21:15:35.128] getGlobalsAndPackages() ...
  [21:15:35.128] Searching for globals...
  [21:15:35.130] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.130] Searching for globals ... DONE
  [21:15:35.131] Resolving globals: FALSE
  [21:15:35.132] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.132] - globals: [1] 'x'
  [21:15:35.132] 
  [21:15:35.132] getGlobalsAndPackages() ... DONE
  [21:15:35.135] Packages needed by the future expression (n = 0): <none>
  [21:15:35.135] Packages needed by future strategies (n = 0): <none>
  [21:15:35.139] {
  [21:15:35.139]     {
  [21:15:35.139]         ...future.startTime <- base::Sys.time()
  [21:15:35.139]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.139]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.139]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.139]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.139]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.139]         {
  [21:15:35.139]             {
  [21:15:35.139]                 {
  [21:15:35.139]                   {
  [21:15:35.139]                     base::local({
  [21:15:35.139]                       has_future <- base::requireNamespace("future", 
  [21:15:35.139]                         quietly = TRUE)
  [21:15:35.139]                       version <- if (has_future) 
  [21:15:35.139]                         utils::packageVersion("future")
  [21:15:35.139]                       else NULL
  [21:15:35.139]                       if (!has_future || version < "1.8.0") {
  [21:15:35.139]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.139]                           "", base::R.version$version.string), 
  [21:15:35.139]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.139]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.139]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.139]                             "release", "version")], collapse = " "), 
  [21:15:35.139]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.139]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.139]                           info)
  [21:15:35.139]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.139]                         if (!has_future) {
  [21:15:35.139]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.139]                             info)
  [21:15:35.139]                         }
  [21:15:35.139]                         else {
  [21:15:35.139]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.139]                             info, version)
  [21:15:35.139]                         }
  [21:15:35.139]                         base::stop(msg)
  [21:15:35.139]                       }
  [21:15:35.139]                     })
  [21:15:35.139]                   }
  [21:15:35.139]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.139]                   base::options(mc.cores = 1L)
  [21:15:35.139]                 }
  [21:15:35.139]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:35.139]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:35.139]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.139]             }
  [21:15:35.139]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.139]         }
  [21:15:35.139]     }
  [21:15:35.139]     if (base::is.na(TRUE)) {
  [21:15:35.139]     }
  [21:15:35.139]     else {
  [21:15:35.139]         if (TRUE) {
  [21:15:35.139]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.139]                 open = "w")
  [21:15:35.139]         }
  [21:15:35.139]         else {
  [21:15:35.139]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.139]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.139]         }
  [21:15:35.139]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.139]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.139]             base::sink(type = "output", split = FALSE)
  [21:15:35.139]             base::close(...future.stdout)
  [21:15:35.139]         }, add = TRUE)
  [21:15:35.139]     }
  [21:15:35.139]     ...future.frame <- base::sys.nframe()
  [21:15:35.139]     ...future.conditions <- base::list()
  [21:15:35.139]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.139]     ...future.result <- base::tryCatch({
  [21:15:35.139]         base::withCallingHandlers({
  [21:15:35.139]             ...future.value <- base::withVisible(base::local({
  [21:15:35.139]                 sample(x, size = 1L)
  [21:15:35.139]             }))
  [21:15:35.139]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.139]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.139]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.139]                 version = "1.8")
  [21:15:35.139]         }, condition = base::local({
  [21:15:35.139]             c <- base::c
  [21:15:35.139]             inherits <- base::inherits
  [21:15:35.139]             invokeRestart <- base::invokeRestart
  [21:15:35.139]             length <- base::length
  [21:15:35.139]             list <- base::list
  [21:15:35.139]             seq.int <- base::seq.int
  [21:15:35.139]             signalCondition <- base::signalCondition
  [21:15:35.139]             sys.calls <- base::sys.calls
  [21:15:35.139]             Sys.time <- base::Sys.time
  [21:15:35.139]             `[[` <- base::`[[`
  [21:15:35.139]             `+` <- base::`+`
  [21:15:35.139]             `<<-` <- base::`<<-`
  [21:15:35.139]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.139]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.139]                   3L)]
  [21:15:35.139]             }
  [21:15:35.139]             function(cond) {
  [21:15:35.139]                 if (inherits(cond, "error")) {
  [21:15:35.139]                   sessionInformation <- function() {
  [21:15:35.139]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.139]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.139]                       search = base::search(), system = base::Sys.info())
  [21:15:35.139]                   }
  [21:15:35.139]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.139]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.139]                     cond$call), session = sessionInformation(), 
  [21:15:35.139]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.139]                   signalCondition(cond)
  [21:15:35.139]                 }
  [21:15:35.139]                 else if (inherits(cond, "condition")) {
  [21:15:35.139]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.139]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.139]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.139]                   if (!signal) {
  [21:15:35.139]                     muffleCondition <- function (cond) 
  [21:15:35.139]                     {
  [21:15:35.139]                       inherits <- base::inherits
  [21:15:35.139]                       invokeRestart <- base::invokeRestart
  [21:15:35.139]                       muffled <- FALSE
  [21:15:35.139]                       if (inherits(cond, "message")) {
  [21:15:35.139]                         invokeRestart("muffleMessage")
  [21:15:35.139]                         muffled <- TRUE
  [21:15:35.139]                       }
  [21:15:35.139]                       else if (inherits(cond, "warning")) {
  [21:15:35.139]                         invokeRestart("muffleWarning")
  [21:15:35.139]                         muffled <- TRUE
  [21:15:35.139]                       }
  [21:15:35.139]                       else if (inherits(cond, "condition")) {
  [21:15:35.139]                         computeRestarts <- base::computeRestarts
  [21:15:35.139]                         grepl <- base::grepl
  [21:15:35.139]                         is.null <- base::is.null
  [21:15:35.139]                         restarts <- computeRestarts(cond)
  [21:15:35.139]                         for (restart in restarts) {
  [21:15:35.139]                           name <- restart$name
  [21:15:35.139]                           if (is.null(name)) 
  [21:15:35.139]                             next
  [21:15:35.139]                           if (!grepl("^muffle", name)) 
  [21:15:35.139]                             next
  [21:15:35.139]                           invokeRestart(restart)
  [21:15:35.139]                           muffled <- TRUE
  [21:15:35.139]                           break
  [21:15:35.139]                         }
  [21:15:35.139]                       }
  [21:15:35.139]                       invisible(muffled)
  [21:15:35.139]                     }
  [21:15:35.139]                     muffleCondition(cond)
  [21:15:35.139]                   }
  [21:15:35.139]                 }
  [21:15:35.139]             }
  [21:15:35.139]         }))
  [21:15:35.139]     }, error = function(ex) {
  [21:15:35.139]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.139]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.139]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.139]     }, finally = {
  [21:15:35.139]         {
  [21:15:35.139]             {
  [21:15:35.139]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.139]             }
  [21:15:35.139]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.139]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.139]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.139]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.139]             {
  [21:15:35.139]                 if (substitute) 
  [21:15:35.139]                   expr <- substitute(expr)
  [21:15:35.139]                 if (is.function(workers)) 
  [21:15:35.139]                   workers <- workers()
  [21:15:35.139]                 workers <- as.integer(workers)
  [21:15:35.139]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.139]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.139]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.139]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.139]                     local = TRUE, label = label, ...))
  [21:15:35.139]                 }
  [21:15:35.139]                 oopts <- options(mc.cores = workers)
  [21:15:35.139]                 on.exit(options(oopts))
  [21:15:35.139]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.139]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.139]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.139]                   label = label, ...)
  [21:15:35.139]                 if (!future$lazy) 
  [21:15:35.139]                   future <- run(future)
  [21:15:35.139]                 invisible(future)
  [21:15:35.139]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.139]         }
  [21:15:35.139]         base::options(...future.oldOptions)
  [21:15:35.139]     })
  [21:15:35.139]     Sys.time
  [21:15:35.139]     if (base::is.na(TRUE)) {
  [21:15:35.139]     }
  [21:15:35.139]     else {
  [21:15:35.139]         base::sink(type = "output", split = FALSE)
  [21:15:35.139]         if (TRUE) {
  [21:15:35.139]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.139]         }
  [21:15:35.139]         else {
  [21:15:35.139]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.139]         }
  [21:15:35.139]         base::close(...future.stdout)
  [21:15:35.139]         ...future.stdout <- NULL
  [21:15:35.139]     }
  [21:15:35.139]     ...future.result$conditions <- ...future.conditions
  [21:15:35.139]     ...future.result
  [21:15:35.139] }
  [21:15:35.143] requestCore(): workers = 2
  [21:15:35.148] MulticoreFuture started
  [21:15:35.150] getGlobalsAndPackages() ...
  [21:15:35.151] Searching for globals...
  [21:15:35.154] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.154] Searching for globals ... DONE
  [21:15:35.155] Resolving globals: FALSE
  [21:15:35.156] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.157] - globals: [1] 'x'
  [21:15:35.157] 
  [21:15:35.157] getGlobalsAndPackages() ... DONE
  [21:15:35.160] Packages needed by the future expression (n = 0): <none>
  [21:15:35.161] Packages needed by future strategies (n = 0): <none>
  [21:15:35.165] plan(): Setting new future strategy stack:
  [21:15:35.166] List of future strategies:
  [21:15:35.166] 1. sequential:
  [21:15:35.166]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.166]    - tweaked: FALSE
  [21:15:35.166]    - call: NULL
  [21:15:35.168] plan(): nbrOfWorkers() = 1
  [21:15:35.169] plan(): Setting new future strategy stack:
  [21:15:35.170] List of future strategies:
  [21:15:35.170] 1. multicore:
  [21:15:35.170]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.170]    - tweaked: FALSE
  [21:15:35.170]    - call: plan(strategy)
  [21:15:35.171] plan(): nbrOfWorkers() = 2
  [21:15:35.177] {
  [21:15:35.177]     {
  [21:15:35.177]         ...future.startTime <- base::Sys.time()
  [21:15:35.177]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.177]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.177]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.177]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.177]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.177]         {
  [21:15:35.177]             {
  [21:15:35.177]                 {
  [21:15:35.177]                   {
  [21:15:35.177]                     base::local({
  [21:15:35.177]                       has_future <- base::requireNamespace("future", 
  [21:15:35.177]                         quietly = TRUE)
  [21:15:35.177]                       version <- if (has_future) 
  [21:15:35.177]                         utils::packageVersion("future")
  [21:15:35.177]                       else NULL
  [21:15:35.177]                       if (!has_future || version < "1.8.0") {
  [21:15:35.177]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.177]                           "", base::R.version$version.string), 
  [21:15:35.177]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.177]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.177]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.177]                             "release", "version")], collapse = " "), 
  [21:15:35.177]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.177]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.177]                           info)
  [21:15:35.177]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.177]                         if (!has_future) {
  [21:15:35.177]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.177]                             info)
  [21:15:35.177]                         }
  [21:15:35.177]                         else {
  [21:15:35.177]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.177]                             info, version)
  [21:15:35.177]                         }
  [21:15:35.177]                         base::stop(msg)
  [21:15:35.177]                       }
  [21:15:35.177]                     })
  [21:15:35.177]                   }
  [21:15:35.177]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.177]                   base::options(mc.cores = 1L)
  [21:15:35.177]                 }
  [21:15:35.177]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:35.177]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:35.177]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.177]             }
  [21:15:35.177]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.177]         }
  [21:15:35.177]     }
  [21:15:35.177]     if (base::is.na(TRUE)) {
  [21:15:35.177]     }
  [21:15:35.177]     else {
  [21:15:35.177]         if (TRUE) {
  [21:15:35.177]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.177]                 open = "w")
  [21:15:35.177]         }
  [21:15:35.177]         else {
  [21:15:35.177]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.177]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.177]         }
  [21:15:35.177]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.177]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.177]             base::sink(type = "output", split = FALSE)
  [21:15:35.177]             base::close(...future.stdout)
  [21:15:35.177]         }, add = TRUE)
  [21:15:35.177]     }
  [21:15:35.177]     ...future.frame <- base::sys.nframe()
  [21:15:35.177]     ...future.conditions <- base::list()
  [21:15:35.177]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.177]     ...future.result <- base::tryCatch({
  [21:15:35.177]         base::withCallingHandlers({
  [21:15:35.177]             ...future.value <- base::withVisible(base::local({
  [21:15:35.177]                 sample(x, size = 1L)
  [21:15:35.177]             }))
  [21:15:35.177]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.177]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.177]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.177]                 version = "1.8")
  [21:15:35.177]         }, condition = base::local({
  [21:15:35.177]             c <- base::c
  [21:15:35.177]             inherits <- base::inherits
  [21:15:35.177]             invokeRestart <- base::invokeRestart
  [21:15:35.177]             length <- base::length
  [21:15:35.177]             list <- base::list
  [21:15:35.177]             seq.int <- base::seq.int
  [21:15:35.177]             signalCondition <- base::signalCondition
  [21:15:35.177]             sys.calls <- base::sys.calls
  [21:15:35.177]             Sys.time <- base::Sys.time
  [21:15:35.177]             `[[` <- base::`[[`
  [21:15:35.177]             `+` <- base::`+`
  [21:15:35.177]             `<<-` <- base::`<<-`
  [21:15:35.177]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.177]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.177]                   3L)]
  [21:15:35.177]             }
  [21:15:35.177]             function(cond) {
  [21:15:35.177]                 if (inherits(cond, "error")) {
  [21:15:35.177]                   sessionInformation <- function() {
  [21:15:35.177]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.177]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.177]                       search = base::search(), system = base::Sys.info())
  [21:15:35.177]                   }
  [21:15:35.177]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.177]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.177]                     cond$call), session = sessionInformation(), 
  [21:15:35.177]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.177]                   signalCondition(cond)
  [21:15:35.177]                 }
  [21:15:35.177]                 else if (inherits(cond, "condition")) {
  [21:15:35.177]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.177]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.177]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.177]                   if (!signal) {
  [21:15:35.177]                     muffleCondition <- function (cond) 
  [21:15:35.177]                     {
  [21:15:35.177]                       inherits <- base::inherits
  [21:15:35.177]                       invokeRestart <- base::invokeRestart
  [21:15:35.177]                       muffled <- FALSE
  [21:15:35.177]                       if (inherits(cond, "message")) {
  [21:15:35.177]                         invokeRestart("muffleMessage")
  [21:15:35.177]                         muffled <- TRUE
  [21:15:35.177]                       }
  [21:15:35.177]                       else if (inherits(cond, "warning")) {
  [21:15:35.177]                         invokeRestart("muffleWarning")
  [21:15:35.177]                         muffled <- TRUE
  [21:15:35.177]                       }
  [21:15:35.177]                       else if (inherits(cond, "condition")) {
  [21:15:35.177]                         computeRestarts <- base::computeRestarts
  [21:15:35.177]                         grepl <- base::grepl
  [21:15:35.177]                         is.null <- base::is.null
  [21:15:35.177]                         restarts <- computeRestarts(cond)
  [21:15:35.177]                         for (restart in restarts) {
  [21:15:35.177]                           name <- restart$name
  [21:15:35.177]                           if (is.null(name)) 
  [21:15:35.177]                             next
  [21:15:35.177]                           if (!grepl("^muffle", name)) 
  [21:15:35.177]                             next
  [21:15:35.177]                           invokeRestart(restart)
  [21:15:35.177]                           muffled <- TRUE
  [21:15:35.177]                           break
  [21:15:35.177]                         }
  [21:15:35.177]                       }
  [21:15:35.177]                       invisible(muffled)
  [21:15:35.177]                     }
  [21:15:35.177]                     muffleCondition(cond)
  [21:15:35.177]                   }
  [21:15:35.177]                 }
  [21:15:35.177]             }
  [21:15:35.177]         }))
  [21:15:35.177]     }, error = function(ex) {
  [21:15:35.177]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.177]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.177]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.177]     }, finally = {
  [21:15:35.177]         {
  [21:15:35.177]             {
  [21:15:35.177]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.177]             }
  [21:15:35.177]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.177]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.177]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.177]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.177]             {
  [21:15:35.177]                 if (substitute) 
  [21:15:35.177]                   expr <- substitute(expr)
  [21:15:35.177]                 if (is.function(workers)) 
  [21:15:35.177]                   workers <- workers()
  [21:15:35.177]                 workers <- as.integer(workers)
  [21:15:35.177]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.177]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.177]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.177]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.177]                     local = TRUE, label = label, ...))
  [21:15:35.177]                 }
  [21:15:35.177]                 oopts <- options(mc.cores = workers)
  [21:15:35.177]                 on.exit(options(oopts))
  [21:15:35.177]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.177]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.177]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.177]                   label = label, ...)
  [21:15:35.177]                 if (!future$lazy) 
  [21:15:35.177]                   future <- run(future)
  [21:15:35.177]                 invisible(future)
  [21:15:35.177]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.177]         }
  [21:15:35.177]         base::options(...future.oldOptions)
  [21:15:35.177]     })
  [21:15:35.177]     Sys.time
  [21:15:35.177]     if (base::is.na(TRUE)) {
  [21:15:35.177]     }
  [21:15:35.177]     else {
  [21:15:35.177]         base::sink(type = "output", split = FALSE)
  [21:15:35.177]         if (TRUE) {
  [21:15:35.177]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.177]         }
  [21:15:35.177]         else {
  [21:15:35.177]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.177]         }
  [21:15:35.177]         base::close(...future.stdout)
  [21:15:35.177]         ...future.stdout <- NULL
  [21:15:35.177]     }
  [21:15:35.177]     ...future.result$conditions <- ...future.conditions
  [21:15:35.177]     ...future.result
  [21:15:35.177] }
  [21:15:35.182] requestCore(): workers = 2
  [21:15:35.192] MulticoreFuture started
  [21:15:35.194] getGlobalsAndPackages() ...
  [21:15:35.195] Searching for globals...
  [21:15:35.198] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.199] Searching for globals ... DONE
  [21:15:35.199] Resolving globals: FALSE
  [21:15:35.200] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.201] - globals: [1] 'x'
  [21:15:35.201] 
  [21:15:35.201] getGlobalsAndPackages() ... DONE
  [21:15:35.204] Packages needed by the future expression (n = 0): <none>
  [21:15:35.204] Packages needed by future strategies (n = 0): <none>
  [21:15:35.209] plan(): Setting new future strategy stack:
  [21:15:35.210] List of future strategies:
  [21:15:35.210] 1. sequential:
  [21:15:35.210]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.210]    - tweaked: FALSE
  [21:15:35.210]    - call: NULL
  [21:15:35.211] plan(): nbrOfWorkers() = 1
  [21:15:35.213] plan(): Setting new future strategy stack:
  [21:15:35.213] List of future strategies:
  [21:15:35.213] 1. multicore:
  [21:15:35.213]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.213]    - tweaked: FALSE
  [21:15:35.213]    - call: plan(strategy)
  [21:15:35.210] {
  [21:15:35.210]     {
  [21:15:35.210]         ...future.startTime <- base::Sys.time()
  [21:15:35.210]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.210]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.210]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.210]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.210]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.210]         {
  [21:15:35.210]             {
  [21:15:35.210]                 {
  [21:15:35.210]                   {
  [21:15:35.210]                     base::local({
  [21:15:35.210]                       has_future <- base::requireNamespace("future", 
  [21:15:35.210]                         quietly = TRUE)
  [21:15:35.210]                       version <- if (has_future) 
  [21:15:35.210]                         utils::packageVersion("future")
  [21:15:35.210]                       else NULL
  [21:15:35.210]                       if (!has_future || version < "1.8.0") {
  [21:15:35.210]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.210]                           "", base::R.version$version.string), 
  [21:15:35.210]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.210]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.210]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.210]                             "release", "version")], collapse = " "), 
  [21:15:35.210]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.210]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.210]                           info)
  [21:15:35.210]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.210]                         if (!has_future) {
  [21:15:35.210]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.210]                             info)
  [21:15:35.210]                         }
  [21:15:35.210]                         else {
  [21:15:35.210]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.210]                             info, version)
  [21:15:35.210]                         }
  [21:15:35.210]                         base::stop(msg)
  [21:15:35.210]                       }
  [21:15:35.210]                     })
  [21:15:35.210]                   }
  [21:15:35.210]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.210]                   base::options(mc.cores = 1L)
  [21:15:35.210]                 }
  [21:15:35.210]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:35.210]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:35.210]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.210]             }
  [21:15:35.210]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.210]         }
  [21:15:35.210]     }
  [21:15:35.210]     if (base::is.na(TRUE)) {
  [21:15:35.210]     }
  [21:15:35.210]     else {
  [21:15:35.210]         if (TRUE) {
  [21:15:35.210]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.210]                 open = "w")
  [21:15:35.210]         }
  [21:15:35.210]         else {
  [21:15:35.210]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.210]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.210]         }
  [21:15:35.210]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.210]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.210]             base::sink(type = "output", split = FALSE)
  [21:15:35.210]             base::close(...future.stdout)
  [21:15:35.210]         }, add = TRUE)
  [21:15:35.210]     }
  [21:15:35.210]     ...future.frame <- base::sys.nframe()
  [21:15:35.210]     ...future.conditions <- base::list()
  [21:15:35.210]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.210]     ...future.result <- base::tryCatch({
  [21:15:35.210]         base::withCallingHandlers({
  [21:15:35.210]             ...future.value <- base::withVisible(base::local({
  [21:15:35.210]                 sample(x, size = 1L)
  [21:15:35.210]             }))
  [21:15:35.210]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.210]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.210]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.210]                 version = "1.8")
  [21:15:35.210]         }, condition = base::local({
  [21:15:35.210]             c <- base::c
  [21:15:35.210]             inherits <- base::inherits
  [21:15:35.210]             invokeRestart <- base::invokeRestart
  [21:15:35.210]             length <- base::length
  [21:15:35.210]             list <- base::list
  [21:15:35.210]             seq.int <- base::seq.int
  [21:15:35.210]             signalCondition <- base::signalCondition
  [21:15:35.210]             sys.calls <- base::sys.calls
  [21:15:35.210]             Sys.time <- base::Sys.time
  [21:15:35.210]             `[[` <- base::`[[`
  [21:15:35.210]             `+` <- base::`+`
  [21:15:35.210]             `<<-` <- base::`<<-`
  [21:15:35.210]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.210]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.210]                   3L)]
  [21:15:35.210]             }
  [21:15:35.210]             function(cond) {
  [21:15:35.210]                 if (inherits(cond, "error")) {
  [21:15:35.210]                   sessionInformation <- function() {
  [21:15:35.210]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.210]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.210]                       search = base::search(), system = base::Sys.info())
  [21:15:35.210]                   }
  [21:15:35.210]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.210]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.210]                     cond$call), session = sessionInformation(), 
  [21:15:35.210]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.210]                   signalCondition(cond)
  [21:15:35.210]                 }
  [21:15:35.210]                 else if (inherits(cond, "condition")) {
  [21:15:35.210]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.210]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.210]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.210]                   if (!signal) {
  [21:15:35.210]                     muffleCondition <- function (cond) 
  [21:15:35.210]                     {
  [21:15:35.210]                       inherits <- base::inherits
  [21:15:35.210]                       invokeRestart <- base::invokeRestart
  [21:15:35.210]                       muffled <- FALSE
  [21:15:35.210]                       if (inherits(cond, "message")) {
  [21:15:35.210]                         invokeRestart("muffleMessage")
  [21:15:35.210]                         muffled <- TRUE
  [21:15:35.210]                       }
  [21:15:35.210]                       else if (inherits(cond, "warning")) {
  [21:15:35.210]                         invokeRestart("muffleWarning")
  [21:15:35.210]                         muffled <- TRUE
  [21:15:35.210]                       }
  [21:15:35.210]                       else if (inherits(cond, "condition")) {
  [21:15:35.210]                         computeRestarts <- base::computeRestarts
  [21:15:35.210]                         grepl <- base::grepl
  [21:15:35.210]                         is.null <- base::is.null
  [21:15:35.210]                         restarts <- computeRestarts(cond)
  [21:15:35.210]                         for (restart in restarts) {
  [21:15:35.210]                           name <- restart$name
  [21:15:35.210]                           if (is.null(name)) 
  [21:15:35.210]                             next
  [21:15:35.210]                           if (!grepl("^muffle", name)) 
  [21:15:35.210]                             next
  [21:15:35.210]                           invokeRestart(restart)
  [21:15:35.210]                           muffled <- TRUE
  [21:15:35.210]                           break
  [21:15:35.210]                         }
  [21:15:35.210]                       }
  [21:15:35.210]                       invisible(muffled)
  [21:15:35.210]                     }
  [21:15:35.210]                     muffleCondition(cond)
  [21:15:35.210]                   }
  [21:15:35.210]                 }
  [21:15:35.210]             }
  [21:15:35.210]         }))
  [21:15:35.210]     }, error = function(ex) {
  [21:15:35.210]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.210]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.210]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.210]     }, finally = {
  [21:15:35.210]         {
  [21:15:35.210]             {
  [21:15:35.210]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.210]             }
  [21:15:35.210]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.210]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.210]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.210]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.210]             {
  [21:15:35.210]                 if (substitute) 
  [21:15:35.210]                   expr <- substitute(expr)
  [21:15:35.210]                 if (is.function(workers)) 
  [21:15:35.210]                   workers <- workers()
  [21:15:35.210]                 workers <- as.integer(workers)
  [21:15:35.210]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.210]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.210]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.210]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.210]                     local = TRUE, label = label, ...))
  [21:15:35.210]                 }
  [21:15:35.210]                 oopts <- options(mc.cores = workers)
  [21:15:35.210]                 on.exit(options(oopts))
  [21:15:35.210]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.210]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.210]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.210]                   label = label, ...)
  [21:15:35.210]                 if (!future$lazy) 
  [21:15:35.210]                   future <- run(future)
  [21:15:35.210]                 invisible(future)
  [21:15:35.210]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.210]         }
  [21:15:35.210]         base::options(...future.oldOptions)
  [21:15:35.210]     })
  [21:15:35.210]     Sys.time
  [21:15:35.210]     if (base::is.na(TRUE)) {
  [21:15:35.210]     }
  [21:15:35.210]     else {
  [21:15:35.210]         base::sink(type = "output", split = FALSE)
  [21:15:35.210]         if (TRUE) {
  [21:15:35.210]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.210]         }
  [21:15:35.210]         else {
  [21:15:35.210]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.210]         }
  [21:15:35.210]         base::close(...future.stdout)
  [21:15:35.210]         ...future.stdout <- NULL
  [21:15:35.210]     }
  [21:15:35.210]     ...future.result$conditions <- ...future.conditions
  [21:15:35.210]     ...future.result
  [21:15:35.210] }
  [21:15:35.215] plan(): nbrOfWorkers() = 2
  [21:15:35.221] requestCore(): workers = 2
  [21:15:35.223] Poll #1 (0): usedCores() = 2, workers = 2
  [21:15:35.263] MulticoreFuture started
  [21:15:35.265] getGlobalsAndPackages() ...
  [21:15:35.267] Searching for globals...
  [21:15:35.274] plan(): Setting new future strategy stack:
  [21:15:35.275] List of future strategies:
  [21:15:35.275] 1. sequential:
  [21:15:35.275]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.275]    - tweaked: FALSE
  [21:15:35.275]    - call: NULL
  [21:15:35.276] plan(): nbrOfWorkers() = 1
  [21:15:35.278] plan(): Setting new future strategy stack:
  [21:15:35.279] List of future strategies:
  [21:15:35.279] 1. multicore:
  [21:15:35.279]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.279]    - tweaked: FALSE
  [21:15:35.279]    - call: plan(strategy)
  [21:15:35.281] plan(): nbrOfWorkers() = 2
  [21:15:35.294] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.295] Searching for globals ... DONE
  [21:15:35.295] Resolving globals: FALSE
  [21:15:35.296] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.297] - globals: [1] 'x'
  [21:15:35.297] 
  [21:15:35.298] getGlobalsAndPackages() ... DONE
  [21:15:35.300] Packages needed by the future expression (n = 0): <none>
  [21:15:35.301] Packages needed by future strategies (n = 0): <none>
  [21:15:35.306] {
  [21:15:35.306]     {
  [21:15:35.306]         ...future.startTime <- base::Sys.time()
  [21:15:35.306]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.306]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.306]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.306]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.306]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.306]         {
  [21:15:35.306]             {
  [21:15:35.306]                 {
  [21:15:35.306]                   {
  [21:15:35.306]                     base::local({
  [21:15:35.306]                       has_future <- base::requireNamespace("future", 
  [21:15:35.306]                         quietly = TRUE)
  [21:15:35.306]                       version <- if (has_future) 
  [21:15:35.306]                         utils::packageVersion("future")
  [21:15:35.306]                       else NULL
  [21:15:35.306]                       if (!has_future || version < "1.8.0") {
  [21:15:35.306]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.306]                           "", base::R.version$version.string), 
  [21:15:35.306]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.306]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.306]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.306]                             "release", "version")], collapse = " "), 
  [21:15:35.306]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.306]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.306]                           info)
  [21:15:35.306]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.306]                         if (!has_future) {
  [21:15:35.306]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.306]                             info)
  [21:15:35.306]                         }
  [21:15:35.306]                         else {
  [21:15:35.306]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.306]                             info, version)
  [21:15:35.306]                         }
  [21:15:35.306]                         base::stop(msg)
  [21:15:35.306]                       }
  [21:15:35.306]                     })
  [21:15:35.306]                   }
  [21:15:35.306]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.306]                   base::options(mc.cores = 1L)
  [21:15:35.306]                 }
  [21:15:35.306]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:35.306]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:35.306]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.306]             }
  [21:15:35.306]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.306]         }
  [21:15:35.306]     }
  [21:15:35.306]     if (base::is.na(TRUE)) {
  [21:15:35.306]     }
  [21:15:35.306]     else {
  [21:15:35.306]         if (TRUE) {
  [21:15:35.306]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.306]                 open = "w")
  [21:15:35.306]         }
  [21:15:35.306]         else {
  [21:15:35.306]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.306]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.306]         }
  [21:15:35.306]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.306]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.306]             base::sink(type = "output", split = FALSE)
  [21:15:35.306]             base::close(...future.stdout)
  [21:15:35.306]         }, add = TRUE)
  [21:15:35.306]     }
  [21:15:35.306]     ...future.frame <- base::sys.nframe()
  [21:15:35.306]     ...future.conditions <- base::list()
  [21:15:35.306]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.306]     ...future.result <- base::tryCatch({
  [21:15:35.306]         base::withCallingHandlers({
  [21:15:35.306]             ...future.value <- base::withVisible(base::local({
  [21:15:35.306]                 sample(x, size = 1L)
  [21:15:35.306]             }))
  [21:15:35.306]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.306]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.306]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.306]                 version = "1.8")
  [21:15:35.306]         }, condition = base::local({
  [21:15:35.306]             c <- base::c
  [21:15:35.306]             inherits <- base::inherits
  [21:15:35.306]             invokeRestart <- base::invokeRestart
  [21:15:35.306]             length <- base::length
  [21:15:35.306]             list <- base::list
  [21:15:35.306]             seq.int <- base::seq.int
  [21:15:35.306]             signalCondition <- base::signalCondition
  [21:15:35.306]             sys.calls <- base::sys.calls
  [21:15:35.306]             Sys.time <- base::Sys.time
  [21:15:35.306]             `[[` <- base::`[[`
  [21:15:35.306]             `+` <- base::`+`
  [21:15:35.306]             `<<-` <- base::`<<-`
  [21:15:35.306]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.306]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.306]                   3L)]
  [21:15:35.306]             }
  [21:15:35.306]             function(cond) {
  [21:15:35.306]                 if (inherits(cond, "error")) {
  [21:15:35.306]                   sessionInformation <- function() {
  [21:15:35.306]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.306]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.306]                       search = base::search(), system = base::Sys.info())
  [21:15:35.306]                   }
  [21:15:35.306]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.306]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.306]                     cond$call), session = sessionInformation(), 
  [21:15:35.306]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.306]                   signalCondition(cond)
  [21:15:35.306]                 }
  [21:15:35.306]                 else if (inherits(cond, "condition")) {
  [21:15:35.306]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.306]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.306]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.306]                   if (!signal) {
  [21:15:35.306]                     muffleCondition <- function (cond) 
  [21:15:35.306]                     {
  [21:15:35.306]                       inherits <- base::inherits
  [21:15:35.306]                       invokeRestart <- base::invokeRestart
  [21:15:35.306]                       muffled <- FALSE
  [21:15:35.306]                       if (inherits(cond, "message")) {
  [21:15:35.306]                         invokeRestart("muffleMessage")
  [21:15:35.306]                         muffled <- TRUE
  [21:15:35.306]                       }
  [21:15:35.306]                       else if (inherits(cond, "warning")) {
  [21:15:35.306]                         invokeRestart("muffleWarning")
  [21:15:35.306]                         muffled <- TRUE
  [21:15:35.306]                       }
  [21:15:35.306]                       else if (inherits(cond, "condition")) {
  [21:15:35.306]                         computeRestarts <- base::computeRestarts
  [21:15:35.306]                         grepl <- base::grepl
  [21:15:35.306]                         is.null <- base::is.null
  [21:15:35.306]                         restarts <- computeRestarts(cond)
  [21:15:35.306]                         for (restart in restarts) {
  [21:15:35.306]                           name <- restart$name
  [21:15:35.306]                           if (is.null(name)) 
  [21:15:35.306]                             next
  [21:15:35.306]                           if (!grepl("^muffle", name)) 
  [21:15:35.306]                             next
  [21:15:35.306]                           invokeRestart(restart)
  [21:15:35.306]                           muffled <- TRUE
  [21:15:35.306]                           break
  [21:15:35.306]                         }
  [21:15:35.306]                       }
  [21:15:35.306]                       invisible(muffled)
  [21:15:35.306]                     }
  [21:15:35.306]                     muffleCondition(cond)
  [21:15:35.306]                   }
  [21:15:35.306]                 }
  [21:15:35.306]             }
  [21:15:35.306]         }))
  [21:15:35.306]     }, error = function(ex) {
  [21:15:35.306]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.306]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.306]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.306]     }, finally = {
  [21:15:35.306]         {
  [21:15:35.306]             {
  [21:15:35.306]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.306]             }
  [21:15:35.306]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.306]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.306]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.306]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.306]             {
  [21:15:35.306]                 if (substitute) 
  [21:15:35.306]                   expr <- substitute(expr)
  [21:15:35.306]                 if (is.function(workers)) 
  [21:15:35.306]                   workers <- workers()
  [21:15:35.306]                 workers <- as.integer(workers)
  [21:15:35.306]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.306]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.306]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.306]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.306]                     local = TRUE, label = label, ...))
  [21:15:35.306]                 }
  [21:15:35.306]                 oopts <- options(mc.cores = workers)
  [21:15:35.306]                 on.exit(options(oopts))
  [21:15:35.306]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.306]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.306]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.306]                   label = label, ...)
  [21:15:35.306]                 if (!future$lazy) 
  [21:15:35.306]                   future <- run(future)
  [21:15:35.306]                 invisible(future)
  [21:15:35.306]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.306]         }
  [21:15:35.306]         base::options(...future.oldOptions)
  [21:15:35.306]     })
  [21:15:35.306]     Sys.time
  [21:15:35.306]     if (base::is.na(TRUE)) {
  [21:15:35.306]     }
  [21:15:35.306]     else {
  [21:15:35.306]         base::sink(type = "output", split = FALSE)
  [21:15:35.306]         if (TRUE) {
  [21:15:35.306]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.306]         }
  [21:15:35.306]         else {
  [21:15:35.306]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.306]         }
  [21:15:35.306]         base::close(...future.stdout)
  [21:15:35.306]         ...future.stdout <- NULL
  [21:15:35.306]     }
  [21:15:35.306]     ...future.result$conditions <- ...future.conditions
  [21:15:35.306]     ...future.result
  [21:15:35.306] }
  [21:15:35.327] requestCore(): workers = 2
  [21:15:35.328] Poll #1 (0): usedCores() = 2, workers = 2
  [21:15:35.382] MulticoreFuture started
  [21:15:35.383] resolve() on list ...
  [21:15:35.384]  recursive: 0
  [21:15:35.384]  length: 4
  [21:15:35.384] 
  [21:15:35.385] Future #1
  [21:15:35.385] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [21:15:35.386] - nx: 4
  [21:15:35.386] - relay: TRUE
  [21:15:35.386] - stdout: TRUE
  [21:15:35.386] - signal: TRUE
  [21:15:35.387] - resignal: FALSE
  [21:15:35.387] - force: TRUE
  [21:15:35.387] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:35.388] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:35.388]  - until=1
  [21:15:35.388]  - relaying element #1
  [21:15:35.389] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.389] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.390] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [21:15:35.390]  length: 3 (resolved future 1)
  [21:15:35.390] Future #2
  [21:15:35.391] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [21:15:35.391] - nx: 4
  [21:15:35.391] - relay: TRUE
  [21:15:35.392] - stdout: TRUE
  [21:15:35.392] - signal: TRUE
  [21:15:35.392] - resignal: FALSE
  [21:15:35.393] - force: TRUE
  [21:15:35.393] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.393] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.398] plan(): Setting new future strategy stack:
  [21:15:35.398] List of future strategies:
  [21:15:35.398] 1. sequential:
  [21:15:35.398]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.398]    - tweaked: FALSE
  [21:15:35.398]    - call: NULL
  [21:15:35.400] plan(): nbrOfWorkers() = 1
  [21:15:35.401] plan(): Setting new future strategy stack:
  [21:15:35.402] List of future strategies:
  [21:15:35.402] 1. multicore:
  [21:15:35.402]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.402]    - tweaked: FALSE
  [21:15:35.402]    - call: plan(strategy)
  [21:15:35.403] plan(): nbrOfWorkers() = 2
  [21:15:35.394]  - until=2
  [21:15:35.410]  - relaying element #2
  [21:15:35.411] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.411] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.411] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [21:15:35.412]  length: 2 (resolved future 2)
  [21:15:35.412] Future #3
  [21:15:35.414] signalConditionsASAP(MulticoreFuture, pos=3) ...
  [21:15:35.414] - nx: 4
  [21:15:35.414] - relay: TRUE
  [21:15:35.415] - stdout: TRUE
  [21:15:35.415] - signal: TRUE
  [21:15:35.415] - resignal: FALSE
  [21:15:35.415] - force: TRUE
  [21:15:35.416] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.416] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.416]  - until=3
  [21:15:35.417]  - relaying element #3
  [21:15:35.417] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.417] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.418] signalConditionsASAP(MulticoreFuture, pos=3) ... done
  [21:15:35.418]  length: 1 (resolved future 3)
  [21:15:35.418] Future #4
  [21:15:35.444] signalConditionsASAP(MulticoreFuture, pos=4) ...
  [21:15:35.445] - nx: 4
  [21:15:35.445] - relay: TRUE
  [21:15:35.446] - stdout: TRUE
  [21:15:35.446] - signal: TRUE
  [21:15:35.446] - resignal: FALSE
  [21:15:35.446] - force: TRUE
  [21:15:35.447] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.447] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.447]  - until=4
  [21:15:35.448]  - relaying element #4
  [21:15:35.448] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:35.448] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:35.449] signalConditionsASAP(MulticoreFuture, pos=4) ... done
  [21:15:35.449]  length: 0 (resolved future 4)
  [21:15:35.449] Relaying remaining futures
  [21:15:35.450] signalConditionsASAP(NULL, pos=0) ...
  [21:15:35.450] - nx: 4
  [21:15:35.450] - relay: TRUE
  [21:15:35.451] - stdout: TRUE
  [21:15:35.451] - signal: TRUE
  [21:15:35.451] - resignal: FALSE
  [21:15:35.451] - force: TRUE
  [21:15:35.452] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:35.452] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
   - flush all
  [21:15:35.452] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:35.453] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
  [21:15:35.453] signalConditionsASAP(NULL, pos=0) ... done
  [21:15:35.453] resolve() on list ... DONE
  [[1]]
  [1] 2
  
  [[2]]
  [1] 0
  
  [[3]]
  [1] 0
  
  [[4]]
  [1] 1
  
  [21:15:35.455] getGlobalsAndPackages() ...
  [21:15:35.455] Searching for globals...
  [21:15:35.457] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.474] Searching for globals ... DONE
  [21:15:35.474] Resolving globals: FALSE
  [21:15:35.475] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.475] - globals: [1] 'x'
  [21:15:35.476] 
  [21:15:35.476] getGlobalsAndPackages() ... DONE
  [21:15:35.478] Packages needed by the future expression (n = 0): <none>
  [21:15:35.478] Packages needed by future strategies (n = 0): <none>
  [21:15:35.483] {
  [21:15:35.483]     {
  [21:15:35.483]         ...future.startTime <- base::Sys.time()
  [21:15:35.483]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.483]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.483]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.483]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.483]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.483]         {
  [21:15:35.483]             {
  [21:15:35.483]                 {
  [21:15:35.483]                   {
  [21:15:35.483]                     base::local({
  [21:15:35.483]                       has_future <- base::requireNamespace("future", 
  [21:15:35.483]                         quietly = TRUE)
  [21:15:35.483]                       version <- if (has_future) 
  [21:15:35.483]                         utils::packageVersion("future")
  [21:15:35.483]                       else NULL
  [21:15:35.483]                       if (!has_future || version < "1.8.0") {
  [21:15:35.483]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.483]                           "", base::R.version$version.string), 
  [21:15:35.483]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.483]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.483]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.483]                             "release", "version")], collapse = " "), 
  [21:15:35.483]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.483]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.483]                           info)
  [21:15:35.483]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.483]                         if (!has_future) {
  [21:15:35.483]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.483]                             info)
  [21:15:35.483]                         }
  [21:15:35.483]                         else {
  [21:15:35.483]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.483]                             info, version)
  [21:15:35.483]                         }
  [21:15:35.483]                         base::stop(msg)
  [21:15:35.483]                       }
  [21:15:35.483]                     })
  [21:15:35.483]                   }
  [21:15:35.483]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.483]                   base::options(mc.cores = 1L)
  [21:15:35.483]                 }
  [21:15:35.483]                 base::assign(".Random.seed", c(10407L, -94575036L, 
  [21:15:35.483]                 -24861725L, 357812871L, 346211554L, -1301022835L, 
  [21:15:35.483]                 440649733L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.483]             }
  [21:15:35.483]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.483]         }
  [21:15:35.483]     }
  [21:15:35.483]     if (base::is.na(TRUE)) {
  [21:15:35.483]     }
  [21:15:35.483]     else {
  [21:15:35.483]         if (TRUE) {
  [21:15:35.483]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.483]                 open = "w")
  [21:15:35.483]         }
  [21:15:35.483]         else {
  [21:15:35.483]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.483]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.483]         }
  [21:15:35.483]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.483]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.483]             base::sink(type = "output", split = FALSE)
  [21:15:35.483]             base::close(...future.stdout)
  [21:15:35.483]         }, add = TRUE)
  [21:15:35.483]     }
  [21:15:35.483]     ...future.frame <- base::sys.nframe()
  [21:15:35.483]     ...future.conditions <- base::list()
  [21:15:35.483]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.483]     ...future.result <- base::tryCatch({
  [21:15:35.483]         base::withCallingHandlers({
  [21:15:35.483]             ...future.value <- base::withVisible(base::local({
  [21:15:35.483]                 sample(x, size = 1L)
  [21:15:35.483]             }))
  [21:15:35.483]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.483]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.483]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.483]                 version = "1.8")
  [21:15:35.483]         }, condition = base::local({
  [21:15:35.483]             c <- base::c
  [21:15:35.483]             inherits <- base::inherits
  [21:15:35.483]             invokeRestart <- base::invokeRestart
  [21:15:35.483]             length <- base::length
  [21:15:35.483]             list <- base::list
  [21:15:35.483]             seq.int <- base::seq.int
  [21:15:35.483]             signalCondition <- base::signalCondition
  [21:15:35.483]             sys.calls <- base::sys.calls
  [21:15:35.483]             Sys.time <- base::Sys.time
  [21:15:35.483]             `[[` <- base::`[[`
  [21:15:35.483]             `+` <- base::`+`
  [21:15:35.483]             `<<-` <- base::`<<-`
  [21:15:35.483]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.483]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.483]                   3L)]
  [21:15:35.483]             }
  [21:15:35.483]             function(cond) {
  [21:15:35.483]                 if (inherits(cond, "error")) {
  [21:15:35.483]                   sessionInformation <- function() {
  [21:15:35.483]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.483]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.483]                       search = base::search(), system = base::Sys.info())
  [21:15:35.483]                   }
  [21:15:35.483]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.483]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.483]                     cond$call), session = sessionInformation(), 
  [21:15:35.483]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.483]                   signalCondition(cond)
  [21:15:35.483]                 }
  [21:15:35.483]                 else if (inherits(cond, "condition")) {
  [21:15:35.483]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.483]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.483]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.483]                   if (!signal) {
  [21:15:35.483]                     muffleCondition <- function (cond) 
  [21:15:35.483]                     {
  [21:15:35.483]                       inherits <- base::inherits
  [21:15:35.483]                       invokeRestart <- base::invokeRestart
  [21:15:35.483]                       muffled <- FALSE
  [21:15:35.483]                       if (inherits(cond, "message")) {
  [21:15:35.483]                         invokeRestart("muffleMessage")
  [21:15:35.483]                         muffled <- TRUE
  [21:15:35.483]                       }
  [21:15:35.483]                       else if (inherits(cond, "warning")) {
  [21:15:35.483]                         invokeRestart("muffleWarning")
  [21:15:35.483]                         muffled <- TRUE
  [21:15:35.483]                       }
  [21:15:35.483]                       else if (inherits(cond, "condition")) {
  [21:15:35.483]                         computeRestarts <- base::computeRestarts
  [21:15:35.483]                         grepl <- base::grepl
  [21:15:35.483]                         is.null <- base::is.null
  [21:15:35.483]                         restarts <- computeRestarts(cond)
  [21:15:35.483]                         for (restart in restarts) {
  [21:15:35.483]                           name <- restart$name
  [21:15:35.483]                           if (is.null(name)) 
  [21:15:35.483]                             next
  [21:15:35.483]                           if (!grepl("^muffle", name)) 
  [21:15:35.483]                             next
  [21:15:35.483]                           invokeRestart(restart)
  [21:15:35.483]                           muffled <- TRUE
  [21:15:35.483]                           break
  [21:15:35.483]                         }
  [21:15:35.483]                       }
  [21:15:35.483]                       invisible(muffled)
  [21:15:35.483]                     }
  [21:15:35.483]                     muffleCondition(cond)
  [21:15:35.483]                   }
  [21:15:35.483]                 }
  [21:15:35.483]             }
  [21:15:35.483]         }))
  [21:15:35.483]     }, error = function(ex) {
  [21:15:35.483]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.483]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.483]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.483]     }, finally = {
  [21:15:35.483]         {
  [21:15:35.483]             {
  [21:15:35.483]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.483]             }
  [21:15:35.483]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.483]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.483]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.483]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.483]             {
  [21:15:35.483]                 if (substitute) 
  [21:15:35.483]                   expr <- substitute(expr)
  [21:15:35.483]                 if (is.function(workers)) 
  [21:15:35.483]                   workers <- workers()
  [21:15:35.483]                 workers <- as.integer(workers)
  [21:15:35.483]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.483]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.483]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.483]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.483]                     local = TRUE, label = label, ...))
  [21:15:35.483]                 }
  [21:15:35.483]                 oopts <- options(mc.cores = workers)
  [21:15:35.483]                 on.exit(options(oopts))
  [21:15:35.483]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.483]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.483]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.483]                   label = label, ...)
  [21:15:35.483]                 if (!future$lazy) 
  [21:15:35.483]                   future <- run(future)
  [21:15:35.483]                 invisible(future)
  [21:15:35.483]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.483]         }
  [21:15:35.483]         base::options(...future.oldOptions)
  [21:15:35.483]     })
  [21:15:35.483]     Sys.time
  [21:15:35.483]     if (base::is.na(TRUE)) {
  [21:15:35.483]     }
  [21:15:35.483]     else {
  [21:15:35.483]         base::sink(type = "output", split = FALSE)
  [21:15:35.483]         if (TRUE) {
  [21:15:35.483]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.483]         }
  [21:15:35.483]         else {
  [21:15:35.483]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.483]         }
  [21:15:35.483]         base::close(...future.stdout)
  [21:15:35.483]         ...future.stdout <- NULL
  [21:15:35.483]     }
  [21:15:35.483]     ...future.result$conditions <- ...future.conditions
  [21:15:35.483]     ...future.result
  [21:15:35.483] }
  [21:15:35.486] requestCore(): workers = 2
  [21:15:35.502] plan(): Setting new future strategy stack:
  [21:15:35.489] MulticoreFuture started
  [21:15:35.507] getGlobalsAndPackages() ...
  [21:15:35.508] Searching for globals...
  [21:15:35.511] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.512] Searching for globals ... DONE
  [21:15:35.512] Resolving globals: FALSE
  [21:15:35.513] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.514] - globals: [1] 'x'
  [21:15:35.514] 
  [21:15:35.514] getGlobalsAndPackages() ... DONE
  [21:15:35.517] Packages needed by the future expression (n = 0): <none>
  [21:15:35.518] Packages needed by future strategies (n = 0): <none>
  [21:15:35.503] List of future strategies:
  [21:15:35.503] 1. sequential:
  [21:15:35.503]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.503]    - tweaked: FALSE
  [21:15:35.503]    - call: NULL
  [21:15:35.519] plan(): nbrOfWorkers() = 1
  [21:15:35.521] plan(): Setting new future strategy stack:
  [21:15:35.521] List of future strategies:
  [21:15:35.521] 1. multicore:
  [21:15:35.521]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.521]    - tweaked: FALSE
  [21:15:35.521]    - call: plan(strategy)
  [21:15:35.523] plan(): nbrOfWorkers() = 2
  [21:15:35.539] {
  [21:15:35.539]     {
  [21:15:35.539]         ...future.startTime <- base::Sys.time()
  [21:15:35.539]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.539]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.539]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.539]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.539]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.539]         {
  [21:15:35.539]             {
  [21:15:35.539]                 {
  [21:15:35.539]                   {
  [21:15:35.539]                     base::local({
  [21:15:35.539]                       has_future <- base::requireNamespace("future", 
  [21:15:35.539]                         quietly = TRUE)
  [21:15:35.539]                       version <- if (has_future) 
  [21:15:35.539]                         utils::packageVersion("future")
  [21:15:35.539]                       else NULL
  [21:15:35.539]                       if (!has_future || version < "1.8.0") {
  [21:15:35.539]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.539]                           "", base::R.version$version.string), 
  [21:15:35.539]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.539]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.539]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.539]                             "release", "version")], collapse = " "), 
  [21:15:35.539]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.539]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.539]                           info)
  [21:15:35.539]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.539]                         if (!has_future) {
  [21:15:35.539]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.539]                             info)
  [21:15:35.539]                         }
  [21:15:35.539]                         else {
  [21:15:35.539]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.539]                             info, version)
  [21:15:35.539]                         }
  [21:15:35.539]                         base::stop(msg)
  [21:15:35.539]                       }
  [21:15:35.539]                     })
  [21:15:35.539]                   }
  [21:15:35.539]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.539]                   base::options(mc.cores = 1L)
  [21:15:35.539]                 }
  [21:15:35.539]                 base::assign(".Random.seed", c(10407L, -358246211L, 
  [21:15:35.539]                 -1411857254L, -488221791L, 1069515918L, -1720689715L, 
  [21:15:35.539]                 1070199760L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.539]             }
  [21:15:35.539]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.539]         }
  [21:15:35.539]     }
  [21:15:35.539]     if (base::is.na(TRUE)) {
  [21:15:35.539]     }
  [21:15:35.539]     else {
  [21:15:35.539]         if (TRUE) {
  [21:15:35.539]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.539]                 open = "w")
  [21:15:35.539]         }
  [21:15:35.539]         else {
  [21:15:35.539]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.539]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.539]         }
  [21:15:35.539]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.539]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.539]             base::sink(type = "output", split = FALSE)
  [21:15:35.539]             base::close(...future.stdout)
  [21:15:35.539]         }, add = TRUE)
  [21:15:35.539]     }
  [21:15:35.539]     ...future.frame <- base::sys.nframe()
  [21:15:35.539]     ...future.conditions <- base::list()
  [21:15:35.539]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.539]     ...future.result <- base::tryCatch({
  [21:15:35.539]         base::withCallingHandlers({
  [21:15:35.539]             ...future.value <- base::withVisible(base::local({
  [21:15:35.539]                 sample(x, size = 1L)
  [21:15:35.539]             }))
  [21:15:35.539]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.539]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.539]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.539]                 version = "1.8")
  [21:15:35.539]         }, condition = base::local({
  [21:15:35.539]             c <- base::c
  [21:15:35.539]             inherits <- base::inherits
  [21:15:35.539]             invokeRestart <- base::invokeRestart
  [21:15:35.539]             length <- base::length
  [21:15:35.539]             list <- base::list
  [21:15:35.539]             seq.int <- base::seq.int
  [21:15:35.539]             signalCondition <- base::signalCondition
  [21:15:35.539]             sys.calls <- base::sys.calls
  [21:15:35.539]             Sys.time <- base::Sys.time
  [21:15:35.539]             `[[` <- base::`[[`
  [21:15:35.539]             `+` <- base::`+`
  [21:15:35.539]             `<<-` <- base::`<<-`
  [21:15:35.539]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.539]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.539]                   3L)]
  [21:15:35.539]             }
  [21:15:35.539]             function(cond) {
  [21:15:35.539]                 if (inherits(cond, "error")) {
  [21:15:35.539]                   sessionInformation <- function() {
  [21:15:35.539]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.539]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.539]                       search = base::search(), system = base::Sys.info())
  [21:15:35.539]                   }
  [21:15:35.539]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.539]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.539]                     cond$call), session = sessionInformation(), 
  [21:15:35.539]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.539]                   signalCondition(cond)
  [21:15:35.539]                 }
  [21:15:35.539]                 else if (inherits(cond, "condition")) {
  [21:15:35.539]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.539]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.539]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.539]                   if (!signal) {
  [21:15:35.539]                     muffleCondition <- function (cond) 
  [21:15:35.539]                     {
  [21:15:35.539]                       inherits <- base::inherits
  [21:15:35.539]                       invokeRestart <- base::invokeRestart
  [21:15:35.539]                       muffled <- FALSE
  [21:15:35.539]                       if (inherits(cond, "message")) {
  [21:15:35.539]                         invokeRestart("muffleMessage")
  [21:15:35.539]                         muffled <- TRUE
  [21:15:35.539]                       }
  [21:15:35.539]                       else if (inherits(cond, "warning")) {
  [21:15:35.539]                         invokeRestart("muffleWarning")
  [21:15:35.539]                         muffled <- TRUE
  [21:15:35.539]                       }
  [21:15:35.539]                       else if (inherits(cond, "condition")) {
  [21:15:35.539]                         computeRestarts <- base::computeRestarts
  [21:15:35.539]                         grepl <- base::grepl
  [21:15:35.539]                         is.null <- base::is.null
  [21:15:35.539]                         restarts <- computeRestarts(cond)
  [21:15:35.539]                         for (restart in restarts) {
  [21:15:35.539]                           name <- restart$name
  [21:15:35.539]                           if (is.null(name)) 
  [21:15:35.539]                             next
  [21:15:35.539]                           if (!grepl("^muffle", name)) 
  [21:15:35.539]                             next
  [21:15:35.539]                           invokeRestart(restart)
  [21:15:35.539]                           muffled <- TRUE
  [21:15:35.539]                           break
  [21:15:35.539]                         }
  [21:15:35.539]                       }
  [21:15:35.539]                       invisible(muffled)
  [21:15:35.539]                     }
  [21:15:35.539]                     muffleCondition(cond)
  [21:15:35.539]                   }
  [21:15:35.539]                 }
  [21:15:35.539]             }
  [21:15:35.539]         }))
  [21:15:35.539]     }, error = function(ex) {
  [21:15:35.539]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.539]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.539]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.539]     }, finally = {
  [21:15:35.539]         {
  [21:15:35.539]             {
  [21:15:35.539]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.539]             }
  [21:15:35.539]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.539]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.539]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.539]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.539]             {
  [21:15:35.539]                 if (substitute) 
  [21:15:35.539]                   expr <- substitute(expr)
  [21:15:35.539]                 if (is.function(workers)) 
  [21:15:35.539]                   workers <- workers()
  [21:15:35.539]                 workers <- as.integer(workers)
  [21:15:35.539]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.539]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.539]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.539]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.539]                     local = TRUE, label = label, ...))
  [21:15:35.539]                 }
  [21:15:35.539]                 oopts <- options(mc.cores = workers)
  [21:15:35.539]                 on.exit(options(oopts))
  [21:15:35.539]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.539]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.539]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.539]                   label = label, ...)
  [21:15:35.539]                 if (!future$lazy) 
  [21:15:35.539]                   future <- run(future)
  [21:15:35.539]                 invisible(future)
  [21:15:35.539]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.539]         }
  [21:15:35.539]         base::options(...future.oldOptions)
  [21:15:35.539]     })
  [21:15:35.539]     Sys.time
  [21:15:35.539]     if (base::is.na(TRUE)) {
  [21:15:35.539]     }
  [21:15:35.539]     else {
  [21:15:35.539]         base::sink(type = "output", split = FALSE)
  [21:15:35.539]         if (TRUE) {
  [21:15:35.539]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.539]         }
  [21:15:35.539]         else {
  [21:15:35.539]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.539]         }
  [21:15:35.539]         base::close(...future.stdout)
  [21:15:35.539]         ...future.stdout <- NULL
  [21:15:35.539]     }
  [21:15:35.539]     ...future.result$conditions <- ...future.conditions
  [21:15:35.539]     ...future.result
  [21:15:35.539] }
  [21:15:35.544] requestCore(): workers = 2
  [21:15:35.547] MulticoreFuture started
  [21:15:35.549] getGlobalsAndPackages() ...
  [21:15:35.549] Searching for globals...
  [21:15:35.552] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.553] Searching for globals ... DONE
  [21:15:35.553] Resolving globals: FALSE
  [21:15:35.561] plan(): Setting new future strategy stack:
  [21:15:35.562] List of future strategies:
  [21:15:35.562] 1. sequential:
  [21:15:35.562]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.562]    - tweaked: FALSE
  [21:15:35.562]    - call: NULL
  [21:15:35.563] plan(): nbrOfWorkers() = 1
  [21:15:35.565] plan(): Setting new future strategy stack:
  [21:15:35.565] List of future strategies:
  [21:15:35.565] 1. multicore:
  [21:15:35.565]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.565]    - tweaked: FALSE
  [21:15:35.565]    - call: plan(strategy)
  [21:15:35.567] plan(): nbrOfWorkers() = 2
  [21:15:35.570] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.571] - globals: [1] 'x'
  [21:15:35.571] 
  [21:15:35.572] getGlobalsAndPackages() ... DONE
  [21:15:35.575] Packages needed by the future expression (n = 0): <none>
  [21:15:35.575] Packages needed by future strategies (n = 0): <none>
  [21:15:35.582] {
  [21:15:35.582]     {
  [21:15:35.582]         ...future.startTime <- base::Sys.time()
  [21:15:35.582]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.582]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.582]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.582]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.582]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.582]         {
  [21:15:35.582]             {
  [21:15:35.582]                 {
  [21:15:35.582]                   {
  [21:15:35.582]                     base::local({
  [21:15:35.582]                       has_future <- base::requireNamespace("future", 
  [21:15:35.582]                         quietly = TRUE)
  [21:15:35.582]                       version <- if (has_future) 
  [21:15:35.582]                         utils::packageVersion("future")
  [21:15:35.582]                       else NULL
  [21:15:35.582]                       if (!has_future || version < "1.8.0") {
  [21:15:35.582]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.582]                           "", base::R.version$version.string), 
  [21:15:35.582]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.582]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.582]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.582]                             "release", "version")], collapse = " "), 
  [21:15:35.582]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.582]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.582]                           info)
  [21:15:35.582]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.582]                         if (!has_future) {
  [21:15:35.582]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.582]                             info)
  [21:15:35.582]                         }
  [21:15:35.582]                         else {
  [21:15:35.582]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.582]                             info, version)
  [21:15:35.582]                         }
  [21:15:35.582]                         base::stop(msg)
  [21:15:35.582]                       }
  [21:15:35.582]                     })
  [21:15:35.582]                   }
  [21:15:35.582]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.582]                   base::options(mc.cores = 1L)
  [21:15:35.582]                 }
  [21:15:35.582]                 base::assign(".Random.seed", c(10407L, 1805183335L, 
  [21:15:35.582]                 -1982978684L, 1500882842L, -1897959390L, -204266259L, 
  [21:15:35.582]                 -2006625641L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.582]             }
  [21:15:35.582]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.582]         }
  [21:15:35.582]     }
  [21:15:35.582]     if (base::is.na(TRUE)) {
  [21:15:35.582]     }
  [21:15:35.582]     else {
  [21:15:35.582]         if (TRUE) {
  [21:15:35.582]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.582]                 open = "w")
  [21:15:35.582]         }
  [21:15:35.582]         else {
  [21:15:35.582]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.582]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.582]         }
  [21:15:35.582]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.582]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.582]             base::sink(type = "output", split = FALSE)
  [21:15:35.582]             base::close(...future.stdout)
  [21:15:35.582]         }, add = TRUE)
  [21:15:35.582]     }
  [21:15:35.582]     ...future.frame <- base::sys.nframe()
  [21:15:35.582]     ...future.conditions <- base::list()
  [21:15:35.582]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.582]     ...future.result <- base::tryCatch({
  [21:15:35.582]         base::withCallingHandlers({
  [21:15:35.582]             ...future.value <- base::withVisible(base::local({
  [21:15:35.582]                 sample(x, size = 1L)
  [21:15:35.582]             }))
  [21:15:35.582]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.582]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.582]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.582]                 version = "1.8")
  [21:15:35.582]         }, condition = base::local({
  [21:15:35.582]             c <- base::c
  [21:15:35.582]             inherits <- base::inherits
  [21:15:35.582]             invokeRestart <- base::invokeRestart
  [21:15:35.582]             length <- base::length
  [21:15:35.582]             list <- base::list
  [21:15:35.582]             seq.int <- base::seq.int
  [21:15:35.582]             signalCondition <- base::signalCondition
  [21:15:35.582]             sys.calls <- base::sys.calls
  [21:15:35.582]             Sys.time <- base::Sys.time
  [21:15:35.582]             `[[` <- base::`[[`
  [21:15:35.582]             `+` <- base::`+`
  [21:15:35.582]             `<<-` <- base::`<<-`
  [21:15:35.582]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.582]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.582]                   3L)]
  [21:15:35.582]             }
  [21:15:35.582]             function(cond) {
  [21:15:35.582]                 if (inherits(cond, "error")) {
  [21:15:35.582]                   sessionInformation <- function() {
  [21:15:35.582]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.582]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.582]                       search = base::search(), system = base::Sys.info())
  [21:15:35.582]                   }
  [21:15:35.582]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.582]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.582]                     cond$call), session = sessionInformation(), 
  [21:15:35.582]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.582]                   signalCondition(cond)
  [21:15:35.582]                 }
  [21:15:35.582]                 else if (inherits(cond, "condition")) {
  [21:15:35.582]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.582]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.582]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.582]                   if (!signal) {
  [21:15:35.582]                     muffleCondition <- function (cond) 
  [21:15:35.582]                     {
  [21:15:35.582]                       inherits <- base::inherits
  [21:15:35.582]                       invokeRestart <- base::invokeRestart
  [21:15:35.582]                       muffled <- FALSE
  [21:15:35.582]                       if (inherits(cond, "message")) {
  [21:15:35.582]                         invokeRestart("muffleMessage")
  [21:15:35.582]                         muffled <- TRUE
  [21:15:35.582]                       }
  [21:15:35.582]                       else if (inherits(cond, "warning")) {
  [21:15:35.582]                         invokeRestart("muffleWarning")
  [21:15:35.582]                         muffled <- TRUE
  [21:15:35.582]                       }
  [21:15:35.582]                       else if (inherits(cond, "condition")) {
  [21:15:35.582]                         computeRestarts <- base::computeRestarts
  [21:15:35.582]                         grepl <- base::grepl
  [21:15:35.582]                         is.null <- base::is.null
  [21:15:35.582]                         restarts <- computeRestarts(cond)
  [21:15:35.582]                         for (restart in restarts) {
  [21:15:35.582]                           name <- restart$name
  [21:15:35.582]                           if (is.null(name)) 
  [21:15:35.582]                             next
  [21:15:35.582]                           if (!grepl("^muffle", name)) 
  [21:15:35.582]                             next
  [21:15:35.582]                           invokeRestart(restart)
  [21:15:35.582]                           muffled <- TRUE
  [21:15:35.582]                           break
  [21:15:35.582]                         }
  [21:15:35.582]                       }
  [21:15:35.582]                       invisible(muffled)
  [21:15:35.582]                     }
  [21:15:35.582]                     muffleCondition(cond)
  [21:15:35.582]                   }
  [21:15:35.582]                 }
  [21:15:35.582]             }
  [21:15:35.582]         }))
  [21:15:35.582]     }, error = function(ex) {
  [21:15:35.582]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.582]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.582]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.582]     }, finally = {
  [21:15:35.582]         {
  [21:15:35.582]             {
  [21:15:35.582]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.582]             }
  [21:15:35.582]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.582]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.582]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.582]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.582]             {
  [21:15:35.582]                 if (substitute) 
  [21:15:35.582]                   expr <- substitute(expr)
  [21:15:35.582]                 if (is.function(workers)) 
  [21:15:35.582]                   workers <- workers()
  [21:15:35.582]                 workers <- as.integer(workers)
  [21:15:35.582]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.582]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.582]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.582]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.582]                     local = TRUE, label = label, ...))
  [21:15:35.582]                 }
  [21:15:35.582]                 oopts <- options(mc.cores = workers)
  [21:15:35.582]                 on.exit(options(oopts))
  [21:15:35.582]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.582]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.582]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.582]                   label = label, ...)
  [21:15:35.582]                 if (!future$lazy) 
  [21:15:35.582]                   future <- run(future)
  [21:15:35.582]                 invisible(future)
  [21:15:35.582]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.582]         }
  [21:15:35.582]         base::options(...future.oldOptions)
  [21:15:35.582]     })
  [21:15:35.582]     Sys.time
  [21:15:35.582]     if (base::is.na(TRUE)) {
  [21:15:35.582]     }
  [21:15:35.582]     else {
  [21:15:35.582]         base::sink(type = "output", split = FALSE)
  [21:15:35.582]         if (TRUE) {
  [21:15:35.582]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.582]         }
  [21:15:35.582]         else {
  [21:15:35.582]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.582]         }
  [21:15:35.582]         base::close(...future.stdout)
  [21:15:35.582]         ...future.stdout <- NULL
  [21:15:35.582]     }
  [21:15:35.582]     ...future.result$conditions <- ...future.conditions
  [21:15:35.582]     ...future.result
  [21:15:35.582] }
  [21:15:35.603] requestCore(): workers = 2
  [21:15:35.604] Poll #1 (0): usedCores() = 2, workers = 2
  [21:15:35.619] MulticoreFuture started
  [21:15:35.621] getGlobalsAndPackages() ...
  [21:15:35.621] Searching for globals...
  [21:15:35.633] plan(): Setting new future strategy stack:
  [21:15:35.634] List of future strategies:
  [21:15:35.634] 1. sequential:
  [21:15:35.634]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.634]    - tweaked: FALSE
  [21:15:35.634]    - call: NULL
  [21:15:35.642] plan(): nbrOfWorkers() = 1
  [21:15:35.648] - globals found: [3] '{', 'sample', 'x'
  [21:15:35.649] Searching for globals ... DONE
  [21:15:35.649] Resolving globals: FALSE
  [21:15:35.651] The total size of the 1 globals is 64 bytes (64 bytes)
  [21:15:35.652] - globals: [1] 'x'
  [21:15:35.652] 
  [21:15:35.653] getGlobalsAndPackages() ... DONE
  [21:15:35.657] Packages needed by the future expression (n = 0): <none>
  [21:15:35.657] Packages needed by future strategies (n = 0): <none>
  [21:15:35.662] plan(): Setting new future strategy stack:
  [21:15:35.662] List of future strategies:
  [21:15:35.662] 1. multicore:
  [21:15:35.662]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.662]    - tweaked: FALSE
  [21:15:35.662]    - call: plan(strategy)
  [21:15:35.665] plan(): nbrOfWorkers() = 2
  [21:15:35.679] {
  [21:15:35.679]     {
  [21:15:35.679]         ...future.startTime <- base::Sys.time()
  [21:15:35.679]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [21:15:35.679]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [21:15:35.679]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [21:15:35.679]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [21:15:35.679]             future.resolve.recursive = NULL, width = 80L)
  [21:15:35.679]         {
  [21:15:35.679]             {
  [21:15:35.679]                 {
  [21:15:35.679]                   {
  [21:15:35.679]                     base::local({
  [21:15:35.679]                       has_future <- base::requireNamespace("future", 
  [21:15:35.679]                         quietly = TRUE)
  [21:15:35.679]                       version <- if (has_future) 
  [21:15:35.679]                         utils::packageVersion("future")
  [21:15:35.679]                       else NULL
  [21:15:35.679]                       if (!has_future || version < "1.8.0") {
  [21:15:35.679]                         info <- base::c(r_version = base::gsub("R version ", 
  [21:15:35.679]                           "", base::R.version$version.string), 
  [21:15:35.679]                           platform = base::sprintf("%s (%s-bit)", 
  [21:15:35.679]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [21:15:35.679]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [21:15:35.679]                             "release", "version")], collapse = " "), 
  [21:15:35.679]                           hostname = base::Sys.info()[["nodename"]])
  [21:15:35.679]                         info <- base::sprintf("%s: %s", base::names(info), 
  [21:15:35.679]                           info)
  [21:15:35.679]                         info <- base::paste(info, collapse = "; ")
  [21:15:35.679]                         if (!has_future) {
  [21:15:35.679]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [21:15:35.679]                             info)
  [21:15:35.679]                         }
  [21:15:35.679]                         else {
  [21:15:35.679]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [21:15:35.679]                             info, version)
  [21:15:35.679]                         }
  [21:15:35.679]                         base::stop(msg)
  [21:15:35.679]                       }
  [21:15:35.679]                     })
  [21:15:35.679]                   }
  [21:15:35.679]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [21:15:35.679]                   base::options(mc.cores = 1L)
  [21:15:35.679]                 }
  [21:15:35.679]                 base::assign(".Random.seed", c(10407L, -860779432L, 
  [21:15:35.679]                 1203324979L, -1993452634L, -1372834584L, 704149361L, 
  [21:15:35.679]                 1348506385L), envir = base::globalenv(), inherits = FALSE)
  [21:15:35.679]             }
  [21:15:35.679]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [21:15:35.679]         }
  [21:15:35.679]     }
  [21:15:35.679]     if (base::is.na(TRUE)) {
  [21:15:35.679]     }
  [21:15:35.679]     else {
  [21:15:35.679]         if (TRUE) {
  [21:15:35.679]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [21:15:35.679]                 open = "w")
  [21:15:35.679]         }
  [21:15:35.679]         else {
  [21:15:35.679]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [21:15:35.679]                 windows = "NUL", "/dev/null"), open = "w")
  [21:15:35.679]         }
  [21:15:35.679]         base::sink(...future.stdout, type = "output", split = FALSE)
  [21:15:35.679]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [21:15:35.679]             base::sink(type = "output", split = FALSE)
  [21:15:35.679]             base::close(...future.stdout)
  [21:15:35.679]         }, add = TRUE)
  [21:15:35.679]     }
  [21:15:35.679]     ...future.frame <- base::sys.nframe()
  [21:15:35.679]     ...future.conditions <- base::list()
  [21:15:35.679]     ...future.rng <- base::globalenv()$.Random.seed
  [21:15:35.679]     ...future.result <- base::tryCatch({
  [21:15:35.679]         base::withCallingHandlers({
  [21:15:35.679]             ...future.value <- base::withVisible(base::local({
  [21:15:35.679]                 sample(x, size = 1L)
  [21:15:35.679]             }))
  [21:15:35.679]             future::FutureResult(value = ...future.value$value, 
  [21:15:35.679]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.679]                   ...future.rng), started = ...future.startTime, 
  [21:15:35.679]                 version = "1.8")
  [21:15:35.679]         }, condition = base::local({
  [21:15:35.679]             c <- base::c
  [21:15:35.679]             inherits <- base::inherits
  [21:15:35.679]             invokeRestart <- base::invokeRestart
  [21:15:35.679]             length <- base::length
  [21:15:35.679]             list <- base::list
  [21:15:35.679]             seq.int <- base::seq.int
  [21:15:35.679]             signalCondition <- base::signalCondition
  [21:15:35.679]             sys.calls <- base::sys.calls
  [21:15:35.679]             Sys.time <- base::Sys.time
  [21:15:35.679]             `[[` <- base::`[[`
  [21:15:35.679]             `+` <- base::`+`
  [21:15:35.679]             `<<-` <- base::`<<-`
  [21:15:35.679]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [21:15:35.679]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [21:15:35.679]                   3L)]
  [21:15:35.679]             }
  [21:15:35.679]             function(cond) {
  [21:15:35.679]                 if (inherits(cond, "error")) {
  [21:15:35.679]                   sessionInformation <- function() {
  [21:15:35.679]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [21:15:35.679]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [21:15:35.679]                       search = base::search(), system = base::Sys.info())
  [21:15:35.679]                   }
  [21:15:35.679]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.679]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [21:15:35.679]                     cond$call), session = sessionInformation(), 
  [21:15:35.679]                     timestamp = Sys.time(), signaled = 0L)
  [21:15:35.679]                   signalCondition(cond)
  [21:15:35.679]                 }
  [21:15:35.679]                 else if (inherits(cond, "condition")) {
  [21:15:35.679]                   signal <- FALSE && inherits(cond, character(0))
  [21:15:35.679]                   ...future.conditions[[length(...future.conditions) + 
  [21:15:35.679]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [21:15:35.679]                   if (!signal) {
  [21:15:35.679]                     muffleCondition <- function (cond) 
  [21:15:35.679]                     {
  [21:15:35.679]                       inherits <- base::inherits
  [21:15:35.679]                       invokeRestart <- base::invokeRestart
  [21:15:35.679]                       muffled <- FALSE
  [21:15:35.679]                       if (inherits(cond, "message")) {
  [21:15:35.679]                         invokeRestart("muffleMessage")
  [21:15:35.679]                         muffled <- TRUE
  [21:15:35.679]                       }
  [21:15:35.679]                       else if (inherits(cond, "warning")) {
  [21:15:35.679]                         invokeRestart("muffleWarning")
  [21:15:35.679]                         muffled <- TRUE
  [21:15:35.679]                       }
  [21:15:35.679]                       else if (inherits(cond, "condition")) {
  [21:15:35.679]                         computeRestarts <- base::computeRestarts
  [21:15:35.679]                         grepl <- base::grepl
  [21:15:35.679]                         is.null <- base::is.null
  [21:15:35.679]                         restarts <- computeRestarts(cond)
  [21:15:35.679]                         for (restart in restarts) {
  [21:15:35.679]                           name <- restart$name
  [21:15:35.679]                           if (is.null(name)) 
  [21:15:35.679]                             next
  [21:15:35.679]                           if (!grepl("^muffle", name)) 
  [21:15:35.679]                             next
  [21:15:35.679]                           invokeRestart(restart)
  [21:15:35.679]                           muffled <- TRUE
  [21:15:35.679]                           break
  [21:15:35.679]                         }
  [21:15:35.679]                       }
  [21:15:35.679]                       invisible(muffled)
  [21:15:35.679]                     }
  [21:15:35.679]                     muffleCondition(cond)
  [21:15:35.679]                   }
  [21:15:35.679]                 }
  [21:15:35.679]             }
  [21:15:35.679]         }))
  [21:15:35.679]     }, error = function(ex) {
  [21:15:35.679]         base::structure(base::list(value = NULL, visible = NULL, 
  [21:15:35.679]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [21:15:35.679]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [21:15:35.679]     }, finally = {
  [21:15:35.679]         {
  [21:15:35.679]             {
  [21:15:35.679]                 base::options(mc.cores = ...future.mc.cores.old)
  [21:15:35.679]             }
  [21:15:35.679]             future::plan(list(function (expr, envir = parent.frame(), 
  [21:15:35.679]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [21:15:35.679]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [21:15:35.679]                 earlySignal = FALSE, label = NULL, ...) 
  [21:15:35.679]             {
  [21:15:35.679]                 if (substitute) 
  [21:15:35.679]                   expr <- substitute(expr)
  [21:15:35.679]                 if (is.function(workers)) 
  [21:15:35.679]                   workers <- workers()
  [21:15:35.679]                 workers <- as.integer(workers)
  [21:15:35.679]                 stop_if_not(is.finite(workers), workers >= 1L)
  [21:15:35.679]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [21:15:35.679]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [21:15:35.679]                     lazy = lazy, seed = seed, globals = globals, 
  [21:15:35.679]                     local = TRUE, label = label, ...))
  [21:15:35.679]                 }
  [21:15:35.679]                 oopts <- options(mc.cores = workers)
  [21:15:35.679]                 on.exit(options(oopts))
  [21:15:35.679]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [21:15:35.679]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [21:15:35.679]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [21:15:35.679]                   label = label, ...)
  [21:15:35.679]                 if (!future$lazy) 
  [21:15:35.679]                   future <- run(future)
  [21:15:35.679]                 invisible(future)
  [21:15:35.679]             }), .cleanup = FALSE, .init = FALSE)
  [21:15:35.679]         }
  [21:15:35.679]         base::options(...future.oldOptions)
  [21:15:35.679]     })
  [21:15:35.679]     Sys.time
  [21:15:35.679]     if (base::is.na(TRUE)) {
  [21:15:35.679]     }
  [21:15:35.679]     else {
  [21:15:35.679]         base::sink(type = "output", split = FALSE)
  [21:15:35.679]         if (TRUE) {
  [21:15:35.679]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [21:15:35.679]         }
  [21:15:35.679]         else {
  [21:15:35.679]             ...future.result["stdout"] <- base::list(NULL)
  [21:15:35.679]         }
  [21:15:35.679]         base::close(...future.stdout)
  [21:15:35.679]         ...future.stdout <- NULL
  [21:15:35.679]     }
  [21:15:35.679]     ...future.result$conditions <- ...future.conditions
  [21:15:35.679]     ...future.result
  [21:15:35.679] }
  [21:15:35.683] requestCore(): workers = 2
  [21:15:35.684] Poll #1 (0): usedCores() = 2, workers = 2
  [21:15:35.698] MulticoreFuture started
  [21:15:35.699] resolve() on list ...
  [21:15:35.700]  recursive: 0
  [21:15:35.700]  length: 4
  [21:15:35.700] 
  [21:15:35.701] Future #1
  [21:15:35.701] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [21:15:35.702] - nx: 4
  [21:15:35.702] - relay: TRUE
  [21:15:35.702] - stdout: TRUE
  [21:15:35.702] - signal: TRUE
  [21:15:35.703] - resignal: FALSE
  [21:15:35.703] - force: TRUE
  [21:15:35.703] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:35.703] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
  [21:15:35.704]  - until=1
  [21:15:35.704]  - relaying element #1
  [21:15:35.705] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.705] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.705] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [21:15:35.706]  length: 3 (resolved future 1)
  [21:15:35.706] Future #2
  [21:15:35.706] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [21:15:35.707] - nx: 4
  [21:15:35.707] - relay: TRUE
  [21:15:35.707] - stdout: TRUE
  [21:15:35.707] - signal: TRUE
  [21:15:35.708] - resignal: FALSE
  [21:15:35.708] - force: TRUE
  [21:15:35.708] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.708] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
  [21:15:35.709]  - until=2
  [21:15:35.709]  - relaying element #2
  [21:15:35.718] plan(): Setting new future strategy stack:
  [21:15:35.718] List of future strategies:
  [21:15:35.718] 1. sequential:
  [21:15:35.718]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [21:15:35.718]    - tweaked: FALSE
  [21:15:35.718]    - call: NULL
  [21:15:35.720] plan(): nbrOfWorkers() = 1
  [21:15:35.721] plan(): Setting new future strategy stack:
  [21:15:35.722] List of future strategies:
  [21:15:35.722] 1. multicore:
  [21:15:35.722]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [21:15:35.722]    - tweaked: FALSE
  [21:15:35.722]    - call: plan(strategy)
  [21:15:35.724] plan(): nbrOfWorkers() = 2
  [21:15:35.709] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.726] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.726] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [21:15:35.727]  length: 2 (resolved future 2)
  [21:15:35.728] Future #3
  [21:15:35.730] signalConditionsASAP(MulticoreFuture, pos=3) ...
  [21:15:35.730] - nx: 4
  [21:15:35.731] - relay: TRUE
  [21:15:35.731] - stdout: TRUE
  [21:15:35.731] - signal: TRUE
  [21:15:35.732] - resignal: FALSE
  [21:15:35.732] - force: TRUE
  [21:15:35.732] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.733] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
  [21:15:35.733]  - until=3
  [21:15:35.734]  - relaying element #3
  [21:15:35.734] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.735] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
  [21:15:35.735] signalConditionsASAP(MulticoreFuture, pos=3) ... done
  [21:15:35.736]  length: 1 (resolved future 3)
  [21:15:35.736] Future #4
  [21:15:35.738] signalConditionsASAP(MulticoreFuture, pos=4) ...